return this / return funktionsobjekt

[MB]

moin communit,

zu return this:

ich bin aus return this nicht ganz schlau geworden. Ich kenne die standarts von Rückgabewerten, wie integer, bolean, strings, objekte usw.

Ich kann mir auf return this n reim drauf machen aber mir fehlt die erklärung:/. Ich nehme an das sich dieses this auf die funktion die es umgibt bezieht.

zu return Funktionsobjekte:

Mit welcher JS Version ist es möglich anonyme Objekte als Funktionsparameter und Rückgabewert zu erhalten.

var foo = bar({ /**/ });

var bar = function( /**/ ) {
  /**/
  return { /**/ };
};

var foo = {
  /**/
  baz : function() { /**/ },
  bar : return { /**/ }
};

vlg MB

[Nachtwächter]

clFoo = function () {
  this.setS = function(str) { this.s = str; return true; }
  this.bar = function() { return 'Hier ist Sender Jerewan.'; }
  this.tok = function(str) { return 'Stimmt es, dass ' + this.s + ' ... Im Prinzip schon. ' + str; }
};

oFoo = new clFoo ();
oFoo.s = 'Objekte schwierig sind?'
console.log ( oFoo.bar() );
console.log ( oFoo.tok('Aber manchmal nicht.') );

oFoo.setS( '"this" immer das Objekt meint?' );
console.log ( oFoo.bar() );
console.log ( oFoo.tok('Aber manchmal nicht.') );

node test.js
Hier ist Sender Jerewan.
Stimmt es, dass Objekte schwierig sind? ... Im Prinzip schon. Aber manchmal nicht.
Hier ist Sender Jerewan.
Stimmt es, dass "this" immer das Objekt meint? ... Im Prinzip schon. Aber manchmal nicht.

[Orlok]

Hallo

Ich bin aus return this nicht ganz schlau geworden. […] Ich nehme an das sich dieses this auf die Funktion die es umgibt bezieht.

Der Wert der Funktionsvariable this hängt unter anderem davon ab, um was für eine Art von Funktion es sich handelt, und ganz besonders auch davon, auf welche Weise die Funktion aufgerufen wurde. Das bedeutet, die Frage nach dem Wert von this kann nicht pauschal beantwortet werden, sondern nur bezogen auf konkrete Fälle.

Jedenfalls hast du in deiner Frage ein für das Verständnis von this relevantes Stichwort bereits gegeben, nämlich das Wort Umgebung. Oder etwas anders ausgedrückt, das Wort Kontext. Allerdings geht es hier nicht wie du dachtest um die Umgebung, beziehungsweise den Kontext von this, sondern um den Kontext der Funktion, der durch this repräsentiert wird.

Das mag vielleicht kompliziert klingen, ist aber eigentlich nicht schwer zu verstehen. Insbesondere dann nicht, wenn man sich vergegenwärtigt, wie die Welt ohne this aussieht. Nehmen wir als Beispiel also einmal eine gewöhnliche Funktion und fragen uns, welche Informationen innerhalb der Funktion zur Verfügung stehen, solange wir nicht auf this zugreifen.

function add (a, b) {
  return a + b;
}

console.log(add(2, 3)); // 5

Wenn wir diese Funktion betrachten, dann stellen wir fest, dass uns innerhalb der Funktion nur zwei Informationen über die Außenwelt zur Verfügung stehen, wobei es sich bei der ersten Information um die Werte handelt, die wir der Funktion bei ihrem Aufruf als Argumente übergeben, also die Werte, welche wir von außen in die Funktion hineinreichen.

Die zweite Information die wir haben ist die lexikalische Umgebung, in der die Funktion definiert wurde. Das heißt, unsere Funktion besitzt eine unsichtbare Verbindung zum umgebenden Quelltext, die es uns ermöglicht, auf Variablen, Konstanten oder andere Funktionen zuzugreifen, die in einem der umgebenden Gültigkeitsbereiche definiert wurden.

const value = 5;

function getValue ( ) {
  return value;
}

console.log(getValue( )); // 5

Ein Beispiel hierfür wäre diese Funktion, die innerhalb ihres Körpers eine Konstante referenziert, die in der äußeren lexikalischen Umgebung der Funktion definiert wurde, und nicht in der Funktion selbst. Im Ergebnis bleibt also festzuhalten, dass eine Funktion abgesehen von diesen beiden Informationen nichts über das Programm weiß, dessen Bestandteil sie ist.

