Implementierung komponieren nur mit Funktion <> in Java 8

Question

In dem Buch Functional Programming in Java baut der Autor eine komponieren Funktion nur mit der Function<T, U> Schnittstelle (die Schnittstelle ist jedoch nicht eine mit Java 8, aber sehr ähnlich ausgeliefert) das Snippet von denen angezeigt wird unter

public interface Function<T, U> { 
    U apply(T arg); 
} 

obwohl ich könnte die Methode Version von compose versteht unten, die in zwei Funktionen übernehmen und gebe eine zusammengesetzte Funktion

public static final Function<Integer, Integer> compose (final Function<Integer, Integer> f1, 
            final Function<Integer, Integer> f2) { 
     arg -> f1.apply(f2.apply(arg)); 
} 

ich konnte einfach nicht meinen Kopf um die unten implementati komponieren auf mit Funktion <> und lambdas

static Function<Function<Integer, Integer>, 
      Function<Function<Integer, Integer>, 
        Function<Integer, Integer>>> compose = 
      x -> y -> z -> x.apply(y.apply(z)); 

PS: meine Meinung nicht da aus diesem und vorwärts bewegen mit den restlichen Abschnitten :(

Answer 1

Unter Bezugnahme auf eine Function<Integer, Integer> als Integer-Funktion, was Sie haben, bekommen könnte ist eine Funktion, die {eine Ganzzahlfunktion} auf {eine Funktion, die eine Ganzzahlfunktion einer anderen Ganzzahlfunktion zuordnet} abbildet.

Insbesondere wenn eine ganzzahlige Funktion gegeben x, gibt sie eine Funktion, die eine ganze Zahl Funktion y gegeben, eine Ganzzahl-Funktion gibt, die ein ganzzahliges z zu x(y(z)) abbildet.

Given a function x 
Returns a function that: 
    Given a function y 
    Returns a function that: 
     Given an integer z 
     Returns x(y(z)) 

Answer 2

Lassen Sie mich eine einfachere λ-Notation Arten Weglassen, wo λx.E bedeutet eine Funktion, die ein Argument x und gibt den Wert von E nimmt. Zum Beispiel ist λx. λy. x+y eine Funktion, die x übernimmt und λy. x+y zurückgibt, die selbst eine Funktion ist, die y übernimmt und x+y zurückgibt. Lassen Sie uns auch schreiben λ(x,y).E für eine Funktion, die zwei Argumente x und y dauert, und gibt den Wert E zurück. Zum Beispiel ist λ(x,y). x+y eine Funktion, die x und yauf einmal und x+y zurücknimmt.

Dann wird die "zwei Argumente auf einmal" -Version von compose ist: λ(f,g). λx.f(g(x))

Die zweite, "one-by-one" Version ist: λf. λg. λx.f(g(x))

Alles andere, die in der Java-Code beängstigend aussieht, ist Tippe einfach Anmerkungen ein. Sowohl f als auch g (sowie das Ergebnis von compose) haben den Typ Function < Integer, Integer >. Lassen Sie uns diesen Typ als T schreiben. Dann hat die zweite Version von compose den Typ Function < T, Function < T, T > >.

P.S. Funktionen wie λx. λy. E heißen curry, während λ(x,y). Euncurried ist. Siehe: https://en.wikipedia.org/wiki/Currying

Answer 3

Diese Art der Darstellung könnte bei der Verwendung verschiedener Typen und/oder Generika sinnvoller sein.

Function<Function<R, S>, 
     Function<Function<T, R>, 
        Function<T, S>>> compose = x -> y -> z -> x.apply(y.apply(z)); 

edit: Typen wurden falsch platziert (aus diesem Grund ist es eine bessere Übung, wenn sie anders sind)