Recentemente ho giocato con Ruby e mi sono ritrovato a chiedermi se nei linguaggi puramente object oriented (e anche in quelli che non sono puri) i metodi che prendono solo un parametro e poi vengono incatenati equivale a scrivere in lingue con uno stile funzionale? Se no, perché no? Gradirei una risposta dettagliata, anche rigorosa sull'argomento.
Il metodo di concatenamento nei linguaggi orientati agli oggetti è leggermente diverso dal curry. Con definizione , il risultato del curry è una forma più ristretta della funzione originale. Con la convenzione , il risultato del concatenamento del metodo è una forma modificata dell'oggetto originale (di solito non funzionale) . Il concatenamento del metodo può essere utilizzato con metodi non correlati sulla stessa classe, mentre il curring implica il ritorno di una funzione in cui uno o più parametri della funzione originale sono fissi (predeterminati).
In Java, il concatenamento dei metodi è come:
String myString = new StringBuilder("Hi ").append(firstName)
.append(" ")
.append(lastName)
.append("!")
.toString();
Quindi, ciascuna di queste chiamate al metodo .append () restituisce un puntatore all'oggetto StringBuilder anonimo. Questo oggetto è completo dopo ogni .append (), e non è una funzione.
Al contrario, in Scala, l'applicazione parziale o il curriculum è come:
def simple(x:Int, y:Int, z:Int) = x * (y + z)
val simpler = simple(2, _:Int, _:Int)
simpler(3, 4) => 14
(Esempio tratto da blog di Daniel Yankowsky )
simpler() in questo esempio è una funzione wrapper per simple() . simpler() è ancora una funzione che richiede più parametri prima di poter valutare qualsiasi cosa tranne una versione più limitata di se stessa.
EDIT: Leggendolo un giorno dopo, penso che "la funzione wrapper" sia la chiave. È possibile simulare il currying o l'applicazione parziale in Java con i 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);
}
}
}
}
: FINE-EDIT
Il concatenamento del metodo può essere simile all'applicazione parziale o al curring, ma può essere equivalente solo con metodi che restituiscono altri metodi (cercare Functors), e quindi i metodi devono essere impostati con tipi restituiti che modellano in modo significativo o parziale applicazione.
Il metodo di concatenamento è più spesso usato per implementare qualcosa come la valutazione pigra, come avviene con il modello di progettazione "Builder" e il nuovo Interfacce della libreria di raccolte in Java 8 .
Spero che questo aiuti.
Leggi altre domande sui tag object-oriented currying method-chaining