🙅🏽 🕺 ✴️ C ++ में आंशिक उपयोग और करी 🦏 👵🏿 👨‍💻

नमस्ते।

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

वास्तव में, एक फ़ंक्शन का आंशिक उपयोग फ़ंक्शन मापदंडों में से एक के लिए एक निश्चित मान को ठीक करने की क्षमता है, अर्थात एन मापदंडों के फ़ंक्शन से हमें एन -1 मापदंडों का एक फ़ंक्शन मिलता है। यदि हमारे पास एक बाइनरी फ़ंक्शन है जो दो संख्याओं को बताता है:

int sum(int a, int b) { return a + b; }

फिर हम किसी एक मानदंड के लिए एक निश्चित मान तय कर सकते हैं, उदाहरण के लिए, 42. इस प्रकार, हमें एक नया, पहले से ही काम करने वाला फ़ंक्शन मिलता है, इसके तर्क में संख्या 42 जोड़ते हैं।

कड़ाई से बोलना, कार्यों का आंशिक अनुप्रयोग पिछले C ++ मानक में था। दो std::binder1st और std::binder2nd वर्गों ने इस भूमिका को निभाया, साथ ही साथ प्रसिद्ध सहायक कार्य std::bind1st और std::bind2nd , जो उपरोक्त वर्गों की वस्तुओं के निर्माण को सरल बनाते हैं। सच है, एक समस्या है: ये बाइंडर्स साधारण फ़ंक्शन पॉइंटर्स के साथ काम नहीं कर सकते, क्योंकि उन्हें मापदंडों के प्रकार को जानने की आवश्यकता होती है। इसे और अन्य समस्याओं को हल करने के लिए, STL हर जगह फंक्शनलर्स का उपयोग करते हैं। ईमानदार होने के लिए, मैं उन्हें कार्यात्मक वस्तुएं कहना पसंद करूंगा, क्योंकि जब मैं हास्केल से मिला, तब से "फन्नेकार" शब्द पूरी तरह से अलग सार के साथ जुड़ा हुआ है। हालाँकि, C ++ प्रोग्रामर्स के सर्कल में, यह शब्द उन वस्तुओं के पदनाम के लिए सटीक रूप से तय किया गया है जो कार्यों की तरह व्यवहार कर सकते हैं; इसके अलावा, यह लिखने के लिए तेज है :)

तो यह समस्या कैसे हल की जाती है? अगर कोई नहीं जानता है, तो मैं संक्षेप में बताऊंगा। std::binder1st और std::binder2nd , जिस तरह से केवल बाइनरी फ़ंक्शन के साथ काम करते हैं, आपको जिस std::binder2nd आवश्यकता होती है: ये result_type, first_argument_type और second_argument_type हैं। हर बार अपने std::binary_function<T0,T1,R> में इन प्रकारों को मैन्युअल रूप से घोषित नहीं करने के लिए, आप बस std::binary_function<T0,T1,R> से प्राप्त कर सकते हैं, जहाँ T0 और T1 फ़ंक्शन के प्रकार हैं, और R क्रमशः रिटर्न मान का प्रकार है।

इस पूरी चीज़ का उपयोग करने का एक उदाहरण कुछ इस प्रकार है:

 template <typename T> struct Sum : public std::binary_function<T, T, T> { T operator()(T const & a, T const & b) { return a + b; } }; //   std::for_each(intArray.begin(), intArray.end(), std::bind1st(Sum<int>(), 42));

