आंशिक बनाम उपयोग करी

जॉन स्कीट के एक लेख का अनुवाद, एक प्रसिद्ध सी # भाषा गुरु , सी # इन डेप्थ का लेखक , एक Google कर्मचारी, प्रतिष्ठा व्यक्ति # 1 stackoverflow.com पर, और अंत में नायक जॉन स्कीट फैक्ट्स । इस लेख में, जॉन स्पष्ट रूप से बताता है कि एक फ़ंक्शन के करी और आंशिक अनुप्रयोग क्या हैं, अवधारणाएं जो कार्यात्मक प्रोग्रामिंग की दुनिया से आती हैं। इसके अलावा, वह विस्तार से बताते हैं कि उनका अंतर क्या है। मैं स्वीकार करता हूं कि मैंने स्वयं इस लेख को पढ़ने से पहले उन्हें भ्रमित किया था, इसलिए यह मुझे अनुवाद करने के लिए उपयोगी लगा।


यह एक विचित्र पोस्ट है, और इसे पढ़ने से पहले, आपको शायद इनमें से किसी एक समूह में खुद को संदर्भित करना चाहिए:

• जो लोग कार्यात्मक प्रोग्रामिंग में रुचि नहीं रखते हैं और उच्च-क्रम वाले कार्यों को भ्रामक पाते हैं: आप इस लेख को पूरी तरह से छोड़ सकते हैं।
• जो लोग कार्यात्मक प्रोग्रामिंग के बारे में सब जानते हैं और करी और आंशिक फ़ंक्शन अनुप्रयोग के बीच अंतर को अच्छी तरह से समझते हैं: कृपया इस पोस्ट को ध्यान से पढ़ें और यदि आप गलतियाँ पाते हैं तो टिप्पणियों में सदस्यता छोड़ें।
• जो लोग कार्यात्मक प्रोग्रामिंग से आंशिक रूप से परिचित हैं और अधिक सीखने में रुचि रखते हैं: इस पोस्ट के बारे में संदेह करें और टिप्पणियों को ध्यान से पढ़ें। अधिक जानकारी के लिए अधिक अनुभवी डेवलपर्स द्वारा अन्य लेख पढ़ें।

सामान्य तौर पर, मुझे पता है कि कुछ लोग कभी-कभी किसी फ़ंक्शन के करीने और आंशिक अनुप्रयोग की शर्तों को भ्रमित करते हैं - उनका उपयोग तब किया जाता है जब ऐसा नहीं किया जाना चाहिए। यह उन विषयों में से एक है (जैसे कि सनक) जिसे मैं कुछ हद तक समझता हूं, और मैंने फैसला किया कि मेरे ज्ञान को सत्यापित करने का सबसे अच्छा तरीका इसके बारे में लिखना होगा। यदि यह विषय को अन्य डेवलपर्स के लिए अधिक सुलभ बनाता है, तो सभी बेहतर।

इस पोस्ट में हास्केल शामिल नहीं है।

इस विषय पर लगभग सभी स्पष्टीकरण, जो मैंने देखा, उदाहरण "सही" कार्यात्मक भाषाओं में दिए गए थे, आमतौर पर हास्केल में। मेरे पास हास्केल के खिलाफ कुछ भी नहीं है, यह मेरे लिए आमतौर पर आसान है कि मैं उस भाषा में उदाहरणों को समझ सकूं जिसे मैं अच्छी तरह से जानता हूं। इसके अलावा, इस तरह की भाषा में उदाहरण लिखना मेरे लिए बहुत आसान है, इसलिए इस पोस्ट के सभी उदाहरण C # में होंगे। दरअसल, सभी उदाहरण एक फ़ाइल में उपलब्ध हैं, हालांकि, इसमें कई चर नाम दिए गए हैं। बस संकलित करें और चलाएं।

सी # वास्तव में एक कार्यात्मक भाषा नहीं है - मुझे यह समझने के लिए पर्याप्त है कि प्रतिनिधि उच्च-क्रम के कार्यों के लिए पूर्ण प्रतिस्थापन नहीं हैं। हालांकि, वे वर्णित सिद्धांतों को प्रदर्शित करने के लिए पर्याप्त हैं।