Im Sinne des funktionalen Programmierparadigmas wäre daran auch nichts auszusetzen, sondern aus diesem Blickwinkel betrachtet ist es sogar erwünscht, dass eine Funktion nur mit den Werten arbeitet, die ihr als Argumente übergeben wurden, ganz so, wie es die Funktion add aus unserem ersten Beispiel tut. Für solche Funktionen spielt es keine Rolle, in welchem Zusammenhang zum restlichen Programm sie stehen, ein Bedarf an weiteren Informationen über den Kontext ist hier also nicht gegeben.

Allerdings stellt die funktionale Programmierung nur eine Möglichkeit dar, ein Programm zu strukturieren, und wenn wir uns der objektorientierten Programmierung zuwenden, dann stellen wir fest, dass Funktionen dort nicht nur isoliert betrachtet werden können, sondern dass sie dort Teil einer größeren logischen Einheit sind, nämlich von Objekten, deren Methoden sie sind.

Das heißt, aus Sicht einer Methode ist es nicht nur von Bedeutung, welche Werte ihr beim Aufruf übergeben wurden oder in welcher lexikalischen Umgebung sie definiert wurde, sondern es ist gegebenenfalls auch wichtig zu wissen, auf welchem Objekt sie operiert.

Diese zusätzlichen Informationen über den Kontext einer Funktion müssen also in irgendeiner Form zugänglich gemacht werden, und hier kommt nun die Funktionsvariable this ins Spiel.

const object = {
  print ( ) {
    console.log(typeof this);
  }
};

object.print( ) // object

Wenn wir wie in diesem Beispiel auf einem Objekt eine Methode definieren und diese Methode dann über einen Elementausdruck aufrufen, die Funktion also beim Aufruf über das Objekt referenzieren, dessen Methode sie ist, dann wird this mit einer Referenz auf ebendieses Objekt initialisiert, sodass innerhalb der Methode direkt darauf zugegriffen werden kann.

Nun ist es natürlich so, dass wir – bezogen auf das Beispiel oben – das in der Konstante mit dem Bezeichner object hinterlegte Objekt aus der Methode heraus nicht zwingend über this hätten referenzieren müssen, sondern wir hätten dieses Objekt auch direkt ansprechen können.

Das heißt, wirklich interessant wird es eigentlich erst dann, wenn wir eine Methode auf einem Objekt aufrufen, ohne dass die Methode auch tatsächlich auf diesem Objekt definiert ist, also zum Beispiel in dem Fall, dass die Methode von einem Prototypen an dieses Objekt vererbt wurde.

const prototype = {
  print ( ) {
    console.log(this.number);
  }
}

const a = Object.create(prototype, {
  'number' : {value : 3}
});

a.print( ); // 3

const b = Object.create(prototype, {
  'number' : {value : 5}
});

b.print( ); // 5

In diesem Beispiel haben wir zunächst ein Objekt erstellt und darauf eine Methode definiert, so wie schon im letzten Beispiel. Aber hier rufen wir die Methode nicht auf diesem Objekt auf, sondern wir erstellen mittels Object.create zwei weitere Objekte, als deren Prototyp wir das zuerst erzeugte Objekt bestimmen. Wenn wir nun auf diesen beiden Objekten die geerbte Methode aufrufen, dann zeigt this mal auf das eine und mal auf das andere Objekt. Das heißt, wir können Methoden mittels this auf eine Weise definieren, sodass sie für eine Vielzahl an Objekten verwendet werden können, und nicht nur für ein spezifisches Objekt.

Daraus folgt aber natürlich, dass der Wert von this nicht bereits zum Zeitpunkt der Definition einer Funktion festgelegt werden kann, sprich, die Bindung von this an einen Wert erfolgt grundsätzlich erst beim Aufruf der jeweiligen Funktion, und dementsprechend hängt der Wert von this wesentlich davon ab, nach welchem Muster die Funktion aufgerufen wird.

Bereits gesehen haben wir, dass bei einem Methodenaufruf this mit einer Referenz auf das Objekt initialisiert wird, als dessen Methode die Funktion aufgerufen wurde. Aber es gibt natürlich noch einige andere Möglichkeiten, wie eine Funktion aufgerufen werden kann …

