एक समारोह के बाद च कि तर्क लेता एक्स ₁ , x ₂ , ..., एक्स _n

- अर्थात। f: X ₁ × X ₂ ×… × X _n → Y

- currying Redefines च एक समारोह के रूप में एक भी तर्क लेने एक ₁ जो अभी तक एक और कार्य करने के लिए मैप करता है। यह तकनीक आंशिक अनुप्रयोग के लिए उपयोगी है, उदाहरण के लिए एक घुमावदार powफ़ंक्शन के साथ हम लिख सकते हैं exp = pow(e)।

उदाहरण

मान लिया जाये कि हम निम्न कार्य हो च तीन तर्कों लेने ( च: एक्स ₁ × एक्स ₂ × एक्स ₃ → Y ):

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

इस फ़ंक्शन को करीने से हमें f_curry: X ₁ → (X ₂ → (X ₃ → Y)) के साथ छोड़ दिया जाता है , अगर हम अब उस फ़ंक्शन को दो बार कॉल करेंगे तो हमें f_curry(1)(2)एक फ़ंक्शन मिलेगा ( h) निम्न रिटर्न के बराबर होगा:

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

करी फ़ंक्शन fको इस तरह लिखा जा सकता है (पायथन 3):

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

इसे ऑनलाइन आज़माएं!

चुनौती

आपकी चुनौती ऊपर बताए गए फंक्शन की करी होगी, यहाँ नियम हैं:

इनपुट एक ब्लैकबॉक्स फ़ंक्शन होगा जो कम से कम 2 तर्क लेता है
इनपुट फ़ंक्शन में हमेशा निश्चित संख्या में तर्क होंगे (विपरीत printfया समान, ध्यान दें: आपको किसी भी तर्क के साथ कार्यों का समर्थन करने की आवश्यकता है argu2)
यदि आपकी भाषा डिफ़ॉल्ट रूप से करी कार्यों का उपयोग करती है (उदाहरण के लिए। हास्केल), तो आप इनपुट फ़ंक्शन को "उच्च-क्रम फ़ंक्शन" के बजाय N -tuples पर परिभाषित करने की अपेक्षा कर सकते हैं।
आप इनपुट के रूप में तर्कों की संख्या ले सकते हैं
आउटपुट इनपुट का करी समकक्ष होगा ^*
आप मान सकते हैं कि आउटपुट फ़ंक्शन केवल कभी होगा:
- इनपुट फ़ंक्शन को ले जाने वाले तर्कों की संख्या से कम या बराबर के साथ कहा जाता है
- सही प्रकार के तर्कों के साथ कहा जाता है

^{* इसका मतलब होगा तर्कों के fसाथ एक इनपुट Nऔर एक आउटपुट hजो सभी मान्य तर्कों के लिए a1,…,aNहोता है f(a1,a2,…,aN) == h(a1)(a2)…(aN)।}

code-golf function functional-programming

— ბიმო
स्रोत

जावास्क्रिप्ट (ईएस 6), 35 बाइट्स

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

— नील
स्रोत

9

इदरीस , 204 बाइट्स

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))

इसे ऑनलाइन आज़माएं!

आश्रित प्रकारों के लिए नौकरी की तरह लगता है! शायद हो सकता है।

सी एक करी प्रकार का कार्य है। प्रकारों के एक वेक्टर को देखते हुए a = [t ₁ , t ₂ ,… t _n ] और एक प्रकार का कार्य T: HVect a → प्रकार , यह एक नया प्रकार लौटाता है:

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

इधर, HVect है विषम वेक्टर प्रकार के प्रकार - इदरिस प्रस्तावना से n -tuples जिसका तत्वों की हैं n विभिन्न प्रकार।

ग एक समारोह है कि लेता है एक और टी अंतर्निहित तर्क के रूप में, और फिर रूपांतरित एक uncurried समारोह fप्रकार के : (HVect एक) → टी बी (ख) एक में curried प्रकार से एक सी एक टी ।

( सी केवल वर्णन करता है कि हम क्या करना चाहते हैं? सी वास्तव में यह नहीं करता है। लेकिन हम सी को परिभाषित नहीं करने के साथ दूर नहीं हो सकते हैं , क्योंकि इदरीस की मांग है कि प्रत्येक शीर्ष-स्तरीय परिभाषा में एक प्रकार का हस्ताक्षर है।)

TIO लिंक एक उपयोग उदाहरण देता है। यदि हम 3-ट्यूपल्स (नेट, नेट, स्ट्रिंग) पर एक फ़ंक्शन को निम्नानुसार परिभाषित करते हैं:

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

फिर uncurried [3, 4, "th"]उसी परिणाम के रूप में पैदावार c uncurried 3 4 "th"। इदरीस तर्कों का उल्लंघन करता है a=[Nat, Nat, String]और T=const Stringहमारे लिए, मेरा मानना है।

