Desenvolvimento Código Aberto

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 );
             }
     }
 }