Co to jest "Currying"?

W algebrze funkcji radzenie sobie z funkcjami, które przyjmują wiele argumentów (lub równoważny jeden argument, który jest N-krotką) jest nieco nieeleganckie -- ale, jak udowodnił Moses Schönfinkel (i niezależnie Haskell Curry), nie jest potrzebne: wszystko, czego potrzebujesz, to funkcje, które przyjmują jeden argument.

Więc jak sobie radzisz z czymś, co naturalnie wyrażasz jako, powiedzmy, f(x,y)? Cóż, bierzesz to za odpowiednik f(x)(y) -- f(x), call it g, is a function, and you apply that function to y. Innymi słowy, masz tylko funkcje, które przyjmują jeden argument -- ale niektóre z tych funkcji zwracają inne funkcje (które również przyjmują jeden argument;-).

Jak zwykle, wikipedia ma ładny wpis podsumowujący na ten temat, z wieloma przydatnymi wskazówkami (prawdopodobnie w tym dotyczącymi twoich ulubionych języków; -), a także nieco bardziej rygorystycznym traktowaniem matematycznym.

Oto konkretny przykład:

Załóżmy, że masz funkcję, która oblicza siłę grawitacji działającą na obiekt. Jeśli nie znasz wzoru, możesz go znaleźć TUTAJ . Ta funkcja przyjmuje trzy niezbędne parametry jako argumenty.

Teraz, będąc na ziemi, chcesz tylko obliczyć siły dla obiektów na tej planecie. W języku funkcjonalnym można przekazać masę ziemi do funkcji, a następnie częściowo ją ocenić. What you ' d get back jest inną funkcją, która przyjmuje tylko dwa argumenty i oblicza siłę grawitacji obiektów na ziemi. To się nazywa currying.

Może to być sposób na wykorzystanie funkcji do tworzenia innych funkcji.

W javascript:

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

Pozwoliłby nam nazwać to tak:

let addTen = add(10);

Po uruchomieniu {[11] } jest przekazywana jako x;

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

Co oznacza, że zwracamy tę funkcję:

function(y) { return 10 + y };

Więc kiedy zadzwonisz

 addTen();

Naprawdę dzwonisz:

 function(y) { return 10 + y };

Więc jeśli to zrobisz:

 addTen(4)

To to samo co:

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

Więc nasz addTen() zawsze dodaje dziesięć do cokolwiek przekażemy. Możemy tworzyć podobne funkcje w ten sam sposób:

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

Wyobraź sobie, że nasza funkcja Curry wyglądała tak:

let doTheHardStuff = function(x) {
  let z = doSomethingComputationallyExpensive(x)
  return function (y){
    z + y
  }
}

Możemy wywołać tę funkcję raz, następnie przekazujemy wynik do wykorzystania w wielu miejscach, co oznacza, że robimy tylko raz kosztowne obliczeniowo rzeczy: {]}

let finishTheJob = doTheHardStuff(10)
finishTheJob(20)
finishTheJob(30)

Możemy uzyskać abstrakcje w podobny sposób.

Currying jest transformacją, która może być zastosowana do funkcji, aby umożliwić im przyjęcie jednego argumentu mniej niż poprzednio.

Na przykład w F# można zdefiniować funkcję w następujący sposób:-

let f x y z = x + y + z

Tutaj funkcja f pobiera parametry x, y i z i sumuje je razem tak:-

f 1 2 3

Zwraca 6.

Z naszej definicji możemy zatem zdefiniować funkcję curry ' ego dla f: -

let curry f = fun x -> f x

Gdzie 'fun x - > f x' jest funkcją lambda równą X = > f (x) w C#. Funkcja ta wprowadza funkcję, którą chcesz curry i zwraca funkcję, która pobiera pojedynczy argument i Zwraca określoną funkcję z pierwszym argumentem ustawionym na argument wejściowy.

Używając naszego poprzedniego przykładu możemy otrzymać curry f w ten sposób:-

let curryf = curry f

Możemy wtedy wykonać następujące czynności:-

let f1 = curryf 1

Który daje nam funkcję f1, która jest równa F1 y z = 1 + y + z. oznacza to, że możemy wykonać następujące czynności:-

f1 2 3

Który zwraca 6.

Ten proces jest często mylony z 'częściowym zastosowaniem funkcji', które można zdefiniować w ten sposób:-

let papply f x = f x

Choć możemy go rozszerzyć do więcej niż jednego parametru, tj.:-

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

