> Aber als Currying bezeichnet man allgemein die Übersetzung einer Funktion mit mehreren Parametern in eine Reihe von Funktionen, die jeweils nur einen Parameter besitzen. Genau, das verdeutlicht man sich am besten, indem man sich die Typen solcher Funktionen anschaut. Dafür muss man sich den Definitions- und Bildbereich genauer ansehen. Die *zweistellige* Addition auf *natürlichen Zahlen* , nimmt zwei natürliche Zahlen entgegen und berechnet als Ergebnis wiederum eine *natürliche Zahl* , mathematisch aufgeschrieben: `add: (ℕ × ℕ) ⟶ ℕ` Alternativ kann man die Funktion aber auch als Funktion *höherer Ordnung* auffassen, die zunächst *eine natürliche Zahl* entgegen nimmt und dann *eine Funktion zurück gibt*, die eine *weitere Zahl* entgegen nimmt und als finales Ergebnis wieder *eine natürliche Zahl* liefert. Der Definitionsbereich dieser Funktion wären also die natürlichen Zahlen, der Bildbereich wären *einstellige Funktionen* von den natürlichen Zahlen in die natürlichen Zahlen: `add: ℕ ⟶ (ℕ ⟶ ℕ)` In JavaScript lassen sich beide Varianten implementieren: ~~~js // add1: (ℕ × ℕ) ⟶ ℕ add1 = (a,b) => a + b // add2: ℕ ⟶ (ℕ ⟶ ℕ) add2 = a => (b => a + b) ~~~ Hat man `add1` gegeben, kann man damit auch `add2` implementieren ohne `+` direkt zu verwenden: ~~~js add2 = a => (b => add1(a,b)) ~~~ Dieser Vorgang nennt sich *Currying*. Die andere Richtung ist natürlich auch möglich, sie bezeichnet man als *Uncurrying*: ~~~js add1 = (a,b) => add2(a)(b) ~~~ Currying macht man in der Regel nicht von Hand, sondern lässt es von einer Funktion erledigen. Dazu ist es zunächst wieder sinnvoll sich den Typen der `curry`-Funktion vorzustellen: Im Definitionsbereich nimmt `curry` zweistellige Funktionen auf den natürlichen Zahlen entgegen. Im Bildbereich liefert `curry` Funktionen höherer Ordnung über den natürlichen Zahlen. Ingesamt hat man also: `curry: ((ℕ × ℕ) ⟶ ℕ) ⟶ (ℕ ⟶ (ℕ ⟶ ℕ))` Für `uncurry` müssen wir nur die Typen des Definitions- und Bildbereiches austauschen: `uncurry: (ℕ ⟶ (ℕ ⟶ ℕ)) ⟶ ((ℕ × ℕ) ⟶ ℕ)` Die beiden Funktionen lassen sich dann wie folgt implementieren: ~~~js // curry: ((ℕ × ℕ) ⟶ ℕ) ⟶ (ℕ ⟶ (ℕ ⟶ ℕ)) curry = f => (a => (b => f(a,b))) // uncurry: (ℕ ⟶ (ℕ ⟶ ℕ)) ⟶ ((ℕ × ℕ) ⟶ ℕ) uncurry = f => ((a,b) => f(a)(b)) ~~~ Zurück zum Additions-Beispiel könnte man nun die Funktion `add2` aus `add1` nur mit der `curry`-Funktion erzeugen: ~~~js add2 = curry(add1) ~~~ Und der Vollständigkeit halber sei auch noch die Umkehrrichtung gezeigt: ~~~js add1 = uncurry(add2) ~~~ Man sieht schnell, dass die `curry`- und `uncurry`-Funktionen eigentlich nicht auf natürliche Zahlen beschränkt sind. Wenn `a`, `b` und `c` für beliebige Typen stehen, können wir den Funktionen die beiden folgenden allgemeineren Typen zuordnen. `curry: ((a × b) ⟶ c) ⟶ (a ⟶ (b ⟶ c))` `uncurry: (a ⟶ (b ⟶ c)) ⟶ ((a × b) ⟶ c)` Ebenso kann man die Funktionen so verallgemeinern, dass sie auf beliebigen n-Tupeln operieren. Dafür müsste aber die Implementierung geändert werden. > Ein klassisches Beispiel hierfür sieht in etwa so aus: > > ~~~ javascript > function add (a, b) { > if (b === undefined) { > return function (b) { > return a + b; > } > } > return a + b; > } > ~~~ Das Beispiel von @Orlok zeigt sogenanntes *Autocurrying*. Das ist eine Sonderform, die den Unterschied zwischen der zweistelligen Addition und der Addition höherer Ordnung vollständig weg abstrahiert. Man kann diese Funktion wie `add1` und wie `add2` aufrufen. Diese Abstraktion kann man nur in dynamisch typisierten Sprachen realisieren, weil man ihr schlicht keinen statischen Typen zuordnen kann.