हालाँकि करीने और आंशिक अनुप्रयोग को एक फ़ंक्शन (विधि) का उपयोग करके कम संख्या में तर्कों के साथ प्रदर्शित किया जा सकता है, मैंने स्पष्टता के लिए तीन तर्कों का उपयोग करने का निर्णय लिया। यद्यपि करीने और आंशिक आवेदन करने के लिए मेरे तरीकों को सामान्यीकृत किया जाएगा (इसलिए सभी प्रकार के पैरामीटर और वापसी मूल्य मनमाना हैं), मैं प्रदर्शन उद्देश्यों के लिए एक साधारण फ़ंक्शन का उपयोग करता हूं:

static string SampleFunction(int a, int b, int c) { return string.Format("a={0}; b={1}; c={2}", a, b, c); } 

अब तक, सब कुछ सरल है। इस पद्धति में कुछ भी चालाक नहीं है, इसमें कुछ भी आश्चर्य की बात नहीं है।

यह सब क्या है?

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

 Func<int, int, int, string> function = SampleFunction; 

यह रेखा दो कारणों से उपयोगी है:

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

अब हम प्रतिनिधि को तीन तर्कों के साथ बुला सकते हैं:

 string result = function(1, 2, 3); 

या एक ही बात:

 string result = function.Invoke(1, 2, 3); 