function a ( ) {
  console.log(this === window);
}

a( ); // true

function b ( ) {
  'use strict';
  console.log(this === undefined);
}

b( ); // true

Bei gewöhnlichen Funktionsaufrufen wie in dem Beispiel oben zeigt this im normalen Ausführungsmodus auf das globale Objekt, also wenn es sich bei der Ausführungsumgebung um einen Webbrowser handelt, auf das Objekt window. Wird die Funktion hingegen im Strict Mode ausgeführt, dann wird this mit dem primitiven Wert undefined initialisiert, was das in diesem Fall eigentlich wünschenswerte Verhalten darstellt, da hier keine spezifischen Kontextinformationen benötigt werden.

function Constructor ( ) {
  'use strict';
  console.log(typeof this);
}

const instance = new Constructor; // object

Wird eine Funktion etwa unter Verwendung des Operators new als Konstruktor aufgerufen, dann zeigt this innerhalb der Funktion auf das hierbei erzeugte Instanzobjekt, sodass auf diesem Objekt eigene Eigenschaften und Methoden definiert werden können.

Auch ist es möglich, eine Funktion explizit in einem bestimmten Kontext aufzurufen, zum Beispiel unter Verwendung der Funktionsmethoden call und apply, wie im folgenden Beispiel demonstriert.

function fn ( ) {
  console.log(this.number);
}

fn.call({number : 3}); // 3

fn.apply({number : 5}); // 5

Hier wird die anfangs deklarierte Funktion zweimal aufgerufen, mal mit call und mal mit apply, wobei in beiden Fällen als erstes Argument ein Objekt mit einer Eigenschaft übergeben wird, dass dann an this gebunden wird. Der Unterschied zwischen den beiden Methoden besteht übrigens darin, auf welche Art Argumente an die aufzurufende Funktion weitergeleitet werden. Die Methode call nimmt die Argumente einzeln entgegen, während sie der Methode apply in einem Array übergeben werden können.

Jedenfalls gibt es darüber hinaus noch ein paar andere Varianten des Aufrufs von Funktionen, auf die hier aber nicht näher eingegangen werden soll. Erwähnt werden soll an dieser Stelle nur noch, dass nicht alle Funktionen einen eigenen Kontext binden.

function outer ( ) {
  const inner = ( ) => {
    console.log(this.value);
  };
  inner( ); // 42
}

outer.call({value : 42});

Sogenannte Pfeilfunktionen, wie die Funktion, die in dem Beispiel oben der Konstante mit dem Bezeichner inner zugewiesen wurde, binden grundsätzlich keinen eigenen Kontext, dass heißt, wenn innerhalb des Körpers einer solchen Funktion auf this zugegriffen wird, dann wird der Kontext der äußeren lexikalischen Umgebung referenziert, welcher Wert das auch immer sein mag.

Also, soviel zu den Grundlagen. Nun wolltest du aber noch wissen, was es mit return this auf sich hat, und diese Frage ist vor dem Hintergrund des bislang Gesagten relativ leicht zu beantworten.

const number = {

  currentValue : 0,

  add (value) {
    this.currentValue += value;
    return this;
  },

  subtract (value) {
    this.currentValue -= value;
    return this;
  },

  print ( ) {
    console.log(this.currentValue);
  }

};

number.add(3).subtract(2).add(4);

number.print( ); // 5

Wir hatten ja gesehen, dass bei einem Methodenaufruf die Kontextvariable this mit einer Referenz auf das Objekt initialisiert wird, auf dem die Methode aufgerufen wurde.

Wenn die Methode nun this zurückgibt, dann kann dieser Wert, also die Referenz auf das Objekt, für weitere Methodenaufrufe verwendet werden. Das heißt, die Aufrufe können wie in dem Beispiel oben verkettet werden, ohne dass das Objekt jedesmal über seinen Bezeichner referenziert werden muss.

Viele Grüße,

Orlok

[MB]

Lieber Orlok,

recht herzlichen Dank! Jetzt hbe ich nicht nur this sonder auch Crurrying mmit dem letzten Beispiel verstanden.

Hast du meine andere Frage übergagen oder ist sie in in deinem AW Artikel enthalten. Wenn nicht dann frage ich nocheinmal explezit.

zu return Funktionsobjekte:

