Eine Funktion f haben , die die Argumente x ₁ , x ₂ ,…, x _n annimmt

                                               - dh.  f: X ₁ × X ₂ ×… × X _n → Y

- currying definiert f als eine Funktion neu, wobei ein einzelnes Argument a _{1 verwendet wird,} das einer weiteren Funktion zugeordnet ist. Diese Technik ist nützlich für eine teilweise Anwendung, zum Beispiel mit einer Curry- powFunktion, die wir schreiben könnten exp = pow(e).

Beispiel

Angenommen, wir haben die folgende Funktion f mit drei Argumenten ( f: X ₁ × X ₂ × X ₃ → Y ):

def f(a,b,c):
  return a + b * c

Wenn wir diese Funktion aufrufen, erhalten wir f_curry: X ₁ → (X ₂ → (X ₃ → Y)) . Wenn wir diese Funktion jetzt zweimal mit aufrufen f_curry(1)(2)würden, würden wir eine function ( h) erhalten, die dem folgenden Ergebnis entspricht:

def h(c):
   return 1 + 2 * c

Die Curry-Funktion fkönnte so geschrieben werden (Python 3):

def f_curry(a):
  def g_curry(b):
    def h(c):
      return a + b * c
    return h
  return g_curry

Probieren Sie es online!

Herausforderung

Deine Herausforderung wird darin bestehen, eine Funktion wie oben beschrieben zu curry. Hier sind die Regeln:

• Die Eingabe ist eine Blackbox-Funktion, die mindestens 2 Argumente akzeptiert
• Die Eingabefunktion hat immer eine feste Anzahl von Argumenten (anders als printfoder ähnlich, Anmerkung: Sie müssen Funktionen mit einer beliebigen Anzahl von Argumenten ≥2 unterstützen)
• Wenn Ihre Sprache standardmäßig Curry-Funktionen verwendet (z. B. Haskell), können Sie erwarten, dass die Eingabefunktion über N- Tupel definiert wird, anstatt über eine Funktion "höherer Ordnung".
• Sie können die Anzahl der Argumente als Eingabe verwenden
• Der Output ist das aktuelle Äquivalent des Inputs ^*
• Sie können davon ausgehen, dass die Ausgabefunktion immer nur:
  • wird mit weniger oder gleich der Anzahl der Argumente aufgerufen, die die Eingabefunktion annimmt
  • mit Argumenten des richtigen Typs aufgerufen

^{* Dies würde für eine Eingabe fmit NArgumenten und für eine Ausgabe bedeuten, hdass für alle gültigen Argumente a1,…,aNdies gilt f(a1,a2,…,aN) == h(a1)(a2)…(aN).}

JavaScript (ES6), 35 Byte

f=g=>g.length<2?g:a=>f(g.bind(f,a))

Idris , 204 Bytes

import Data.HVect
C:(a:Vect n Type)->(HVect a->Type)->Type
C[]T=T[]
C(h::t)T=(x:h)->C t(T .(x::))
c:{a:Vect n Type}->{T:HVect a->Type}->((b:HVect a)->T b)->C a T
c{a=[]}f=f[]
c{a=h::t}f=\v=>c(\u=>f(v::u))

Probieren Sie es online!

Klingt nach einem Job für abhängige Typen! Vielleicht.

C ist eine currying Art Funktion. Bei einem Vektor der Typen a = [t ₁ , t ₂ ,… t _n ] und einer Typfunktion T: HVect a → Type wird ein neuer Typ zurückgegeben:

　　　　　　　　　　　(x ₁  : t ₁ ) → (x ₂  : t ₂ ) →… → (T [x ₁ , x ₂ ,… x _n ])

Hier ist HVect der heterogene Vektortyp aus dem Idris-Präludium - der Typ von n- Tupeln, deren Elemente von n sind verschiedenen Typen sind.

c ist eine Funktion, nimmt ein und T als implizite Argumente, und dann eine wandelt uncurried Funktion fvom Typ ((b: HVect a) → T b) in eine curried eines vom Typ C einem T .

( C beschreibt einfach, was wir tun möchten; c tut es tatsächlich. Aber wir kommen nicht damit davon, C nicht zu definieren , da Idris verlangt, dass jede Definition der obersten Ebene eine Typensignatur hat.)

