Was ist "Curry"?

In eine algebra von Funktionen, Umgang mit Funktionen, die mehrere Argumente (oder äquivalent ein argument, das ein N-Tupel) ist etwas unelegant-aber, wie Moses Schönfinkel (und, unabhängig von Haskell Curry) bewiesen, es ist nicht nötig: alles, was Sie brauchen, sind Funktionen, die ein argument.

So, wie Sie mit etwas umgehen würden Sie natürlich auszudrücken, als, sagen wir, f(x,y)? Gut, Sie nehmen das als äquivalent zu f(x)(y) -- f(x) nennen es g ist eine Funktion, und wenden Sie diese Funktion, um y. In anderen Worten, müssen Sie nur die Funktionen, die ein argument-aber einige, die diese Funktionen zurückgeben, die anderen Funktionen (was AUCH ein argument;-).

Als üblich, wikipedia hat eine schöne Zusammenfassung-Eintrag zu dieser, mit vielen nützliche Hinweise (und wahrscheinlich auch diejenigen in Bezug auf Ihre Lieblings-Sprachen;-) sowie etwas mehr strenge mathematische Behandlung.

InformationsquelleAutor der Antwort Alex Martelli

Currying ist eine transformation, die angewendet werden können, um Funktionen zu ermöglichen, nehmen Sie weniger ein argument als zuvor.

Zum Beispiel in F# können Sie eine Funktion definieren, damit:-

let f x y z = x + y + z

Hier die Funktion f nimmt die Parameter x, y und z und addiert Sie zusammen, so dass:-

f 1 2 3

Zurück 6.

Unsere definition wir definieren daher die curry-Funktion für f:-

let curry f = fun x -> f x

Wo 'fun-x -> f x' ist eine lambda-Funktion äquivalent zu x => f(x) in C#. Diese Funktion Eingänge die Funktion, die Sie möchten, curry und gibt eine Funktion, die übernimmt ein einzelnes argument, und gibt die angegebene Funktion mit dem ersten argument legen Sie die input-argument.

Mit unserem vorherigen Beispiel wir erhalten ein curry von f so:-

let curryf = curry f

Wir können dann Folgendes tun:-

let f1 = curryf 1

Sodass wir nun eine Funktion f1, die ist äquivalent zu f1 y z = 1 + y + z. Dies bedeutet, dass wir Folgendes tun können:-

f1 2 3

Gibt 6.

Dieser Prozess wird oft verwechselt mit 'partial function application", die werden so definiert:-

let papply f x = f x

Aber wir können erweitern, um mehr als einen parameter, d.h.:-

let papply2 f x y = f x y
let papply3 f x y z = f x y z
etc.

Einer teilweisen Anwendung wird die Funktion und die parameter(s) und zurück, eine Funktion, die erfordert, dass Sie einen oder mehr weniger Parameter, und wie die beiden vorangegangenen Beispiele zeigen, ist direkt implementiert in der standard-F# definition einer Funktion, so das wir erreichen konnten, das bisherige Ergebnis so:-

let f1 = f 1
f1 2 3

Wird wieder ein Ergebnis von 6.

Fazit:-

Den Unterschied zwischen currying und partielle Funktion Anwendung ist, dass:-

Currying nimmt eine Funktion und eine neue Funktion akzeptiert ein einzelnes argument, und für die Rückgabe der Funktion mit dem ersten argument festgelegt, dass argument. Dies ermöglicht es uns, stellen Funktionen mit mehreren Parametern aus einer Reihe von single-argument-Funktionen. Beispiel:-

let f x y z = x + y + z
let curryf = curry f
let f1 = curryf 1
let f2 = curryf 2
f1 2 3
6
f2 1 3
6

Partielle Funktion Anwendung ist direkter, es dauert eine Funktion und ein oder mehrere Argumente und gibt eine Funktion mit der ersten n Argumente gesetzt, um die n Argumente angegeben werden. Beispiel:-

let f x y z = x + y + z
let f1 = f 1
let f2 = f 2
f1 2 3
6
f2 1 3
6

InformationsquelleAutor der Antwort ljs

Kann es ein Weg sein, um die Funktionen nutzen, um andere Funktionen.

In javascript:

let add = function(x){
  return function(y){ 
   return x + y
  };
};

Uns erlauben würde, es zu nennen wie so:

let addTen = add(10);

Wenn diese läuft die 10 übergeben wird, als x;

let add = function(10){
  return function(y){
    return 10 + y 
  };
};

das heißt, wir werden zurückgegeben dieser Funktion:

function(y) { 10 + y };

Also, wenn Sie rufen

 addTen();

sind Sie wirklich anrufen:

 function(y) { 10 + y };

Also, wenn Sie dies tun:

 addTen(4)

es ist das gleiche wie:

function(4) { 10 + 4} //14

Also unsere addTen() fügt immer zehn auf das, was wir in übergeben. Wir können ähnliche Funktionen in der gleichen Weise:

let addTwo = add(2)       //addTwo(); will add two to whatever you pass in
let addSeventy = add(70)  //... and so on...

InformationsquelleAutor der Antwort Adzz

