São métodos encadeados que requerem apenas um parâmetro por método equivalente ao currying?

15
Tenho andado a brincar com o Ruby ultimamente e comecei a pensar se, nas linguagens orientadas a objetos puras (e mesmo naquelas que não são puras), fazer métodos que usem apenas um parâmetro e depois se encadearem é equivalente a currying em linguagens. com um estilo funcional? Se não, por que não? Eu apreciaria uma resposta detalhada e rigorosa sobre o assunto.

    
por World Engineer 03.02.2013 / 04:20
fonte

1 resposta

14

O encadeamento de métodos em linguagens orientadas a objetos é um pouco diferente do currying. Por definição , o resultado do curry é uma forma mais restrita da função original . Por convenção , o resultado do encadeamento de métodos é uma forma modificada do objeto original (geralmente não funcional) . O encadeamento de métodos pode ser usado com métodos não relacionados na mesma classe, enquanto o currying envolve o retorno de uma função em que um ou mais parâmetros da função original são fixos (predeterminados).

Em Java, o encadeamento de métodos é como:

String myString = new StringBuilder("Hi ").append(firstName)
                                          .append(" ")
                                          .append(lastName)
                                          .append("!")
                                          .toString();

Assim, cada uma dessas chamadas do método .append () retorna um ponteiro para o objeto StringBuilder anônimo. Este objeto é concluído após cada .append () e não é uma função.

Por outro lado, no Scala, a aplicação parcial ou curry é como:

def simple(x:Int, y:Int, z:Int) = x * (y + z)
val simpler = simple(2, _:Int, _:Int)
simpler(3, 4) => 14

(amostra retirada do blog de Daniel Yankowsky )

simpler() neste exemplo é uma função de wrapper para simple() . simpler() ainda é uma função que usa mais parâmetros antes de poder avaliar qualquer coisa, exceto uma versão mais limitada de si mesma.

EDIT: Lendo isso um dia depois, acho que "wrapper-function" é a chave. O currying ou aplicativo parcial pode ser melhor simulado em Java com métodos de wrapper.

public interface Simpler {
    public int apply(int y, int z);
}

public class Simple {
    public int apply(int x, int y, int z) { return x * (y + z); }

    public Simpler partiallyApply(final int x) {
        final simple = this;
        return new Simpler() {
            @Override
            public int apply(int y, int z) {
                // x is the final int parameter to partiallyApply()
                simple.apply(x, y, z);
            }
        }
    }
}

: END-EDIT

O encadeamento de métodos pode ser semelhante a aplicação parcial ou curry, mas só pode ser equivalente a métodos que retornam outros métodos (procure por Functors) e, em seguida, os métodos precisam ser configurados com tipos de retorno que modelam significativamente currying ou parcial aplicação.

O encadeamento de métodos é mais usado para implementar algo como avaliação lenta, como é feito com o padrão de design "Construtor" e o novo Interfaces da biblioteca de coleções no Java 8 .

Espero que ajude.

    
por 03.02.2013 / 06:31
fonte