Mit welcher JS Version ist es möglich anonyme Objekte als Funktionsparameter und Rückgabewert zu erhalten.

Kannst du mir kurz n Anwendungsbeispiel für Currying geben? Metasyntaktische Variablen reichen.

VLG MB

PS: Du muss mich entschuldigen. Das was du Ausgibig erklärt hast, kann ich nur sehr schwer verstehen. Erst durch deine simplen sehr guten Anschaulichen Anwendungsbeispiele habe ich es verstanden. Der Umfang an Text erschwert mir das verständnis ebenfalls. Das hat überhaupt nichts mit der ausführlichen Erklärungen zutun sondern eben mit meiner Sprachbehinderung. Wenn möglich, kurz und präzise. Fachbegriffe generell in den Erklärungen sind explizit für mich ebenfall sehr hilfreich. Z.B. dt. Rückgabewert kann ich mir n Kassenbon der realenwelt oder n Integer als Returnwert der Programmierwelt vorstellen. Beidest verschwimmt in den Beiträgen sehr sodass ich nicht mehr weis wo ich mich bewege. Diese Bitte ist an alle gerichtet.

[Orlok]

Hallo

Hast du meine andere Frage übergangen?

Ja, weil ich sie nicht so richtig verstanden habe. Du hattest erst etwas von „Funktionsobjekten“ geschrieben, dann aber gefragt:

Mit welcher JS Version ist es möglich anonyme Objekte als Funktionsparameter und Rückgabewert zu erhalten.

Ich nehme an, mit „anonymen Objekten“ meinst du Objektliterale, wie in deinem Beispiel hier:

var bar = function( /**/ ) {
  /**/
  return { /**/ };
};

var foo = bar({ /**/ });

Da brauchst du dir um die „JS Version“ keine Gedanken zu machen. Das kannst du genauso schreiben, wie du es hier gemacht hast. Das gilt im Übrigen auch für Funktionsobjekte. Die kannst du ebenfalls als Argument übergeben oder als Rückgabewert verwenden.

function foo (bar) {
  return bar;
}

const baz = foo(function ( ) {
  return true;
});

console.log(baz( )); // true

Dieses Beispiel von dir ist allerdings kaputt:

var foo = {
  /**/
  baz : function() { /**/ },
  bar : return { /**/ }
};

Das Schlüsselwort return darf da nicht stehen. Das ergibt auch keinen Sinn, denn du weist hier einer Objekteigenschaft einen Wert zu und bist nicht im Körper einer Funktion.

Kannst du mir kurz n Anwendungsbeispiel für Currying geben?

Ein gutes Anwendungsbeispiel fällt mir dazu nicht ein. Ich bin eher Theoretiker. ;-)

Aber als Currying bezeichnet man allgemein die Übersetzung einer Funktion mit mehreren Parametern in eine Reihe von Funktionen, die jeweils nur einen Parameter besitzen.

Ein klassisches Beispiel hierfür sieht in etwa so aus:

function add (a, b) {
  if (b === undefined) {
    return function (b) {
      return a + b;
    }
  }
  return a + b;
}

let result = add(2, 3);

console.log(result); // 5

Wird die Funktion mit zwei Argumenten aufgerufen, dann werden die beiden Werte addiert und das Ergebnis wird zurückgegeben.

const fn = add(4);

result = fn(7)

console.log(result); // 11

Wird die Funktion hingegen nur mit einem Argument aufgerufen, ist der zweite Parameter also undefined, dann wird eine Funktion zurückgegeben, die nur noch einen Parameter besitzt. Der beim ersten Aufruf übergebene Wert wird durch den Funktionsabschluss (Closure) gespeichert.

Wenn die beim ersten Aufruf zurückgegebene Funktion nun mit einem Argument aufgerufen wird, dann wird der gespeicherte Wert aus dem ersten Aufruf mit dem neuen Wert addiert und das Ergebnis wird zurückgegeben.

Auf diese Weise hat man eine Funktion mit zwei Parametern in zwei Funktionen mit je einem Parameter zerlegt.