Częściowa aplikacja pobierze funkcję i parametr(y) i zwróci funkcję, która wymaga jednego lub więcej Mniej parametrów, A Jak pokazują poprzednie dwa przykłady, jest zaimplementowana bezpośrednio w standardowej definicji funkcji F#, dzięki czemu możemy osiągnąć poprzedni wynik tak więc: -

let f1 = f 1
f1 2 3

Który zwróci wynik 6.

Podsumowując:-

Różnica między curryingiem a częściowym zastosowaniem funkcji jest taka, że:-

Currying przyjmuje funkcję i dostarcza nową funkcję przyjmującą pojedynczy argument i zwracającą podaną funkcję z jej pierwszym argumentem ustawionym na ten argument. to pozwala nam reprezentować funkcje z wieloma parametrami jako szereg funkcji pojedynczego argumentu . Przykład: -

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

Częściowa aplikacja funkcji jest bardziej bezpośrednia - pobiera funkcję i jeden lub więcej argumentów i zwraca funkcję z pierwszymi N argumentami ustawionymi na N podanych argumentów. Przykład: -

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

Funkcja curry jest funkcją kilku argumentów przepisanych tak, że przyjmuje pierwszy argument i zwraca funkcję, która akceptuje drugi argument i tak dalej. Pozwala to funkcjom kilku argumentów częściowo zastosować niektóre z ich początkowych argumentów.

Oto przykład zabawki w Pythonie:

>>> from functools import partial as curry

>>> # Original function taking three parameters:
>>> def display_quote(who, subject, quote):
        print who, 'said regarding', subject + ':'
        print '"' + quote + '"'


>>> display_quote("hoohoo", "functional languages",
           "I like Erlang, not sure yet about Haskell.")
hoohoo said regarding functional languages:
"I like Erlang, not sure yet about Haskell."

>>> # Let's curry the function to get another that always quotes Alex...
>>> am_quote = curry(display_quote, "Alex Martelli")

>>> am_quote("currying", "As usual, wikipedia has a nice summary...")
Alex Martelli said regarding currying:
"As usual, wikipedia has a nice summary..."

(po prostu używam konkatenacji przez +, aby uniknąć rozproszenia uwagi dla programistów spoza Pythona.)

Edycja do dodania:

Zobacz http://docs.python.org/library/functools.html?highlight=partial#functools.partial , co pokazuje również podział częściowego obiektu na funkcje w sposób, w jaki implementuje to Python.

Jeśli rozumiesz, jesteś w połowie drogi. Ideą partial jest wstępne zastosowanie argumentów do funkcji i zwrócenie nowej funkcji, która chce tylko pozostałych argumentów. Kiedy ta nowa funkcja jest wywoływana, zawiera wstępnie załadowane argumenty wraz z argumentami, które zostały jej dostarczone.

W Clojure + jest funkcją, ale żeby wszystko było jasne:

(defn add [a b] (+ a b))

Możesz być świadomy, że funkcja inc po prostu dodaje 1 do dowolnej liczby zdałem.

(inc 7) # => 8

Zbudujmy go sami używając partial:

(def inc (partial add 1))

Tutaj zwracamy inną funkcję, która ma 1 załadowany do pierwszego argumentu add. Ponieważ add pobiera dwa argumenty, nowa funkcja inc chce tylko argumentu b - a nie 2 argumenty jak poprzednio, ponieważ 1 został już częściowo zastosowany. Tak więc partial jest narzędziem do tworzenia nowych funkcji z domyślnymi wartościami. Dlatego w języku funkcyjnym funkcje często porządkują argumenty od ogólnych do szczegółowych. Ułatwia to ponowne wykorzystanie takich funkcji, z których można konstruować inne funkcje.

Teraz wyobraź sobie, że język był wystarczająco mądry, aby zrozumieć introspektywnie, że add chciał dwóch argumentów. Kiedy przekazaliśmy jeden argument, a nie balking, co jeśli funkcja częściowo zastosowała argument przekazaliśmy go w naszym imieniu rozumiejąc, że prawdopodobnie zamierzamy dostarczyć drugi argument później? Możemy wtedy zdefiniować {[7] } bez jawnego użycia partial.

(def inc (add 1)) #partial is implied

Tak zachowują się niektóre języki. Jest to wyjątkowo przydatne, gdy chce się komponować funkcje w większe przekształcenia. To prowadziłoby do przetworników.

