I metodi concatenati che richiedono solo un parametro per metodo equivalgono al curry?

Ultimamente ho avuto a che fare con Ruby e mi sono ritrovato a chiedermi se in linguaggi orientati agli oggetti puri (e anche quelli che non sono puri) fare metodi che prendessero solo un parametro e poi si incatenassero equivale a curry in linguaggi con un stile? In caso contrario, perché no? Gradirei una risposta dettagliata, anche rigorosa, sull'argomento.

Il concatenamento di metodi in linguaggi orientati agli oggetti è leggermente diverso dal curry. Per definizione , il risultato del curry è una forma più limitata della funzione originale . Per convenzione , il risultato del concatenamento del metodo è una forma modificata dell'oggetto originale (generalmente non funzionale) . Il concatenamento dei metodi può essere utilizzato con metodi non correlati sulla stessa classe, mentre il curry comporta la restituzione di una funzione in cui uno o più parametri della funzione originale sono fissi (predeterminati).

In Java, il concatenamento dei metodi è simile a:

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

Quindi, ognuna di quelle chiamate al metodo .append () restituisce un puntatore all'oggetto anonimo StringBuilder. Questo oggetto è completo dopo ogni .append () e non è una funzione.

Al contrario, in Scala, l'applicazione parziale o il curry è come:

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

(Esempio tratto dal blog di Daniel Yankowsky )

simpler()in questo esempio è una funzione wrapper per simple(). simpler()è ancora una funzione che accetta più parametri prima di poter valutare se non una versione più limitata di se stesso.

EDIT: leggendo questo un giorno dopo, penso che la "funzione wrapper" sia la chiave. L'applicazione al curry o parziale potrebbe essere simulata al meglio in Java con metodi 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

Il concatenamento dei metodi può essere simile all'applicazione parziale o al curry, ma può essere equivalente solo ai metodi che restituiscono altri metodi (cercare Functors), quindi i metodi devono essere impostati con tipi di ritorno che modellano in modo significativo il curry o l'applicazione parziale.

Il concatenamento dei metodi viene più spesso utilizzato per implementare qualcosa di simile alla valutazione pigra, come avviene con il modello di progettazione "Builder" e le nuove interfacce della libreria collezioni in Java 8 .

Spero che aiuti.