(C # संकलक पहले लघु रूप को दूसरे में रूपांतरित करता है। उत्पन्न IL समान होगा।)

ठीक है, अगर एक समय में सभी तीन तर्क हमारे पास उपलब्ध हैं, लेकिन क्या नहीं तो? एक विशिष्ट (कुछ हद तक वंचित) उदाहरण के लिए, मान लें कि हमारे पास तीन मापदंडों (स्रोत, गंभीरता, संदेश) के साथ एक लॉगिंग फ़ंक्शन है और एक ही वर्ग के भीतर (जिसे मैं BusinessLogic कहूंगा), हम हमेशा पैरामीटर के लिए समान मान का उपयोग करना चाहते हैं "स्रोत"। हम कक्षा में कहीं से भी आसानी से प्रवेश करने में सक्षम होना चाहते हैं, केवल गंभीरता और संदेश का संकेत देते हैं। हमारे पास कई विकल्प हैं:

• एक एडेप्टर वर्ग बनाएं जो एक लॉगिंग फ़ंक्शन (या यहां तक ​​कि एक लकड़हारा ऑब्जेक्ट) और इसके निर्माता में स्रोत पैरामीटर के मूल्य को स्वीकार करता है, उन्हें अपने क्षेत्रों में बचाता है और दो मापदंडों के साथ एक विधि को उजागर करता है। यह विधि केवल सहेजे गए लकड़हारे को कॉल बताती है, लकड़हारा फ़ंक्शन के पहले पैरामीटर के रूप में सहेजे गए "स्रोत" को पारित करता है। BusinessLogic वर्ग में, हम एडेप्टर का एक उदाहरण बनाते हैं और लिंक को इस क्षेत्र में सहेजते हैं, और फिर दो मापदंडों के साथ विधि को कॉल करते हैं, जहां हम चाहते हैं। शायद यह एक ओवरकिल है, अगर हमें केवल BusinessLogic से एक एडाप्टर की आवश्यकता है, लेकिन इसका पुन: उपयोग किया जा सकता है ... जब तक हम उसी लॉगिंग फ़ंक्शन को अनुकूलित करते हैं।
• हमारे BusinessLogic वर्ग में स्रोत लकड़हारा ऑब्जेक्ट को स्टोर करें, लेकिन दो मापदंडों के साथ एक सहायक विधि बनाएं, जिसके अंदर "स्रोत" पैरामीटर के लिए मूल्य हार्डकोड किया जाएगा। अगर हमें कई जगहों पर ऐसा करने की ज़रूरत है, तो यह गुस्सा करने लगता है।
• अधिक कार्यात्मक दृष्टिकोण का उपयोग करें - इस मामले में, फ़ंक्शन का आंशिक उपयोग ।

मैं जानबूझकर किसी लकड़हारे ऑब्जेक्ट के लिंक को जोड़ने और लॉगिंग फ़ंक्शन के लिंक को संग्रहीत करने के बीच के अंतर को अनदेखा करता हूं। स्पष्ट रूप से, अगर हम लकड़हारे वर्ग के एक से अधिक कार्यों का उपयोग करने की आवश्यकता है, लेकिन एक महत्वपूर्ण अंतर है, लेकिन करी और आंशिक अनुप्रयोग के बारे में सोचने के लिए, हम "लकड़हारे" को "फ़ंक्शन" के रूप में सोचेंगे जो तीन पैरामीटर लेता है "(उदाहरण में हमारे फ़ंक्शन के रूप में) )।

अब जब मैंने प्रेरणा के लिए एक छद्म वास्तविक ठोस मामला दिया है, तो हम इसे लेख के अंत तक भूल जाएंगे और हम केवल एक उदाहरण समारोह पर विचार करेंगे। मैं एक पूरी BusinessLogic क्लास नहीं लिखना चाहता जो कुछ उपयोगी होने का नाटक करे; मुझे यकीन है कि आप एक "उदाहरण फ़ंक्शन" से "कुछ ऐसा करने के लिए जो आप वास्तव में करना चाहते हैं, एक मानसिक परिवर्तन कर सकते हैं।"

आंशिक समारोह का उपयोग करें

एक आंशिक अनुप्रयोग एन मापदंडों के साथ एक फ़ंक्शन लेता है और इन मापदंडों में से एक के लिए एक मान लेता है और एन -1 मापदंडों के साथ एक फ़ंक्शन देता है, जैसे कि, जब बुलाया जाता है, तो यह सभी आवश्यक मान एकत्र करेगा (पहला तर्क आंशिक आवेदन फ़ंक्शन के लिए पारित किया गया, और बाकी एन -1 दलीलें रिटर्न फंक्शन में)। इस प्रकार, ये दो कॉल तीन मापदंडों के साथ हमारी पद्धति के बराबर होनी चाहिए:

 //   string result1 = function(1, 2, 3); //     Func<int, int, string> partialFunction = ApplyPartial(function, 1); string result2 = partialFunction(2, 3); 

इस मामले में, मैंने एक एकल पैरामीटर के साथ एक आंशिक आवेदन को लागू किया, पहली पंक्ति में - आप ApplyPartial लिख सकते हैं , जो बड़ी संख्या में तर्क ले जाएगा या फ़ंक्शन के अंतिम निष्पादन में उन्हें अन्य पदों पर स्थानापन्न कर देगा। स्पष्ट रूप से, एक समय में एक पैरामीटर को इकट्ठा करना, शुरुआत से शुरू करना, सबसे आम दृष्टिकोण है।

अनाम कार्यों के लिए धन्यवाद (इस मामले में, लंबोदर अभिव्यक्ति, लेकिन अनाम विधि अधिक क्रिया नहीं होगी), ApplyPartial का कार्यान्वयन सरल है:

 static Func<T2, T3, TResult> ApplyPartial<T1, T2, T3, TResult> (Func<T1, T2, T3, TResult> function, T1 arg1) { return (b, c) => function(arg1, b, c); } 

सामान्यीकरण इस विधि को वास्तव में होने की तुलना में अधिक जटिल लगते हैं। ध्यान दें कि C # में उच्च आदेश प्रकारों की अनुपस्थिति का मतलब है कि आपको प्रत्येक प्रतिनिधि के लिए इस पद्धति को लागू करने की आवश्यकता है जिसे आप उपयोग करना चाहते हैं - यदि आपको चार मापदंडों वाले फ़ंक्शन के लिए संस्करण की आवश्यकता है, तो आपको ApplyPartial <T1, T2 विधि की आवश्यकता है , T3, T4, TResult> आदि। आपको शायद एक्शन प्रतिनिधि परिवार के लिए तरीकों का एक सेट भी चाहिए।

ध्यान देने वाली अंतिम बात यह है कि इन सभी तरीकों से, हम आंशिक आवेदन फिर से कर सकते हैं, यहां तक ​​कि संभावित रूप से पैरामीटर के बिना परिणामी फ़ंक्शन तक, यदि हम चाहते हैं:

 Func<int, int, string> partial1 = ApplyPartial(function, 1); Func<int, string> partial2 = ApplyPartial(partial1, 2); Func<string> partial3 = ApplyPartial(partial2, 3); string result = partial3(); 

फिर, केवल अंतिम पंक्ति मूल फ़ंक्शन को कॉल करेगी।

ठीक है, यह फ़ंक्शन का एक आंशिक अनुप्रयोग है। यह अपेक्षाकृत सरल है। मेरी राय में करीना को समझना थोड़ा कठिन है।

currying

जबकि एक आंशिक अनुप्रयोग एक तर्क के साथ एन -1 मापदंडों के साथ एक फ़ंक्शन में एन मापदंडों के साथ एक फ़ंक्शन में परिवर्तित करता है, करीकरण फ़ंक्शन को एक तर्क के कार्यों में विघटित करता है। परिवर्तित कार्य को छोड़कर, हम करी विधि में कोई अतिरिक्त तर्क नहीं देते हैं:

• करी (f) एक फ़ंक्शन f1 देता है जैसे कि ...
• f1 (a) एक फ़ंक्शन f2 देता है जैसे कि ...
• f2 (b) एक फंक्शन f3 देता है जैसे कि ...
• f3 (c) के कारण f (a, b, c)

(फिर से, ध्यान दें कि यह केवल तीन मापदंडों के साथ हमारे फ़ंक्शन पर लागू होता है - मुझे उम्मीद है, जाहिर है, यह अन्य हस्ताक्षरों के साथ कैसे काम करेगा।)

हमारे "समकक्ष" उदाहरण के लिए, हम लिख सकते हैं:

 //   string result1 = function(1, 2, 3); //    Func<int, Func<int, Func<int, string>>> f1 = Curry(function); Func<int, Func<int, string>> f2 = f1(1); Func<int, string> f3 = f2(2); string result2 = f3(3); //     ... var curried = Curry(function); string result3 = curried(1)(2)(3); 

अंतिम उदाहरणों के बीच का अंतर इस कारण को दर्शाता है कि कार्यात्मक भाषाओं में अक्सर प्रकार के प्रकार के औचित्य और कॉम्पैक्ट प्रकार का प्रतिनिधित्व होता है: घोषणा एफ 1 बहुत डरावना है।

अब जब हम जानते हैं कि करी पद्धति को क्या करना चाहिए, तो इसका कार्यान्वयन आश्चर्यजनक रूप से सरल है। वास्तव में, हमें बस इतना करने की आवश्यकता है कि उपरोक्त बिंदुओं को लैम्ब्डा एक्सप्रेशन में बदल दिया जाए। सौंदर्य:

 static Func<T1, Func<T2, Func<T3, TResult>>> Curry<T1, T2, T3, TResult> (Func<T1, T2, T3, TResult> function) { return a => b => c => function(a, b, c); } 

कोष्ठक जोड़ने के लिए स्वतंत्र महसूस करें यदि आप अपने लिए कोड को अधिक समझदार बनाना चाहते हैं, तो मुझे व्यक्तिगत रूप से लगता है कि वे केवल अव्यवस्था जोड़ देंगे। किसी भी मामले में, हमें वही मिला जो हम चाहते थे। (यह विचारणीय है कि लंबोदर भाव या अनाम तरीकों के बिना लिखना कितना थकाने वाला होगा। कठिन नहीं, बस थका देने वाला।)

यह करी है। मुझे ऐसा लगता है। हो सकता है कि।

निष्कर्ष

मैं यह नहीं कह सकता कि मैंने कभी करी का उपयोग किया है, जबकि नोडा टाइम के लिए पाठ पार्सिंग के कुछ हिस्से वास्तव में आंशिक अनुप्रयोग का उपयोग करते हैं। (अगर कोई वास्तव में मुझे यह जांचना चाहता है, तो मैं इसे करूंगा।)

मुझे वास्तव में उम्मीद है कि मैंने आपको इन दोनों से संबंधित के बीच अंतर दिखाया है, लेकिन फिर भी बहुत अलग अवधारणाएं हैं। अब जब हम समाप्त हो गए हैं, तो सोचें कि दो मापदंडों के साथ एक फ़ंक्शन के लिए उनके बीच का अंतर कैसे दिखाई देगा, और मुझे आशा है कि आप समझेंगे कि मैंने तीन का उपयोग करने का फैसला क्यों किया :)

मेरी छठी इंद्रिय मुझे बताती है कि शैक्षिक संदर्भ में करी एक उपयोगी अवधारणा है, जबकि आंशिक अनुप्रयोग व्यवहार में अधिक उपयोगी है। हालांकि, यह एक ऐसे व्यक्ति की छठी इंद्रिय है, जिसने पूर्ण भाषा में कार्यात्मक भाषाओं का उपयोग नहीं किया। अगर मैं कभी F # का उपयोग करना शुरू कर दूं, तो शायद मैं एक पूरक पोस्ट लिखूंगा। अब, मुझे आशा है कि मेरे अनुभवी पाठक टिप्पणियों में उपयोगी विचार प्रदान कर सकते हैं।