Currying jest tłumaczeniem funkcji z możliwego do wywołania jako f(a, b, c) na możliwą do wywołania jako f(a)(b)(c).

Inaczej currying polega na rozbiciu funkcji, która przyjmuje wiele argumentów na szereg funkcji, które biorą część argumentów.

Dosłownie, currying jest przekształceniem funkcji: z jednego sposobu wywołania w inny. W JavaScript Zwykle tworzymy wrapper, aby zachować oryginalną funkcję.

Currying nie wywołuje funkcji. To po prostu przekształca to.

Zróbmy funkcję curry 'ego, która wykonuje Curry' ego dla funkcji dwuargumentowych. Innymi słowy, curry(f) dla dwuargumentowego f(a, b) tłumaczy go na f(a)(b)

function curry(f) { // curry(f) does the currying transform
  return function(a) {
    return function(b) {
      return f(a, b);
    };
  };
}

// usage
function sum(a, b) {
  return a + b;
}

let carriedSum = curry(sum);

alert( carriedSum(1)(2) ); // 3

Jak widać, implementacja jest serią wrapperów.

• wynikiem curry(func) jest wrapper function(a).
• gdy wywołany jest podobnie sum(1), argument jest zapisywany w środowisku leksykalnym i zwracany jest nowy wrapper function(b).
• następnie sum(1)(2) W końcu wywołuje function(b) podając 2, i to przekazuje wywołanie do oryginalnej sumy wielu argumentów.

Currying jest jedną z funkcji wyższego rzędu Java Script.

Currying jest funkcją wielu argumentów, która jest przepisywana tak, że pobiera pierwszy argument i zwraca funkcję, która z kolei używa pozostałych argumentów i zwraca wartość.

Zdezorientowany?

Pokaż przykład,

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

Jest to podobne do następującej funkcji currying,

function add(a)
    {
        return function(b){
            return a+b;
        }
    }
var curryAdd = add(5);
curryAdd(6);

Więc co oznacza ten kod?

Teraz Przeczytaj definicję again,

Currying jest funkcją wielu argumentów, która jest przepisywana tak, że pobiera pierwszy argument i zwraca funkcję, która z kolei używa pozostałych argumentów i zwraca wartość.

Kiedy wywołujesz tę funkcję,

var curryAdd = add(5);

Zwróci ci taką funkcję,

curryAdd=function(y){return 5+y;}

Ta linia przekaże drugi argument do funkcji curryAdd.

curryAdd(6);

Co z kolei powoduje,

curryAdd=function(6){return 5+6;}
// Which results in 11

Mam nadzieję, że rozumiesz użycie currying tutaj. Więc, idąc do zalet,

Dlaczego Currying?

Korzysta z możliwości ponownego użycia kodu. Mniej kodu, mniej błędów. Możesz zapytać, Jak to jest mniej kodu?

Mogę to udowodnić z ECMA script 6 nowe funkcje strzałki.

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

Za pomocą funkcji strzałki możemy zapisać powyższą funkcję w następujący sposób:

x=>y=>x+y

Fajne prawda?

Więc mniej kodu i mniej błędów!!

Z Pomocą tych funkcji wyższego rzędu można łatwo opracować kod wolny od błędów.

Hope, zrozumiałaś, co jest currying. Zapraszam do skomentuj tutaj, jeśli potrzebujesz wyjaśnień.

Dzięki, miłego dnia!

Znalazłem ten artykuł, A artykuł, do którego się odnosi, przydatny, aby lepiej zrozumieć currying: http://blogs.msdn.com/wesdyer/archive/2007/01/29/currying-and-partial-function-application.aspx

Jak inni wspominali, jest to tylko sposób, aby mieć funkcję jednego parametru.

Jest to przydatne w tym, że nie musisz zakładać, ile parametrów zostanie przekazanych, więc nie potrzebujesz funkcji 2, 3 i 4.

Jak wszystkie inne odpowiedzi currying pomaga tworzyć częściowo stosowane funkcje. Javascript nie zapewnia natywnego wsparcia dla automatycznego currying. Powyższe przykłady mogą więc nie pomóc w praktycznym kodowaniu. Jest jakiś doskonały przykład w livescript (który zasadniczo kompiluje się do js) http://livescript.net/

times = (x, y) --> x * y
times 2, 3       #=> 6 (normal use works as expected)
double = times 2
double 5         #=> 10

