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 ajudam a gerenciar a complexidade dos grandes projetos.

Modifiers

Usa objetos como argumentos e modifica alguns elementos ou todos eles. Muitas vezes, retorna um method. 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.

Abap

*&---------------------------------------------------------------------*
*& Report  ZOBJETOS_M
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Objetos - Métodos - Pure Function, Modifier e Fill-in
*&---------------------------------------------------------------------*

REPORT  ZOBJETOS_M.

* Classe Retangulo
Class Retangulo DEFINITION.
PUBLIC SECTION.

DATA : x       TYPE i,
       y       TYPE i,
       altura  TYPE i,
       largura TYPE i.

METHODS:

" Workaround para efeito Overload
CONSTRUCTOR IMPORTING
       X       TYPE i OPTIONAL
       Y       TYPE i OPTIONAL
       altura  TYPE i OPTIONAL
       largura TYPE i OPTIONAL,

imprimeRet.

ENDCLASS.

Class RETANGULO IMPLEMENTATION.

METHOD CONSTRUCTOR.
   me->X       = X.
   me->Y       = Y.
   me->ALTURA  = ALTURA.
   me->LARGURA = LARGURA.
ENDMETHOD.

METHOD IMPRIMERET.
   WRITE: / 'X=', me->X, 'Y=', me->Y, 'Altura=', me->ALTURA, 'Largura=', me->LARGURA.
ENDMETHOD.

ENDCLASS.

* Classe Métodos
CLASS METODOS DEFINITION INHERITING FROM RETANGULO.
PUBLIC SECTION.

METHODS:

CONSTRUCTOR,

maxRet   IMPORTING
 ret     TYPE REF TO RETANGULO
 altura  TYPE i
 largura TYPE i
         RETURNING VALUE(resultado) TYPE abap_bool,

posicao  IMPORTING
     ret TYPE REF TO RETANGULO
     x   TYPE i
     y   TYPE i,

modRet  IMPORTING
     r1 TYPE REF TO RETANGULO
     r2 TYPE REF TO RETANGULO
     r3 TYPE REF TO RETANGULO.

ENDCLASS.

CLASS METODOS IMPLEMENTATION.

METHOD CONSTRUCTOR.
     CALL METHOD SUPER->CONSTRUCTOR.
ENDMETHOD.

* Método Pure Function
METHOD MAXRET.
  IF  me->altura LT altura AND me->largura LT largura.
    RESULTADO = abap_true.
  ELSE.
    RESULTADO = abap_false.
  ENDIF.
ENDMETHOD.

* Método Modifier
METHOD POSICAO.
   RET->X = RET->X + X.
   RET->Y = RET->Y + Y.
ENDMETHOD.

* Método Fill-in
METHOD MODRET.
   R1->X = R2->X + R3->X.
   R1->Y = R2->Y + R3->Y.
   R1->ALTURA = R2->ALTURA + R3->ALTURA.
   R1->LARGURA =  R2->LARGURA +  R3->LARGURA.
ENDMETHOD.

ENDCLASS.

START-OF-SELECTION.

* Cria Instâncias e Objetos

DATA RET1 TYPE REF TO RETANGULO.
DATA RET2 TYPE REF TO RETANGULO.
DATA RET3 TYPE REF TO RETANGULO.
DATA MET1 TYPE REF TO METODOS.
DATA REST TYPE ABAP_BOOL.

* Objetos instanciados contrutores

CREATE OBJECT RET1 EXPORTING X = 50 Y = 50 ALTURA = 200 LARGURA = 300.
CREATE OBJECT RET2 EXPORTING X = 15 Y = 15 ALTURA = 120 LARGURA = 150.

* Objeto instanciado Overload

CREATE OBJECT RET3.

* Objeto de Metodos

CREATE OBJECT MET1.

* Manipula Método Pure Function

RET1->IMPRIMERET( ).
MET1->MAXRET( exporting RET = RET1 ALTURA = 500 LARGURA = 600 RECEIVING RESULTADO = REST  ).

IF REST = abap_true.
   WRITE : / 'Retangulo está dentro do limite maximo: TRUE'.
ELSE.
   WRITE : / 'Retangulo está dentro do limite maximo: FALSE'.
ENDIF.

* Manipula Método Modifier
WRITE : / .
WRITE : / 'Modifica posição do retangulo:'.
MET1->POSICAO( exporting RET = RET1 X   = 20 Y   = 20 ).
RET1->IMPRIMERET( ).

* Manipula Métodos Fill-in
WRITE : / .
WRITE : / 'Modifica tamanho do retangulo:'.
MET1->MODRET( exporting R1 = RET3 R2 = RET1 R3 = RET2 ).
RET3->IMPRIMERET( ).