मैं इस कोड को इस समय पर आधारित कर रहा हूं।

— लिन
स्रोत

मेरी राय में, हास्केल और इदरीस में टुपल्स वास्तव HVectमें डिफ़ॉल्ट रूप HVectसे होना चाहिए- अनिवार्य रूप से एक टपल है जिसे आप बेहोश कर सकते हैं।

— 3

5

पायथन 3 , 54 53 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत

5

आर , 96 बाइट्स

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))

इसे ऑनलाइन आज़माएं!

पिछला संस्करण (97 बाइट्स)

-1 बाइट @JayCE को धन्यवाद

— digEmAll
स्रोत

मैं यह नहीं देखता कि इसे कैसे मौलिक रूप से छोटा किया जाए। आप पहली पंक्ति के अंत में ब्रेसिज़ और अंतरिक्ष से छुटकारा पाकर तीन बाइट्स को दूर कर सकते हैं। और दो और यहां अधिवेशन के कारण बाइट काउंट में फ़ंक्शन का नाम शामिल नहीं है। TIO

— एन जी एम

@ng पुनरावर्ती होने पर फ़ंक्शन नाम शामिल होना चाहिए।

— अर्जन जोहानसन

@ngm: मैंने उप-फंक्शन के दसवें हिस्से को बाइट्स में बचाने के लिए इफ स्टेटमेंट डाल दिया :)

— digEmAll

4

नारियल , 54 बाइट्स

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

इसे ऑनलाइन आज़माएं!

नारियल , 40 बाइट्स

पोर्ट ऑफ एरिक के पायथन उत्तर ।

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

इसे ऑनलाइन आज़माएं!

— OVS
स्रोत

3

पायथन 2 , 60 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पाद एक परीक्षक है जो प्रति पंक्ति निम्नलिखित तरीके से STDIN का उपयोग करता है:

कार्य ही
फ़ंक्शन के तर्कों की संख्या,'s2
तर्कों की एक सूची ( [a,b,...])

ध्यान दें कि, जबकि तर्कों की एक सूची परीक्षक में इनपुट के रूप में दी गई है, वास्तविकता में, क्यूरेड समतुल्य सूची में शामिल हो जाता है और फ़ंक्शन कॉल द्वारा सूची को कम कर दिया जाता है।

एक समान 55-बाइट संस्करण ओवस द्वारा प्रदान किया गया है :

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

इसे ऑनलाइन आज़माएं!

— आउटग्रॉफर को एरिक करें
स्रोत

2

फूलगोभी , 84 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— ASCII-केवल
स्रोत

1

मम, फूलगोभी करी। स्वादिष्ट। ^ _ ^

— DLosc

@ डलास भोजन संबंधी नामों के साथ भाषा में इस चुनौती के लिए पर्याप्त जवाब नहीं हैं: पी (हालांकि मुझे लगता है कि उनमें से अधिकांश वास्तव में कार्य नहीं करते हैं)

— एएससीआईआई-केवल

2

पर्ल 6 , 42 40 बाइट्स

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

इसे ऑनलाइन आज़माएं!

ब्रैड गिल्बर्ट b2gills के लिए -2 बाइट्स धन्यवाद ।

— nwellnhof
स्रोत

आपको एक अनुगामी का उपयोग करने की आवश्यकता नहीं है *, यह केवल आवश्यक है अगर इसके बाद कुछ ऐसा हो .assuming(*,1)।

— ब्रैड गिल्बर्ट b2gills

1

पायथन 2 , 78 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— OVS
स्रोत

1

अटैची , 5 बाइट्स

Curry

इसे ऑनलाइन आज़माएं!

में निर्मित सरल, काफी हद तक निर्बाध। लेकिन, यहाँ एक संस्करण खरोंच से है:

अटैची, 35 बाइट्स

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

स्पष्टीकरण:

{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

— कोनोर ओ ब्रायन
स्रोत

1

जावा 8, 46 + 318 = 364 बाइट्स

यह एक फंक्शनल (हाह) लैम्बडा है जो एक फंक्शन और एक तर्क गिनता है और क्यूरेड फंक्शन को वापस करता है।

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;}}}

यह ऑनलाइन की कोशिश करो

प्रस्तुत करने का प्रकार

इनपुट फ़ंक्शन

फ़ंक्शन इनपुट फ़ंक्शन का प्रतिनिधित्व करने वाली एकल विधि (विरासत में मिली विधियों को छोड़कर) के साथ एक ऑब्जेक्ट है। ध्यान दें कि एक मानक कार्यात्मक इंटरफ़ेस का उपयोग इनपुट प्रकार के रूप में नहीं किया जा सकता है क्योंकि (जैसे) 3 मापदंडों के कार्यों का समर्थन किया जाना चाहिए। यह भी ध्यान दें कि मानक java.util.function.Function-प्रकार के प्रकार का एक लंबो एक्सप्रेशन पास किया जा सकता है (एकल विधि apply)।