जो निर्माण लंबे समय से एसटीएल से परिचित हैं, वे अब इस तरह के निर्माणों से डरते नहीं हैं (और मैं, दुर्भाग्य से, उनमें से हैं), लेकिन मेरा विश्वास करो, इन सभी विशेष पात्रों और रैपरों को ढेर करने वाले नए लोग जो अन्य भाषाओं से सी ++ आए थे। या तो पठनीयता के बारे में याद नहीं करना बेहतर है, क्योंकि मैंने संयोजन को इससे भी बेहतर देखा :) विशेष रूप से बाद में बूस्ट लाइब्रेरी में एक अधिक शक्तिशाली प्रतिस्थापन दिखाई दिया - बूस्ट.बाइंड, जो, हालांकि, पठनीयता में कम भिन्न (विशिष्ट C ++) - इस तरह से । वैसे, यह ध्यान दिया जाना चाहिए कि बूस्ट। बाइंड पुराने बाइंडरों को बदलने के लिए नए सी ++ 11 मानक पर चले गए, जिनके बारे में मैंने थोड़ा ऊपर बात की थी। हालांकि, जब वहाँ है तो इसका इस्तेमाल कौन करेगा ... क्या? यह सही है, लंबोदर! खैर, उनके साथ, यह पूरी तरह से अलग बात है :) लेखन कम है, पठनीयता बेहतर है (बाइंडरों की तुलना में, निश्चित रूप से, और अन्य भाषाओं के साथ नहीं;))।

तो, हमारे पास Sum , जिसे हमने ऊपर परिभाषित किया है। मैं कहना भूल सकता हूँ, लेकिन एसटीएल में पहले से ही एक ऐसा ही फ़नकार है - std :: plus <>। लेकिन हम इसके बिना कर सकते हैं, क्योंकि हमने अपने समान लिखा था। सामान्य तौर पर, हमारे पास एक द्विआधारी फ़नकार है, और हमें आंशिक रूप से लागू होने वाली एकरी प्राप्त करने की आवश्यकता है। लंबोदर के साथ, ऐसा लग सकता है:

 using namespace std; //  for_each, begin  end // ... Sum<int> sum; for_each(begin(intArray)), end(intArray), [sum] (int const & n) { return sum(42, n); });

आप पूछ सकते हैं कि हम यहां sum(42, n) क्यों कहते sum(42, n) , जब हम लैंबडा के शरीर में सीधे return 42 + n; लिख सकते हैं । अवलोकन, निश्चित रूप से, सच है, लेकिन फ़ंक्शन का आंशिक उपयोग करने में हमारी रुचि क्या है, अगर आप अभी तक नहीं भूले हैं। इसके अलावा, फ़ंक्शन केवल दो संख्याओं को जोड़ने की तुलना में बहुत अधिक जटिल हो सकता है।

और हम इसे हास्केल में कैसे लिखेंगे? शायद, ऐसा कुछ निकलेगा:

 sum ab = a + b someFunc intList = map (λ n → sum 42 n) intList

यदि आप हास्केल से परिचित नहीं हैं, तो निराशा न करें। यह कोड पिछले C ++ उदाहरण के समान है। अब मैं संक्षेप में समझाऊंगा: पहली पंक्ति में, हमने फ़ंक्शन sum घोषणा की, जिसमें a b और b लगता a , और उनका योग लौटाता है। अगला, हमने कुछ फ़ंक्शन की घोषणा की जो कुछ सूची को पैरामीटर के रूप में लेते हैं (शायद पूर्णांक की एक सूची, पैरामीटर के नाम से देखते हुए) और इसके साथ कुछ करते हैं। map फ़ंक्शन std::for_each का एक एनालॉग है, अर्थात यह किसी प्रकार का कार्य करता है और इसे सूची के प्रत्येक तत्व के लिए कहता है। एक फ़ंक्शन के रूप में, हम एक लंबो पास करते हैं जो sum फ़ंक्शन को कॉल करते हैं, स्पष्ट रूप से इसे पहले पैरामीटर के रूप में एक निश्चित मान पास करते हैं, और लंबा तर्क स्वाभाविक रूप से दूसरे पैरामीटर के रूप में कार्य करता है। यह सब वास्तव में महत्वपूर्ण नहीं है ... या यों कहें कि यह महत्वपूर्ण नहीं होता अगर समान हास्केल कोड को इस तरह नहीं लिखा जा सकता:

 sum ab = a + b someFunc intList = map (sum 42) intList

