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 def. Um método modificador muda a forma como os objetos funcionam.

Fill-in

Um dos argumentos é um objeto vazio que é preenchido em 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.

Exemplo:

Neste exemplo escrevemos três métodos diferentes: Pure function, Modifier e um fill-in, e manipulamos objetos utilizando estes métodos.

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# objetos.py

class Retangulo:
    x = 0
    y = 0
    altura = 0
    largura = 0

    # Workaround para efeito de Overload
    # Constructor ()
    def __init__ (self, x= None, y= None, altura= None, largura= None):
        if (x is not None) and (y is not None) and (altura is not None) and (largura is not None):
            self.x = x
            self.y = y
            self.altura = altura
            self.largura = largura

    def imprimeRet(self):
         print "X=", self.x, "Y =", self.y, "Altura=", self.altura, "Largura=", self.largura

# Método Pure Function
def maxRet(ret = Retangulo(), altura = 0, largura = 0):
    if ( ret.altura <= altura) and (ret.largura <= largura):
        return True
    else:
        return False

# Método Modifier
def posicao(ret = Retangulo(), x = 0, y = 0):
    ret.x = ret.x + x
    ret.y = ret.y + y

# Método Fill-in
def modRet(r1 = Retangulo(), r2 = Retangulo(), r3 = Retangulo()):
    r1.x       =  r2.x      + r3.x
    r1.y       =  r2.y      + r3.y
    r1.altura  = r2.altura  + r3.altura
    r1.largura = r2.largura + r3.largura

ret1 = Retangulo(50,50,200,300)
ret2 = Retangulo(15,15,120,150)
ret3 = Retangulo() 
ret1.imprimeRet()

resultado =  maxRet(ret1, 500, 600)
print "Retangulo está dentro do limite maximo:", resultado
print ""

print "Modifica posição do retangulo:"
posicao(ret1, 20, 20)
ret1.imprimeRet()

print ""
print "Modifica tamanho do retangulo:"
modRet(ret3, ret1, ret2);
ret3.imprimeRet()

raw_input()