चेक किए गए अपवादों को इनपुट फ़ंक्शन पर घोषित किया जा सकता है, लेकिन उन्हें फेंका नहीं जा सकता है (यानी वे आउटपुट फ़ंक्शन के कॉलर को प्रचारित नहीं किया जाएगा)। यह स्वीकार्य माना जाता है क्योंकि जावा के कार्यात्मक इंटरफेस चेक किए गए अपवादों की अनुमति नहीं देते हैं (और उन्हें प्रचारित करने से जमा को वापस आने से रोका जा सकेगा Function)। रनटाइम अपवाद (करने के लिए असाइन RuntimeExceptionया Error) प्रचारित हैं।

आउटपुट फ़ंक्शन

सबमिशन का आउटपुट ए है java.util.function.Function<Object, Object>। मैंने Objectएक applyविधि के साथ एक सादा लौटाने पर विचार किया (जैसे इनपुट में), लेकिन फिर परिणाम को लागू करने के लिए प्रतिबिंब की आवश्यकता होगी, जो काफी असुविधाजनक लग रहा था - विशेष रूप से, सभी तरह से नीचे कॉल करना अब एक एकल में संभव नहीं होगा अभिव्यक्ति।

प्रयोग

क्योंकि प्रस्तुत करने से एक फ़ंक्शन Objectकरने के लिए Object, उत्पादन सीधे लागू किया जा सकता है (साथ apply), लेकिन बाद में मध्यवर्ती वापसी मान एक उचित प्रकार (उदाहरण के लिए डाली जानी चाहिए java.util.function.Function<Object, Object>लागू किए जाने से पहले)। कुछ उपयोग उदाहरणों के लिए TIO से परामर्श करें।

ध्यान दें कि जावा फ़ंक्शंस (अर्थात विधियाँ) प्रथम श्रेणी की वस्तुएँ नहीं हैं। इस प्रकार चुनौती विवरण के आउटपुट बुलेट में प्रयुक्त वाक्यविन्यास जावा में अर्थहीन है। बल्कि f(a1, a2, a3)हमारे पास है f.apply(a1, a2, a3), और बजाय f(a1)(a2)(a3)हमारे पास है f.apply(a1).apply(a2).apply(a3)।

सीमाएं

जब एक मध्यवर्ती परिणाम लागू किया जाता है (एक तर्क जोड़ा जाता है), तो परिणाम वास्तव में मूल परिणाम की एक उत्परिवर्तित प्रति है। उदाहरण के लिए, इस स्निपेट में:

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));

पंक्ति 4 प्रिंट होगी 4, लेकिन पंक्ति 5 विफल हो जाएगी, क्योंकि उस समय तक c2पहले से ही तर्क हैं 2और 2(ध्यान दें कि c2 == c)। यह करी की भावना का उल्लंघन करता है, लेकिन चुनौती में बताई गई विशिष्ट आवश्यकता को पूरा करता है।

Ungolfed

एक ungolfed कॉपी के लिए TIO देखें।

— जेकब
स्रोत

1

जूलिया 0.6 , 48 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पोर्ट ऑफ @ EricTheOutgolfer का पायथन जवाब।

— sundar - मोनिका को बहाल करना
स्रोत

0

एपीएल (डायलॉग क्लासिक) , 58 57 बाइट्स

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

इसे ऑनलाइन आज़माएं!

कॉलिंग सिंटैक्स (करी फ़ंक्शन के साथ g, तर्कों के x1माध्यम से x3और तर्कों की संख्या n):

((n x1 f g) x2) x3

आवश्यक है ⎕IO←1

— जाकारी
स्रोत

मुझे कुछ करवा दो

उदाहरण

चुनौती

जावास्क्रिप्ट (ईएस 6), 35 बाइट्स

इदरीस , 204 बाइट्स

पायथन 3 , 54 53 बाइट्स

आर , 96 बाइट्स

नारियल , 54 बाइट्स

नारियल , 40 बाइट्स

पायथन 2 , 60 बाइट्स

फूलगोभी , 84 बाइट्स

पर्ल 6 , 42 40 बाइट्स

पायथन 2 , 78 बाइट्स

अटैची , 5 बाइट्स

अटैची, 35 बाइट्स

जावा 8, 46 + 318 = 364 बाइट्स

प्रस्तुत करने का प्रकार

इनपुट फ़ंक्शन

आउटपुट फ़ंक्शन

प्रयोग

सीमाएं

Ungolfed

जूलिया 0.6 , 48 बाइट्स

एपीएल (डायलॉग क्लासिक) , 58 57 बाइट्स