जैसा कि हम देखते हैं, इस बार लैम्ब्डा के बजाय, हमने एक बहुत छोटे निर्माण का उपयोग किया, अर्थात् एक पैरामीटर के साथ बाइनरी फ़ंक्शन sum को कॉल किया। यह कैसे काम करता है? हाँ, बहुत आसान है! :) कॉल (sum 42) हमारे लिए एक नया फ़ंक्शन लौटाएगा जो एक पैरामीटर लेता है और फिर इसे संख्या 42 के साथ sum । वास्तव में, यह एक ही आंशिक अनुप्रयोग है - हम केवल sum फ़ंक्शन कहते हैं: "यहां आपके पास पहला पैरामीटर है, इसे याद रखें! लेकिन हम अभी भी दूसरे पैरामीटर को नहीं जानते हैं, इसलिए आपको बाद में इससे निपटना होगा। ” यह सब इस तथ्य के कारण काम करता है कि हास्केल में सभी फ़ंक्शन करी हैं (वैसे, इस तरह के एक गणितज्ञ थे - हास्केल करी;))। इसलिए यह पता लगाने का समय है कि यह क्या है।

सबसे पहले, करी एक ऑपरेशन है। यानी हास्केल ब्रह्मांड में यह सिर्फ कुछ संपत्ति या जादुई प्राणी नहीं है, यह एक परिवर्तन है। दूसरे, यह एक फ़ंक्शन पर किया जाने वाला रूपांतरण है: यह एन मापदंडों का एक फ़ंक्शन लेता है और इसे एक पैरामीटर के समान फ़ंक्शन में परिवर्तित करता है, जो एन -1 मापदंडों के एक फ़ंक्शन को लौटाता है। मैं एक उदाहरण के साथ समझाऊंगा। ऐसा करने के लिए, चलो हमारे C ++ फ़ंक्शन sum लौटते हैं, लेकिन इसमें एक और पैरामीटर जोड़ते हैं (बस मामले में):

 template <typename T1, typename T2, typename T3, typename R> R sum(T1 a, T2 b, T3 c) { return a + b + c; }

चूँकि हम केवल मापदंडों और रिटर्न वैल्यू के प्रकारों में रुचि रखते हैं, हम इसके प्रकार इस प्रकार लिखेंगे:

 sum :: ((T1 × T2 × T3) → R)

इस रिकॉर्ड का अर्थ है कि फ़ंक्शन क्रमशः T1, T2 और T3 प्रकार के तीन तर्क लेता है, और प्रकार R का मान लौटाता है। वास्तव में, करी के बाद, ऊपर परिभाषा के अनुसार, हमें कुछ इस तरह प्राप्त करना चाहिए:

 sum :: (T1 → ((T2 × T3) → R))

यही है, यह एक फ़ंक्शन है जो टाइप T1 के एक पैरामीटर को लेता है, और एक अन्य फ़ंक्शन देता है, जो बदले में क्रमशः T2 और T3 के दो तर्क लेता है, और रिटर्न (पहले की तरह) टाइप R का एक मान लेता है। वास्तव में, हम फ़ंक्शन का पहला पैरामीटर "बंद" करते हैं। और कहते हैं, वे कहते हैं, "हम उसे याद करते हैं, चिंता मत करो।" और फिर हम एक समान फ़ंक्शन लौटाते हैं जो एक पैरामीटर को कम लेता है। क्या कुछ भी समान नहीं है? लेकिन इसके आधार पर, आंशिक आवेदन को महसूस किया जा सकता है!

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

 sum :: (T1 → (T2 → (T3 → R)))

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

मुझे उम्मीद है कि अब तक सब कुछ कमोबेश स्पष्ट रहा है। लेकिन, मुझे लगता है, आप में से कई पहले से ही एक विस्मयादिबोधक के साथ मॉनिटर पर एक उंगली दबा रहे हैं: "ठीक है, अंत में मुझे ब्लाज कोड दिखाओ!" उचित रूप से, मैं आपत्ति नहीं कर सकता। इसलिए, सिद्धांत समाप्त होने के साथ, हम अभ्यास करने के लिए मुड़ते हैं। यह 2012 है, इसलिए हम नए C ++ 11 मानक का उपयोग करेंगे, हालांकि हम खुद को केवल उसी तक सीमित रखने का प्रयास करेंगे जो Microsoft Visual Studio 2010 समर्थन करता है - नए मानक का समर्थन करने के मामले में, यह संभवतः सबसे अधिक जारी करने वाला रिलीज़ कंपाइलर है।