W powyższym przykładzie, gdy podałeś mniej argumentów livescript generuje dla Ciebie nową funkcję Curry (double)

Curry może uprościć Twój kod. Jest to jeden z głównych powodów, aby z tego skorzystać. Currying jest procesem konwersji funkcji, która akceptuje n argumentów na N funkcji, które akceptują tylko jeden argument.

Zasadą jest przekazywanie argumentów przekazywanej funkcji, używając właściwości closure (closure), aby zapisać je w innej funkcji i traktować jako wartość zwracaną, a te funkcje tworzą łańcuch, a końcowe argumenty są przekazywane w celu zakończenia operacji.

The zaletą tego jest to, że może uprościć przetwarzanie parametrów, zajmując się jednym parametrem na raz, co może również poprawić elastyczność i czytelność programu. To również sprawia, że program jest łatwiejszy w zarządzaniu. Podzielenie kodu na mniejsze części uczyniłoby go przyjaznym do ponownego użycia.

Na przykład:

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

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

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

Jest to bardzo dobre rozwiązanie do uporządkowania złożonego kodu i obsługi niezsynchronizowanych metod itp.

Funkcja Currie jest stosowana do wielu list argumentów, zamiast tylko jeden.

Tutaj jest regularna, nie-Curry funkcja, która dodaje dwa Int parametry, x i y:

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

Tutaj jest podobna funkcja, która jest curry. Zamiast z jednej listy dwóch parametrów Int, można zastosować tę funkcję do dwóch list jednego Int parametr each:

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

Dzieje się tak, że kiedy wywołujesz curriedSum, otrzymujesz dwie tradycyjne wywołania funkcji z powrotem do tyłu. Na pierwsza funkcja wywołanie przyjmuje pojedynczy parametr Int o nazwie x i zwraca funkcję wartość dla drugiej funkcji. Ta druga funkcja przyjmuje parametr Int y.

Oto funkcja o nazwie first, która robi w duchu to, co pierwsze tradycyjne wywołanie funkcji curriedSum wykonałoby:

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

Zastosowanie 1 do pierwszej funkcji-innymi słowy, wywołanie pierwszej funkcji a Przejście W 1-daje drugą funkcję:

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

Zastosowanie 2 do drugiego funkcja daje wynik:

scala> second(2)
res6: Int = 3

Przykładem curryingu może być, gdy mając funkcje w danej chwili znasz tylko jeden z parametrów:

Na przykład:

func aFunction(str: String) {
    let callback = callback(str) // signature now is `NSData -> ()`
    performAsyncRequest(callback)
}

func callback(str: String, data: NSData) {
    // Callback code
}

func performAsyncRequest(callback: NSData -> ()) {
    // Async code that will call callback with NSData as parameter
}

Tutaj, ponieważ nie znasz drugiego parametru wywołania zwrotnego przy wysyłaniu go do performAsyncRequest(_:), Musisz utworzyć inny lambda / closure, aby wysłać go do funkcji.

Oto przykład generycznej i najkrótszej wersji dla funkcji currying z N no. params.

const add = a => b => b ? add(a + b) : a; 

const add = a => b => b ? add(a + b) : a; 
console.log(add(1)(2)(3)(4)());

Tutaj znajdziesz proste wyjaśnienie implementacji w C#. W komentarzach starałem się pokazać, jak currying może być przydatny:

public static class FuncExtensions {
    public static Func<T1, Func<T2, TResult>> Curry<T1, T2, TResult>(this Func<T1, T2, TResult> func)
    {
        return x1 => x2 => func(x1, x2);
    }
}

//Usage
var add = new Func<int, int, int>((x, y) => x + y).Curry();
var func = add(1);

//Obtaining the next parameter here, calling later the func with next parameter.
//Or you can prepare some base calculations at the previous step and then
//use the result of those calculations when calling the func multiple times 
//with different input parameters.

int result = func(1);

Jest przykład "Currying in ReasonML".

let run = () => {
    Js.log("Curryed function: ");
    let sum = (x, y) => x + y;
    Printf.printf("sum(2, 3) : %d\n", sum(2, 3));
    let per2 = sum(2);
    Printf.printf("per2(3) : %d\n", per2(3));
  };

"currying" jest procesem pobierania funkcji wielu argumentów i przekształcania jej w poważny z funkcji, które każdy bierze jeden argument i zwraca funkcję jednego argumentu, lub w przypadku funkcji końcowej zwraca rzeczywisty wynik.