Der TIO-Link enthält ein Verwendungsbeispiel. Wenn wir eine Funktion für 3-Tupel (Nat, Nat, String) wie folgt definieren:

uncurried : HVect [Nat, Nat, String] -> String
uncurried [a, b, c] = show (a*a + b*b) ++ c

uncurried [3, 4, "th"]ergibt dann das gleiche Ergebnis wie c uncurried 3 4 "th". Idris schließt sich den Argumenten an a=[Nat, Nat, String]und T=const Stringfür uns glaube ich.

Ich habe diesen Code auf diesem Kern von timjb aufgebaut.

Python 3 , 54 53 Bytes

c=lambda n,f,*x:lambda y:(f,c)[n>1](*1%n*(n-1,f)+x,y)

Probieren Sie es online!

R , 96 Bytes

y=function(f,n=length(formals(f)),p=list())function(x,u=c(p,x))`if`(n<2,do.call(f,u),y(f,n-1,u))

Probieren Sie es online!

Vorherige Version (97 Bytes)

-1 Byte dank @JayCE

Kokosnuss , 54 Bytes

def c(f,*a):
 try:return f(*a)
 except:return c$(f,*a)

Probieren Sie es online!

Kokosnuss , 40 Bytes

Port of Eriks Python Antwort .

def c(f,n,*a)=n and c$(f,n-1,*a)or f(*a)

Probieren Sie es online!

Python 2 , 60 Bytes

c=lambda f,n,l=[]:lambda a:n-1and c(f,n-1,l+[a])or f(*l+[a])

Probieren Sie es online!

Die Fußzeile ist ein Tester, der STDIN pro Zeile folgendermaßen verwendet:

1. Die Funktion selbst
2. Die Anzahl der Argumente der Funktion, ≥2
3. Eine Liste der Argumente ( [a,b,...])

Beachten Sie, dass, während eine Liste der Argumente als Eingabe im Tester angegeben wird, in der Realität das Curry-Äquivalent der Liste vorangestellt wird und die Liste durch Funktionsaufruf reduziert wird.

Eine ähnliche 55-Byte-Version wurde freundlicherweise von ovs bereitgestellt :

c=lambda f,n,*l:lambda a:n-1and c(f,n-1,*l,a)or f(*l,a)

Probieren Sie es online!

Blumenkohl , 84 Bytes

(:= c(\($f$n(@a))(if$n(\($a)(call c(cat(list$f(-$n 1))@a(list$a))))else(call$f@a))))

Probieren Sie es online!

Perl 6 , 42 40 Bytes

my&c={.count>1??{c(.assuming($^a))}!!$_}

Probieren Sie es online!

-2 Bytes dank Brad Gilbert b2gills .

Python 2 , 78 Bytes

c=lambda f,*a:f.func_code.co_argcount>len(a)and(lambda x:c(f,*a+(x,)))or f(*a)

Probieren Sie es online!

Attache , 5 Bytes

Curry

Probieren Sie es online!

Einfach eingebaut, weitgehend uninteressant. Aber hier ist eine Version von Grund auf neu:

Attache, 35 Bytes