चलो एक साधारण से शुरू करते हैं। एक बाइनरी फ़ंक्शन है। करीने के परिणामस्वरूप, हमें एक संयुक्त फ़ंक्शन प्राप्त करना चाहिए जो हमें एक और unary फ़ंक्शन देता है। C ++ 11 का उपयोग करना, यह धमाकेदार शलजम से आसान है:

 #include <cstddef> #include <iostream> using namespace std; template <typename R, typename T0, typename T1> function<function<R(T1)>(T0)> curry_(function<R(T0,T1)> f) { return [=] (T0 const & t0) -> function<R(T1)> { return [=] (T1 const & t1) { return f(t0, t1); }; }; } int sum(int a, int b) { return a + b; } int main() { auto curried_sum = curry_<int,int,int>(sum); cout << sum(42, 10) << endl; // => 52 cout << curried_sum(42)(10) << endl; // => 52 return EXIT_SUCCESS; }

सामान्य तौर पर, ऐसी चीजें होती हैं: हमारा curry_ फ़ंक्शन तीन टेम्पलेट पैरामीटर (फ़ंक्शन तर्क और वापसी प्रकार के प्रकार) पर निर्भर करता है। यह एक तर्क के रूप में लेता है एक प्रकार की वस्तु std::function<> । अगर किसी को पता नहीं है, तो यह एक ऐसा सार्वभौमिक कंटेनर है जो फंक्शनलर्स, लैम्ब्डा और यहां तक कि पॉइंटर्स को फ़ंक्शंस (Yay! अधिक बंट :)) को स्टोर कर सकता है। हमारे लिए यह महत्वपूर्ण है कि वास्तव में यह एक कार्यात्मक वस्तु है, अर्थात इसमें operator() ओवरलोड है। अगला, हम बस यूरी लैम्ब्डा (मूल रूप से एक अनाम फ़नकार) लौटाते हैं, जो एक और गैरी लैम्ब्डा को लौटाता है। यह रूसी से सी ++ में करी शब्द की परिभाषा के एक अनुवाद में लगभग एक है।

अब एक महत्वपूर्ण क्षण आ गया है। इस स्थान पर पढ़ने वाले सभी को अपने भीतर की आवाज़ से पूछना चाहिए कि उन्हें कौन सा विकल्प पसंद है:

 std::bind1st(std::function<int(int,int)>(sum), 42)(10); //  curry_<int,int,int>(sum)(42)(10);

यदि पहले, आप अब नहीं पढ़ सकते हैं, तो मेरा विश्वास करो। अगर दूसरा, तो मुझे आपको स्वीकार करना होगा ... मैं खुद दूसरे विकल्प की तरह नहीं हूं, हालांकि मेरी राय में यह पहले से बहुत बेहतर है।

एक तरह से या किसी अन्य, मैं तर्क और वापसी मूल्य के प्रकारों को स्पष्ट रूप से निर्दिष्ट करने की आवश्यकता से थोड़ा परेशान हूं। कंपाइलर अपने आप ही सभी प्रकार के आउटपुट नहीं दे सकता है, इसलिए इसे संकेत देना होगा। इसके अलावा, अगर हम curry_ फंक्शन के लिए curry_ फ़ंक्शन को ओवरलोड करना चाहते हैं, तो हम असफल हो जाएंगे क्योंकि कंपाइलर std::function<> इंस्टेंस के बीच अंतर नहीं कर सकता है। जैसा कि मैं इसे समझता हूं, इसका कारण यह है कि std::function<> एक टेम्पलेट कंस्ट्रक्टर है जो किसी भी प्रकार को स्वीकार करता है, लेकिन हम अब इसमें नहीं जाएंगे, क्योंकि मुझे पूरी तरह से यकीन नहीं है कि मैंने समस्या को सही ढंग से समझा है। हालांकि, तथ्य यह है। और आपको इसके बारे में कुछ करने की जरूरत है।

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

 template <typename Func> struct function_traits {}; //      template <typename R, typename T0, typename T1> struct function_traits<R(*)(T0,T1)> { typedef R result_type; typedef T0 first_argument_type; typedef T1 second_argument_type; }; //   curry_ template <typename Functor> function< function< typename function_traits<Functor>::result_type(typename function_traits<Functor>::second_argument_type) >(typename function_traits<Functor>::first_argument_type) > curry(Functor f) { return curry_ < typename function_traits<Functor>::result_type , typename function_traits<Functor>::first_argument_type , typename function_traits<Functor>::second_argument_type > (f); }

