करी के वास्तविक उपयोग के मामले क्या हैं?

Question

मैं करीबी पर बहुत सारे लेख पढ़ रहा हूं, लेकिन उनमें से लगभग सभी भ्रामक हैं, आंशिक फ़ंक्शन एप्लिकेशन के रूप में करीकरण को समझाते हैं और सभी उदाहरण आमतौर पर 2 की धैर्य के साथ कार्य करते हैं, जैसे add फ़ंक्शन या कुछ।

की curry जावास्क्रिप्ट में समारोह बनाता आंशिक आवेदन प्रति 1 से अधिक तर्क को स्वीकार करने के अलावा कई कार्यान्वयन (lodash देखें), जब Wikipedia article स्पष्ट रूप से है कि currying बताता है के बारे में है:

एक फंक्शन का मूल्यांकन का अनुवाद है कि कार्यों में से एक दृश्य का मूल्यांकन, एक भी तर्क के साथ प्रत्येक (आंशिक आवेदन)

तो मूल रूप से currying प्रत्येक आंशिक अनुप्रयोगों की एक श्रृंखला के लिए एक एकल एक साथ है में कई तर्क (या तर्कों की किसी टपल) लेता है rgument। और मैं वास्तव में किसी भी भाषा में, वास्तविक उपयोगों को जानना चाहता हूं।

Answer 1

करी का वास्तविक उपयोग केस आंशिक अनुप्रयोग है।

स्वयं द्वारा करीना बहुत दिलचस्प नहीं है। दिलचस्प बात यह है कि यदि आपकी प्रोग्रामिंग भाषा डिफ़ॉल्ट रूप से करीकरण का समर्थन करती है, जैसा कि एफ # या हास्केल में है।

आप प्रथम श्रेणी के कार्यों का समर्थन करने वाली किसी भी भाषा में करी और आंशिक अनुप्रयोग के लिए उच्च ऑर्डर फ़ंक्शंस को परिभाषित कर सकते हैं, लेकिन जब आप जो भी फ़ंक्शन प्राप्त करते हैं, वह लचीलापन से बहुत रोना होता है, और इस प्रकार आंशिक रूप से आपके बिना आंशिक रूप से लागू होता है कुछ भी करो।

तो यदि आप लोगों को करी और आंशिक अनुप्रयोग को भंग करने वाले लोगों को देखते हैं, तो यह है कि उन अवधारणाओं को कितनी बारीकी से बंधे हुए हैं - चूंकि करीकरण सर्वव्यापी है, इसलिए आपको लगातार तर्कों के लिए करीबी कार्यों को लागू करने के बजाय आंशिक आवेदन के अन्य रूपों की आवश्यकता नहीं है।

Answer 2

संदर्भ पास करने के लिए उपयोगी है।

'मानचित्र' फ़ंक्शन पर विचार करें। यह तर्क के रूप में एक समारोह लेता है:

map : (a -> b) -> [a] -> [b] 

एक समारोह जो संदर्भ के कुछ फार्म का उपयोग करता है को देखते हुए:

f : SomeContext -> a -> b 

इसका मतलब है आप सुंदर ढंग से 'A'-तर्क राज्य के लिए बिना नक्शा समारोह का उपयोग कर सकते :

:

map (f actualContext) [1,2,3] 

currying बिना, आप एक लैम्ब्डा का उपयोग करना होगा 210

नोट्स:

map एक समारोह जो a, एक समारोह f के मूल्यों से युक्त एक सूची लेता है। यह प्रत्येक a ले कर और f को लागू करके

उदाहरण के लिए एक नई सूची तैयार करता है। map (+1) [1,2,3] = [2,3,4]

Answer 3

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

सिंटेक्स अंक 1:

Currying कुछ मामलों में अधिक से अधिक कोड स्पष्टता की अनुमति देता है। स्पष्टता का क्या अर्थ है? फ़ंक्शन पढ़ना इसकी कार्यक्षमता का स्पष्ट संकेत प्रदान करता है। उदा। मानचित्र समारोह

map : (a -> b) -> ([a] -> [b]) 

इस तरह से पढ़ें, हम देखते हैं कि नक्शा एक उच्च आदेश समारोह एक समारोह है कि [b] को [a] बदल करने के लिए bs को as बदलने एक समारोह लिफ्टों है।

इस अंतर्ज्ञान को विशेष रूप से उपयोगी होने पर यह अंतर्ज्ञान उपयोगी होता है।

map (map (+1)) 

भीतरी नक्शा [a] -> [b] ऊपर प्रकार है। बाहरी मानचित्र के प्रकार को जानने के लिए, हम उपरोक्त से हमारे अंतर्ज्ञान को पुन: लागू करते हैं। बाहरी नक्शा इस प्रकार [a] -> [b] से [[a]] -> [[b]] ले जाता है।

यह अंतर्ज्ञान आपको एक बहुत आगे ले जाएगा। एक बार जब हम map को fmap पर map पर मनमाने ढंग से कंटेनरों पर सामान्यीकृत करते हैं, तो इस तरह के अभिव्यक्तियों को पढ़ने में वास्तव में आसान हो जाता है (नोट मैंने उदाहरण के लिए प्रत्येक fmap के प्रकार को मोनोमोर्फिज्ड किया है)।

showInt : Int -> String 
(fmap . fmap . fmap) showInt : Tree (Set [Int]) -> Tree (Set [String]) 

उम्मीद है कि इसके बाद के संस्करण दिखाता है कि fmap कुछ मनमाने ढंग से कंटेनर से अधिक कार्यों में वेनिला कार्यों उठाने के इस सामान्यीकृत धारणा प्रदान करता है।

सिंटेक्स समस्या 2:

Currying भी बिंदु से मुक्त रूप में कार्य करता है व्यक्त करने के लिए अनुमति देता है।

nthSmallest : Int -> [Int] -> Maybe Int 
nthSmallest n = safeHead . drop n . sort 

safeHead (x:_) = Just x 
safeHead _  = Nothing 

उपर्युक्त आमतौर पर अच्छी शैली माना जाता है क्योंकि यह डेटा के स्पष्ट हेरफेर के बजाय कार्यों की पाइपलाइन के संदर्भ में सोच को दर्शाता है।

कार्यान्वयन:

हास्केल में, बिंदु मुक्त शैली (currying के माध्यम से) हमें कार्यों का अनुकूलन कर सकते हैं। बिंदु मुक्त रूप में एक फ़ंक्शन लिखना हमें इसे याद रखने की अनुमति देगा।

memoized_fib :: Int -> Integer 
memoized_fib = (map fib [0 ..] !!) 
    where fib 0 = 0 
      fib 1 = 1 
      fib n = memoized_fib (n-2) + memoized_fib (n-1) 


not_memoized_fib :: Int -> Integer 
not_memoized_fib x = map fib [0 ..] !! x 
    where fib 0 = 0 
      fib 1 = 1 
      fib n = not_memoized_fib (n-2) + not_memoized_fib (n-1) 

memoized संस्करण में के रूप में एक curried समारोह के रूप में यह लेखन एक इकाई के रूप curried समारोह व्यवहार करता है और इसलिए यह memoizes।