Ich fand diesen Artikel, und der Artikel, auf den es verweist, nützlich, um besser zu verstehen, currying:
http://blogs.msdn.com/wesdyer/archive/2007/01/29/currying-and-partial-function-application.aspx

Als die anderen erwähnt, es ist nur ein Weg, um eine ein-parameter-Funktion.

Dies ist sinnvoll, da Sie nicht davon ausgehen, wie viele Parameter übergeben werden, so dass Sie nicht brauchen eine 2 parameter, 3 parameter-und 4-parameter-Funktionen.

InformationsquelleAutor der Antwort James Black

Einer Curry-Funktion angewandt wird, um mehrere Argumente, anstatt nur
ein.

Hier ist eine regelmäßige, nicht-Curry-Funktion, wodurch zwei Int
Parameter x und y:

scala> def plainOldSum(x: Int, y: Int) = x + y
plainOldSum: (x: Int,y: Int)Int
scala> plainOldSum(1, 2)
res4: Int = 3

Hier ähnliche Funktion, die die Curry. Statt
eine Liste von zwei Int-Parameter, können Sie die Anwendung dieser Funktion auf zwei Listen ein
Int-parameter:

scala> def curriedSum(x: Int)(y: Int) = x + y
curriedSum: (x: Int)(y: Int)Intscala> second(2)
res6: Int = 3
scala> curriedSum(1)(2)
res5: Int = 3

Was hier passiert ist, dass beim aufrufen curriedSumerhalten Sie tatsächlich zwei traditionelle Funktion Aufrufe, Rücken an Rücken. Die erste Funktion
Aufruf mit einem einzigen Int-parameter namens x aus und liefert eine Funktion
Wert für die zweite Funktion. Diese zweite Funktion nimmt den Int-parameter
y.

Hier ist eine Funktion namens firstdie nicht im Geist ist, was der erste traditionelle
Funktions-Aufruf von curriedSum tun würde:

scala> def first(x: Int) = (y: Int) => x + y
first: (x: Int)(Int) => Int

Anwendung 1 um die erste Funktion—in anderen Worten, aufrufen der ersten Funktion
und die übergabe in 1 —ergibt sich die zweite Funktion:

scala> val second = first(1)
second: (Int) => Int = <function1>

Anwendung von 2 um die zweite Funktion liefert das Ergebnis:

scala> second(2)
res6: Int = 3

InformationsquelleAutor der Antwort nazar_art

Geben, eine Reale Welt (und potentiell nützlich) Beispiel currying überprüfen Sie heraus, wie Sie server-Aufrufe in javascript mit der Bibliothek Holen

    Get(url) {
        let fullUrl = toFullUrl(url);

        let promise = getPromiseForFetchWithToken((token) => {

        let headers = Object.assign(
            getDefaultHeaders(token),
            jsonHeaders);

        let config = {
            method: "GET",
            headers: headers
        };

        return fetch(fullUrl, config);
    });

    return promise;
}

Wo getPromiseForFetchWithToken ist eine Curry-Funktion zurückgibt, die ein Promise mit dem Ergebnis der fetch -, wie unten gezeigt:

function getPromiseForFetchWithToken(tokenConsumingFetch) {
   function resolver(resolve, reject) {

    let token = localStorage.getItem("token");

    tokenConsumingFetch(token)
        .then(checkForError)
        .then((response) => {
            if (response) resolve(response);
        })
        .catch(reject);
   }

   var promise = new Promise(resolver);

   return promise;
}

Diese können Sie erwarten den Anruf der Get Funktion und dann entsprechend verarbeiten den Rückgabewert egal was es ist, Sie wieder verwenden können die getPromiseForFetchWithToken - Funktion überall Sie brauchen, um einen server aufrufen, muss ein bearer-token. (Put, Delete, Post, etc)

InformationsquelleAutor der Antwort Josh Siegl

Curry kann den code vereinfachen. Dies ist einer der Hauptgründe für die Verwendung dieser. Currying ist ein Prozess der Umwandlung eine Funktion, die nimmt n Argumente in die n Funktionen, die akzeptiert nur ein argument.

Dem Prinzip der übergabe von Argumenten an die Funktion übergeben, mit der Schließung (closure) - Eigenschaft, um Sie zu speichern in einer anderen Funktion und behandeln es als einen Rückgabewert, und diese Funktionen bilden eine Kette, und die letzten Argumente übergeben werden, um den Vorgang abzuschließen.

Der Vorteil dabei ist, dass es vereinfacht die Verarbeitung von Parametern durch den Umgang mit einem parameter in einer Zeit, die auch zur Verbesserung der Flexibilität und Lesbarkeit des Programms. Das macht das Programm übersichtlicher. Auch die Aufteilung der code in kleinere Stücke würde es wiederzuverwenden-freundlich.

Beispiel:

function curryMinus(x) 
{
  return function(y) 
  {
    return x - y;
  }
}

var minus5 = curryMinus(1);
minus5(3);
minus5(5);

Kann ich auch tun...

var minus7 = curryMinus(7);
minus7(3);
minus7(5);

Dieser ist sehr groß für die Herstellung von komplexen code, der ordentlich und die Handhabung von nicht synchronisierte Methoden etc.

InformationsquelleAutor der Antwort Marcus Thornton