> Aber als Currying bezeichnet man allgemein die Übersetzung einer Funktion mit mehreren Parametern in eine Reihe von Funktionen, die jeweils nur einen Parameter besitzen. Genau, das verdeutlicht man sich am besten, indem man sich die Typen solcher Funktionen anschaut. Dafür muss man sich den Definitions- und Bildbereich genauer ansehen. Die *zweistellige* Addition auf *natürlichen Zahlen* , nimmt zwei natürliche Zahlen entgegen und berechnet als Ergebnis wiederum eine *natürliche Zahl* , mathematisch aufgeschrieben: `add: (ℕ × ℕ) ⟶ ℕ` Alternativ kann man die Funktion aber auch als Funktion *höherer Ordnung* auffassen, die zunächst *eine natürliche Zahl* entgegen nimmt und dann *eine Funktion zurück gibt*, die eine *weitere Zahl* entgegen nimmt und als finales Ergebnis wieder *eine natürliche Zahl* liefert. Der Definitionsbereich dieser Funktion wären also die natürlichen Zahlen, der Bildbereich wären *einstellige Funktionen* von den natürlichen Zahlen in die natürlichen Zahlen: `add: ℕ ⟶ (ℕ ⟶ ℕ)` In JavaScript lassen sich beide Varianten implementieren: ~~~js // add1: (ℕ × ℕ) ⟶ ℕ add1 = (a,b) => a + b // add2: ℕ ⟶ (ℕ ⟶ ℕ) add2 = a => (b => a + b) ~~~ Hat man `add1` gegeben, kann man damit auch `add2` implementieren ohne `+` direkt zu verwenden: ~~~js add2 = a => (b => add1(a,b)) ~~~ Dieser Vorgang nennt sich *Currying*. Die andere Richtung ist natürlich auch möglich, sie bezeichnet man als *Uncurrying*: ~~~js add1 = (a,b) => add1(a)(b) ~~~ Currying macht man in der Regel nicht von Hand, sondern lässt es von einer Funktion erledigen. Dazu ist es zunächst wieder sinnvoll sich den Typen der `curry`-Funktion vorzustellen: Im Definitionsbereich nimmt `curry` zweistellige Funktionen auf den natürlichen Zahlen entgegen. Im Bildbereich liefert `curry` Funktionen höherer Ordnung über den natürlichen Zahlen. Ingesamt hat man also: `curry: ((ℕ × ℕ) ⟶ ℕ) ⟶ (ℕ ⟶ (ℕ ⟶ ℕ))` Für `uncurry` müssen wir nur die Typen des Definitions- und Bildbereiches austauschen: `uncurry: (ℕ ⟶ (ℕ ⟶ ℕ)) ⟶ ((ℕ × ℕ) ⟶ ℕ)` Die beiden Funktionen lassen sich dann wie folgt implementieren: ~~~js // curry: ((ℕ × ℕ) ⟶ ℕ) ⟶ (ℕ ⟶ (ℕ ⟶ ℕ)) curry = f => (a => (b => f(a,b))) // uncurry: (ℕ ⟶ (ℕ ⟶ ℕ)) ⟶ ((ℕ × ℕ) ⟶ ℕ) uncurry = f => ((a,b) => f(a)(b)) ~~~ Zurück zum Additions-Beispiel könnte man nun die Funktion `add2` aus `add1` nur mit der `curry`-Funktion erzeugen: ~~~js add2 = curry(add1) ~~~ Und der Vollständigkeit halber sei auch noch die Umkehrrichtung gezeigt: ~~~js add1 = uncurry(add2) ~~~ Man sieht schnell, dass die `curry`- und `uncurry`-Funktionen eigentlich nicht auf natürliche Zahlen beschränkt sind. Wenn `a`, `b` und `c` für beliebige Typen stehen, können wir den Funktionen die beiden folgenden allgemeineren Typen zuordnen. `curry: ((a × b) ⟶ c) ⟶ (a ⟶ (b ⟶ c))` `uncurry: (a ⟶ (b ⟶ c)) ⟶ ((a × b) ⟶ c)` Ebenso kann man die Funktionen so verallgemeinern, dass sie auf beliebigen n-Tupeln operieren. Dafür müsste aber die Implementierung geändert werden. > Ein klassisches Beispiel hierfür sieht in etwa so aus: > > ~~~ javascript > function add (a, b) { > if (b === undefined) { > return function (b) { > return a + b; > } > } > return a + b; > } > ~~~ Das Beispiel von @Orlok zeigt sogenanntes *Autocurrying*. Das ist eine Sonderform, die den Unterschied zwischen der zweistelligen Addition und der Addition höherer Ordnung vollständig weg abstrahiert. Man kann diese Funktion wie `add1` und wie `add2` aufrufen. Diese Abstraktion kann man nur in dynamisch typisierten Sprachen realisieren, weil man ihr schlicht keinen statischen Typen zuordnen kann.