Pure Function
Usa os objetos como argumentos, mas não os modifica. o valor de retorno é ou um primitivo ou um novo objeto criado dentro do método.
Um método é considerado uma função pura se o resultado depender apenas dos argumentos, e não ter efeitos colaterais, como modificar um argumento ou imprimir algo. O único resultado de chamar uma função pura é o seu valor de retorno.
Na transformação funcional pura, um conjunto de funções, chamadas funções puras, definem a forma de como transformar um conjunto de dados estruturados a partir de sua forma original para outra forma. A palavra “pura” indica que as funções são combináveis, que exige que elas sejam:
Auto-suficiente, de modo que elas podem ser livremente ordenada e rearranjada sem emaranhamento ou interdependências com o resto do programa. Transformações puras não têm conhecimento ou efeito sobre o meio ambiente. Ou seja, as funções utilizadas para a transformação não tem efeitos colaterais.
Sem mudança de estado, de modo que a execução da mesma função ou conjunto específico de funções na mesma entrada sempre resultará na mesma saída. Transformações puras não têm memória do seu uso anterior. Funções puras ajudar a gerenciar a complexidade dos grandes projetos.
Modifiers
Usa objetos como argumentos e modifica alguns elementos ou todos eles. Muitas vezes, retorna uma void. Um método modificador muda a forma como os objetos funcionam.
Fill-in
Um dos argumentos é um objeto vazio que é preenchido pelo método. Tecnicamente, este método também é um tipo de Modifier.
Melhores Praticas
É recomendado que você escreva funções puras sempre que for razoável, e recorra aos Modifiers e Fill-ins apenas se houver uma grande vantagem.
Métodos Modifiers e Fill-in são eficientes porque eles não têm que criar novos objetos. Mas se torna mais difícil de isolar partes de um programa, e em grandes projetos podem causar erros que são difíceis de encontrar.
Em síntese estes conceitos passam a substituir a nomenclatura das funções e procedimentos das linguagens de programação procedural, por serem métodos integrantes de objetos e não mais procedimentos ou funções auto suficientes, porem ainda são estruturalmente iguais.
Exemplo:
Neste exemplo escrevemos três métodos diferentes: Pure function, Modifier e um fill-in, e manipulamos objetos utilizando estes métodos.
Java
Classe #1 – Principal
public class Metodos
{
// Método - Pure Function
static boolean maxRet(Retangulo ret, int altura, int largura)
{
if ((ret.altura <= altura) && (ret.largura <= largura))
{
return true;
}
else
{
return false;
}
}
// Método - Modifiers
static void posicao(Retangulo ret, int x, int y)
{
ret.x = ret.x + x;
ret.y = ret.y + y;
}
// Método - Fill-in
static void modRet(Retangulo r1, Retangulo r2, Retangulo r3)
{
r1.x = r2.x + r3.x;
r1.y = r2.y + r3.y;
r1.altura = r2.altura + r3.altura;
r1.largura = r2.largura + r3.largura;
}
public static void main(String[] args)
{
Retangulo ret1 = new Retangulo(50,50,200,300);
Retangulo ret2 = new Retangulo(15,15,120,150);
Retangulo ret3 = new Retangulo();
ret1.imprimeRet();
System.out.println("Retangulo está dentro do limite maximo:" + maxRet(ret1, 500, 600));
System.out.println();
System.out.println("Modifica posição do retangulo:");
posicao(ret1, 20, 20);
ret1.imprimeRet();
System.out.println();
System.out.println("Modifica tamanho do retangulo:");
modRet(ret3, ret1, ret2);
ret3.imprimeRet();
}
}
Classe #2 – Retangulo
public class Retangulo
{
public int x;
public int y;
public int altura;
public int largura;
public Retangulo ()
{
}
public Retangulo (int x, int y, int altura, int largura)
{
this.x = x;
this.y = y;
this.altura = altura;
this.largura = largura;
}
public void imprimeRet()
{
System.out.println("X =" + x + " Y= " + y + " Altura="+ altura + " Largura=" + largura );
}
}
C++
Classe #1 – Principal
include "stdafx.h"
#include <iostream>
#include <string>
#include "Retangulo.h"
static bool maxRet(Retangulo& ret, int altura, int largura)
{
if ((ret.altura <= altura) && (ret.largura <= largura))
{
return true;
}
else
{
return false;
}
}
// Método - Modifiers
static void posicao(Retangulo& ret, int x, int y)
{
ret.x = ret.x + x; ret.y = ret.y + y;
}
// Método - Fill-in
static void modRet(Retangulo& r1, Retangulo& r2, Retangulo& r3)
{
r1.x = r2.x + r3.x;
r1.y = r2.y + r3.y;
r1.altura = r2.altura + r3.altura;
r1.largura = r2.largura + r3.largura;
}
int _tmain(int argc, _TCHAR* argv[])
{
Retangulo ret1 (50, 50, 200, 300);
Retangulo ret2 (15, 15, 120, 150);
Retangulo ret3 (0,0,0,0);
ret1.imprimeRet();
cout << "Retangulo está dentro do limite maximo:" << maxRet(ret1, 500, 600) << endl;
cout << endl;
cout << "Modifica posição do retangulo:" << endl; posicao(ret1, 20, 20);
ret1.imprimeRet();
cout << endl;
cout << "Modifica tamanho do retangulo:" << endl; modRet(ret3, ret1, ret2);
ret3.imprimeRet();
system("pause");
return 0;
}
Classe #2 – Retangulo
#include "stdafx.h"
#include <iostream>
using namespace std;
class Retangulo
{
public:
int x;
int y;
int altura;
int largura;
Retangulo()
{ }
Retangulo(int x, int y, int altura, int largura)
{
this->x = x;
this->y = y;
this->altura = altura;
this->largura = largura;
}
void imprimeRet()
{
cout << "X =" << x << " Y= " << y << " Altura=" << altura << " Largura=" << largura << endl;
}
};
C#
Classe #1 – Principal
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DesenvolvimentoAberto
{
class Program
{
// Método - Pure Function
static Boolean maxRet(Retangulo ret, int altura, int largura)
{
if ((ret.altura <= altura) && (ret.largura <= largura))
{
return true;
}
else
{
return false;
}
}
// Método - Modifiers
static void posicao(Retangulo ret, int x, int y)
{
ret.x = ret.x + x;
ret.y = ret.y + y;
}
// Método - Fill-in
static void modRet(Retangulo r1, Retangulo r2, Retangulo r3)
{
r1.x = r2.x + r3.x;
r1.y = r2.y + r3.y;
r1.altura = r2.altura + r3.altura;
r1.largura = r2.largura + r3.largura;
}
static void Main(string[] args)
{
Retangulo ret1 = new Retangulo(50,50,200,300);
Retangulo ret2 = new Retangulo(15,15,120,150);
Retangulo ret3 = new Retangulo();
ret1.imprimeRet();
Console.WriteLine("Retangulo está dentro do limite maximo:" + maxRet(ret1, 500, 600));
Console.WriteLine();
Console.WriteLine("Modifica posição do retangulo:");
posicao(ret1, 20, 20);
ret1.imprimeRet();
Console.WriteLine();
Console.WriteLine("Modifica tamanho do retangulo:");
modRet(ret3, ret1, ret2);
ret3.imprimeRet();
Console.ReadKey();
}
}
}
Classe #2 – Retangulo
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DesenvolvimentoAberto
{
class Retangulo
{
public int x;
public int y;
public int altura;
public int largura;
public Retangulo()
{
}
public Retangulo(int x, int y, int altura, int largura)
{
this.x = x;
this.y = y;
this.altura = altura;
this.largura = largura;
}
public void imprimeRet()
{
Console.WriteLine("X =" + x + " Y= " + y + " Altura="+ altura + " Largura=" + largura );
}
}
}
Ricardo Mantovani
Desenvolvimento Código Aberto 