PS: Du muss mich entschuldigen. Das was du Ausgibig erklärt hast, kann ich nur sehr schwer verstehen. Erst durch deine simplen sehr guten Anschaulichen Anwendungsbeispiele habe ich es verstanden. Der Umfang an Text erschwert mir das verständnis ebenfalls. Das hat überhaupt nichts mit der ausführlichen Erklärungen zutun sondern eben mit meiner Sprachbehinderung. Wenn möglich, kurz und präzise. Fachbegriffe generell in den Erklärungen sind explizit für mich ebenfall sehr hilfreich. Z.B. dt. Rückgabewert kann ich mir n Kassenbon der realenwelt oder n Integer als Returnwert der Programmierwelt vorstellen. Beidest verschwimmt in den Beiträgen sehr sodass ich nicht mehr weis wo ich mich bewege. Diese Bitte ist an alle gerichtet.

Ich glaube du musst eher mich entschuldigen. ;-)

Ich habe einfach nicht daran gedacht, dass der lange Text dir Schwierigkeiten bereiten könnte. Aber es fällt mir auch schwer einzuschätzen, womit du klarkommst und womit nicht. Von daher, vielen Dank für dein Feedback! +1

Hoffentlich war dieser Beitrag etwas besser lesbar.

Viele Grüße,

Orlok

[Der Martin]

Hi,

Ein gutes Anwendungsbeispiel fällt mir dazu nicht ein. Ich bin eher Theoretiker. ;-)

und ein Theoretiker ist ein Mensch, der praktisch nur denkt. :-)

So long,
 Martin

[Gunnar Bittersmann]

@@Der Martin

Ein gutes Anwendungsbeispiel fällt mir dazu nicht ein. Ich bin eher Theoretiker. ;-)

und ein Theoretiker ist ein Mensch, der praktisch nur denkt. :-)

und anderen gern bei der Arbeit zusieht. ;-)

LLAP 🖖

[1unitedpower]

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:

// 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:

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:

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:

// 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:

add2 = curry(add1)

Und der Vollständigkeit halber sei auch noch die Umkehrrichtung gezeigt:

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:

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.

[MB]

Hallo Orlok,

Hast du meine andere Frage übergangen?

Ja, weil ich sie nicht so richtig verstanden habe. Du hattest erst etwas von „Funktionsobjekten“ geschrieben, dann aber gefragt:

Mit welcher JS Version ist es möglich anonyme Objekte als Funktionsparameter und Rückgabewert zu erhalten.

Ich nehme an, mit „anonymen Objekten“ meinst du Objektliterale, wie in deinem Beispiel hier:

Ja meine ich. Mein Fehler wie so oft :D.

Da brauchst du dir um die „JS Version“ keine Gedanken zu machen. Das kannst du genauso schreiben, wie du es hier gemacht hast. Das gilt im Übrigen auch für Funktionsobjekte. Die kannst du ebenfalls als Argument übergeben oder als Rückgabewert verwenden.

Alles klar,

Dieses Beispiel von dir ist allerdings kaputt:

ach stimmt ja. Habe ich abet eben nur runtergeschrieben. Ich hab zum erstenmal mit Objekten gearbeitet. Man möge mir verzeihen.

Aber als Currying bezeichnet man allgemein die Übersetzung einer Funktion mit mehreren Parametern in eine Reihe von Funktionen, die jeweils nur einen Parameter besitzen.

jo besten Dank

Ich glaube du musst eher mich entschuldigen. ;-)

Wir sind alle Menschen. Wie vergessen schonmal dinge. Ich bin nur einer von vielen die hilfe in eurem Forum suchen. Und nur sehr wenigen mangelt es an Sprachbeherschung.

Aber es fällt mir auch schwer einzuschätzen, womit du klarkommst und womit nicht.

Ja is echt schwer aber mach dir bitte deswegen keinen Kopf. Meine Bitte habe ich ja schon gesagt: präzise, kurze Anwendunggsbeispiele, Fachsprache. Wenn ich etwas nicht verstehe auf sprachlicherbasis habe ich eben pech gehabt, Punkt. So einfach ist das :-).

Hoffentlich war dieser Beitrag etwas besser lesbar.

Perfekt!!! Ich hab jedes Wort verstanden

Herzlich Grüße MB

[Der Martin]

Hi,

Aber als Currying bezeichnet man allgemein die Übersetzung einer Funktion mit mehreren Parametern in eine Reihe von Funktionen, die jeweils nur einen Parameter besitzen.

ach was! Weiß doch jeder, dass Currying eine uralte Tradition aus der indischen Küche ist! :-)

*scnr*
 Martin