{If[#__2<#_,Fold[`&:,$'__],_@@__2]}

Erläuterung:

{If[#__2<#_,Fold[`&:,$'__],_@@__2]}
{                                 }    lambda
 If[       ,              ,      ]     if
    #__2                                 the number of parameters after the first
        <#_                              is less than the arity of the first
            Fold[   ,    ]             then fold:
                 `&:                     right-function bonding
                     $                     over this function
                      '__                  paired with the rest of the parameters
                          ,            otherwise:
                           _@@           call the first parameter
                              __2        with the rest of them

Java 8, 46 + 318 = 364 Bytes

Dies ist ein Curry-Lambda (hah), das eine Funktion und eine Argumentanzahl annimmt und die Curry-Funktion zurückgibt.

import java.lang.reflect.*;import java.util.*;

f->p->new java.util.function.Function(){Object F=f;Method m=F.getClass().getDeclaredMethods()[0];int P=p;List a=new Stack();public Object apply(Object r){a.add(r);try{return a.size()<P?this:m.invoke(F,a.toArray());}catch(Throwable t){t=t.getCause();if(t instanceof Error)throw(Error)t;else throw(RuntimeException)t;}}}

Probieren Sie es online

Einreichungsart

Eingabefunktion

Die Funktionseingabe ist ein Objekt mit einer einzelnen Methode (ausgenommen geerbte Methoden), die die Funktion darstellt. Beachten Sie, dass eine Standardfunktionsschnittstelle nicht als Eingabetyp verwendet werden kann, da Funktionen von (z. B.) 3 Parametern unterstützt werden müssen. Beachten Sie auch, dass ein Lambda-Ausdruck, der in einen standardähnlichen java.util.function.FunctionTyp umgewandelt wurde, übergeben werden kann (die einzige Methode ist apply).

Überprüfte Ausnahmen können in der Eingabefunktion deklariert, aber nicht ausgelöst werden (dh sie werden nicht an den Aufrufer der Ausgabefunktion weitergegeben). Dies wird als akzeptabel angesehen, da die Funktionsschnittstellen von Java keine geprüften Ausnahmen zulassen (und deren Weitergabe die Übermittlung von a verhindern würde Function). Laufzeitausnahmen (zuweisbar auf RuntimeExceptionoderError ) werden weitergegeben.

Ausgangsfunktion

Die Ausgabe der Einreichung ist a java.util.function.Function<Object, Object>. Ich überlegte, eine Ebene Objectmit einemapply Methode (wie in der Eingabe) zurückzugeben, aber dann wäre eine Reflektion erforderlich, um das Ergebnis aufzurufen, was unpraktisch genug schien, um nicht zulässig zu sein - insbesondere, wenn in einer einzigen Methode kein vollständiger Abwärtsaufruf mehr möglich wäre Ausdruck.

Verwendung

Da die Übermittlung eine Funktion von Objectbis zurückgibt Object, kann die Ausgabe direkt (mit apply) aufgerufen werden , nachfolgende Zwischenrückgabewerte müssen jedoch in einen geeigneten Typ umgewandelt werden (z. B.java.util.function.Function<Object, Object> ) umgewandelt werden. Konsultieren Sie den TIO für einige Anwendungsbeispiele.

Beachten Sie, dass in Java Funktionen (dh Methoden) keine erstklassigen Objekte sind. Daher ist die im Ausgabe-Aufzählungszeichen der Challenge-Beschreibung verwendete Syntax in Java bedeutungslos. Eher als f(a1, a2, a3)wir f.apply(a1, a2, a3)und eher als f(a1)(a2)(a3)wir f.apply(a1).apply(a2).apply(a3).

Einschränkungen

Wenn ein Zwischenergebnis angewendet wird (ein Argument hinzugefügt), ist das Ergebnis tatsächlich eine mutierte Kopie des ursprünglichen Ergebnisses. Zum Beispiel in diesem Snippet:

Function<Object, Function<Integer, Function>> submission = ...;
Function c = submission.apply((IntBinaryOperator) (a, b) -> a + b).apply(2);
Function c2 = (Function) c.apply(2);
System.out.println(c2.apply(2));
System.out.println(c2.apply(3));

Zeile 4 würde gedruckt 4, aber Zeile 5 würde fehlschlagen, da zu diesem Zeitpunkt c2bereits Argumente 2und 2(beachte auch das) enthalten sindc2 == c). This violates the spirit of currying, but meets the specific requirement stated in the challenge.

Ungolfed

Eine unbenutzte Kopie finden Sie beim TIO.

Julia 0,6 , 48 Bytes

c=(f,n,a=[])->n>1?x->c(f,n-1,[a;x]):x->f(a...,x)

Probieren Sie es online!

Port von @ EricTheOutgolfers Python-Antwort.

APL (Dyalog Classic), 58 57 bytes

∇r←(a f g)x
:If a[1]=≢a
r←g 1↓a,x
:Else
r←(a,x)f g
:End
∇

Try it online!

Calling syntax (with curried function g, arguments x1 through x3, and number of arguments n):

((n x1 f g) x2) x3

Requires ⎕IO←1