ठीक है, बहुत पठनीय कोड की सिर्फ दो दर्जन लाइनें, और हम पहले से ही इस तरह लिख सकते हैं:

 cout << curry(sum)(42)(10) << endl;

मेरी राय में, यह एक सफलता है! :) यह टर्नरी कार्यों के लिए curry_ को लागू करने के लिए बना हुआ है, और यहां तक कि हमें इन उद्देश्यों के लिए एक और फ़ंक्शन नाम प्राप्त करने की आवश्यकता नहीं है - कार्यों को ओवरलोड करके सब कुछ हल करने दें। अब तक, मेरी वृत्ति मुझसे कहती है कि यह समस्याग्रस्त होगा। कम से कम curry आवरण फ़ंक्शन देखें: यह केवल एक पैरामीटर (फ़ंक्शन को सीधे कर्ल किया जाता है) लेता है, लेकिन इसे हमेशा फ़ंक्शन की समता के आधार पर विभिन्न प्रकारों की वस्तुओं को वापस करना चाहिए (यानी यह एक फ़ंक्शन लौटाएगा जो एक फ़ंक्शन या एक फ़ंक्शन लौटाता है फ़ंक्शन जो एक फ़ंक्शन देता है, या ... mmm, यह पर्याप्त है)।

इस समस्या को हल करने के लिए, आपको सोचने और प्रेरणा पाने के लिए ~~थोड़ा मेटाप्रोग्रामिंग~~ मोड़ देना होगा। इसलिए, शुरुआत के लिए, हमें एकात्मक, बाइनरी, टर्नरी, ... n-ary फ़ंक्शंस के बीच अंतर करने की आवश्यकता है। मुझे लगता है कि इसके लिए आप function_traits एक स्थिर स्थिरांक जोड़ सकते हैं, जिसे टेम्पलेट की विशेषज्ञता के आधार पर एक अलग मूल्य के साथ आरंभ किया जाएगा। इसके बाद, हम अपने curry रैपर फ़ंक्शन में एक अतिरिक्त डमी तर्क जोड़ेंगे, जो केवल संकलन चरण में फ़ंक्शन ओवरलोड को हल करने में भाग लेंगे।

हम निम्नलिखित प्राप्त करते हैं:

 template <typename Func> struct function_traits {}; //      template <typename R, typename T0> struct function_traits<R(*)(T0)> { typedef R result_type; typedef T0 argument_type; static const int arity = 1; }; //      template <typename R, typename T0, typename T1> struct function_traits<R(*)(T0,T1)> { typedef R result_type; typedef T0 first_argument_type; typedef T1 second_argument_type; static const int arity = 2; }; //     template <typename R, typename T0, typename T1, typename T2> struct function_traits<R(*)(T0,T1,T2)> { typedef R result_type; typedef T0 first_argument_type; typedef T1 second_argument_type; typedef T2 third_argument_type; static const int arity = 3; }; //     template<typename Functor, int NArgs> struct count_args : std::enable_if<function_traits<Functor>::arity == NArgs> { static_assert(NArgs >= 0, "Negative number? WTF?"); }; //  //       ,     template <typename Functor> Functor curry(Functor f, typename count_args<Functor, 1>::type * = 0) { return f; } //   template <typename Functor> std::function< std::function< typename function_traits<Functor>::result_type(typename function_traits<Functor>::second_argument_type) >(typename function_traits<Functor>::first_argument_type) > curry(Functor f, typename count_args<Functor, 2>::type * = 0) { return curry_ < typename function_traits<Functor>::result_type , typename function_traits<Functor>::first_argument_type , typename function_traits<Functor>::second_argument_type > (f); } //   template <typename Functor> std::function< std::function< std::function< typename function_traits<Functor>::result_type(typename function_traits<Functor>::third_argument_type) >(typename function_traits<Functor>::second_argument_type) >(typename function_traits<Functor>::first_argument_type) > curry(Functor f, typename count_args<Functor, 3>::type * = 0) { return curry_ < typename function_traits<Functor>::result_type , typename function_traits<Functor>::first_argument_type , typename function_traits<Functor>::second_argument_type , typename function_traits<Functor>::third_argument_type > (f); }

सामान्य तौर पर, यहां सब कुछ बहुत स्पष्ट है। हमने दूसरे डमी पैरामीटर को जोड़कर फ़ंक्शन ओवरलोडिंग को लागू किया। यह पैरामीटर ओवरलोड रिज़ॉल्यूशन के दौरान अनुचित curry विकल्पों को "बंद" करने के लिए std::enable_if का उपयोग करता है। हमने यूनिरी फ़ंक्शंस के लिए एक करी कार्यान्वयन भी जोड़ा जो मूल फ़ंक्शन को वापस करता है। यह curry_ फ़ंक्शन के लिए curry_ फ़ंक्शन के लिए एक कार्यान्वयन लिखने के लिए बनी हुई है। सैद्धांतिक भाग में, मैंने उल्लेख किया है कि एक टर्नरी फ़ंक्शन की करी के दौरान, परिणाम एकात्मक होगा, जो सैद्धांतिक रूप से दो तर्कों के एक फ़ंक्शन को वापस कर सकता है, लेकिन वास्तव में इसके करी संस्करण को लौटाता है। इस ज्ञान के साथ, तीन तर्कों के लिए कार्यान्वयन अत्यंत सरल है:

 <typename R, typename T0, typename T1, typename T2> function<function<function<R(T2)>(T1)>(T0)> curry_(function<R(T0,T1,T2)> f) { return [=] (T0 const & t0) -> function<function<R(T2)>(T1)> { return curry_<R,T1,T2>([=] (T1 const & t1, T2 const & t2) { return f(t0,t1,t2); }); }; }

सामान्य तौर पर, मैंने mega नेमस्पेस में यह सब (उपयोग के उदाहरणों को छोड़कर) को लपेट दिया है और function_traits लिए फंक्शन_ट्रिट्स स्पेशलाइजेशन को एक हेडर फाइल में भर दिया है और इसे GitHub पर अपलोड कर दिया है । किसी भी तरह README को जोड़ना आवश्यक होगा :) अब हम टर्नरी फ़ंक्शन का उपयोग करके किसी भी बकवास को लिख सकते हैं। हां, यहां तक कि इस तरह:

 string foo(string s, int i, double d) { ostringstream str; str << s << ": " << i << " . = " << d << "$"; return str.str(); } int main() { cout << mega::curry(foo)("-")(2)(9.95) << endl; // => -: 2 . = 9.95$ return EXIT_SUCCESS; }

इस दृष्टिकोण का संपूर्ण आकर्षण यह है कि "व्यापक" लोगों से मक्खी पर नए, अधिक विशिष्ट कार्य किए जा सकते हैं। इसे कैसे और कहां से लागू किया जा सकता है, हर कोई खुद तय करेगा।

ईमानदारी से, मैंने यह नहीं जांचा कि क्या कुछ समान पहले से ही लागू किया गया था, इसलिए मैं यह नहीं छोड़ता कि मैंने एक और बाइक लिखी, क्योंकि यह मेरे लिए एक अकादमिक दृष्टिकोण से दिलचस्प था। इसके अलावा, इष्टतमता के दृष्टिकोण से, मैं भी बहुत विस्तार में नहीं गया था। मैं तुरंत कह सकता हूं कि C ++ कंपाइलर ऐसी चीजों का अनुकूलन नहीं करता है, इसलिए परिणामस्वरूप हमें रजिस्टरों के बीच अलग-अलग जानकारी खींचने के साथ call का एक पूरा गुच्छा मिलता है। लेकिन आपको सुविधा के लिए भुगतान करना होगा।

आपका ध्यान देने के लिए धन्यवाद।

आपके साथ बल हो सकता है।

पुनश्च मेरे पास अभी सुबह है, और ऑनलाइन मैं सबसे अधिक संभावना देर से दोपहर में दिखाई दूंगा। तो मेरे बिना ज्यादा मत करो :)

C ++ में आंशिक उपयोग और करी

More articles: