💂 🏄 🏂🏿 C ++ 14 में करी और आंशिक अनुप्रयोग 🤶🏼 🧖🏽 🚤

इस लेख में मैं आपको C ++ में एक करीने के विकल्पों और कार्यों के आंशिक अनुप्रयोग के बारे में बताने जा रहा हूं जो कि मेरा व्यक्तिगत पसंदीदा है। मैं इस चीज़ का अपना पायलट कार्यान्वयन भी दिखाने जा रहा हूं और जटिल गणितीय सूत्र के बिना करीने की बात समझाता हूं, जिससे यह वास्तव में आपके लिए सरल हो जाता है। हम यह भी देखेंगे कि kari.hpp लाइब्रेरी के हुड के नीचे क्या है जिसका उपयोग हम करी कार्यों के लिए करेंगे। वैसे भी, अंदर बहुत सारे आकर्षक सामान हैं, इसलिए आपका स्वागत है!

Currying

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

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

int sum2(int lhs, int rhs) { return lhs + rhs; }

यहां हमारे पास एक बाइनरी अतिरिक्त फ़ंक्शन है। और क्या होगा अगर हम इसे सिंगल वेरिएबल फंक्शन में बदलना चाहते हैं? यह वास्तव में बहुत सरल है:

 auto curried_sum2(int lhs) { return [=](int rhs) { return sum2(lhs, rhs); }; }

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

 // output: 42 std::cout << sum2(40, 2) << std::endl; std::cout << curried_sum2(40)(2) << std::endl;

और यह वास्तव में करी ऑपरेशन का पूरा बिंदु है। बेशक, यह किसी भी कार्य के कार्यों के साथ करना संभव है - यह बिल्कुल उसी तरह काम करने जा रहा है। हर बार जब हम किसी दूसरे तर्क से मूल्य लेते हैं, तो हम एन -1 तर्कों का एक करीबी कार्य लौटाएंगे:

 auto sum3(int v1, int v2, int v3) { return v1 + v2 + v3; } auto curried_sum3(int v1) { return [=](int v2){ return [=](int v3){ return sum3(v1, v2, v3); }; }; } // output: 42 std::cout << sum3(38, 3, 1) << std::endl; std::cout << curried_sum3(38)(3)(1) << std::endl;

आंशिक आवेदन

आंशिक आवेदन - एन तर्कों के कॉलिंग फ़ंक्शन का एक तरीका है जब वे केवल तर्कों का एक हिस्सा लेते हैं और शेष तर्कों का एक और फ़ंक्शन वापस करते हैं।

इस संबंध में यह ध्यान दिया जाना चाहिए कि हास्केल जैसी भाषाओं में प्रोग्रामर की पीठ के पीछे यह प्रक्रिया स्वचालित रूप से काम करती है। हम यहां क्या करने की कोशिश कर रहे हैं, यह स्पष्ट रूप से प्रदर्शन करना है, sum3 हमारे sum3 फ़ंक्शन को इस तरह से बुलाना है: sum3(38,3)(1) या शायद इस तरह: sum3(38)(3,1) । उसके शीर्ष पर, यदि कोई फ़ंक्शन एक और फ़ंक्शन देता है जिसे क्यूरेट किया गया है, तो इसे पहले फ़ंक्शन के तर्कों की सूची का उपयोग करके भी कहा जा सकता है। आइए उदाहरण देखें:

 int boo(int v1, int v2) { return v1 + v2; } auto foo(int v1, int v2) { return kari::curry(boo, v1 + v2); } // output: 42 std::cout << kari::curry(foo)(38,3,1) << std::endl; std::cout << kari::curry(foo)(38,3)(1) << std::endl; std::cout << kari::curry(foo)(38)(3,1) << std::endl;

हम वास्तव में यहाँ अपने आप से थोड़ा आगे निकल गए हैं, उदाहरण के लिए kari.hpp उपयोग, इसलिए हाँ, यह ऐसा करता है।

लक्ष्य निर्धारित करना

इससे पहले कि हम कुछ लिखें, यह समझना आवश्यक है (या वांछनीय) कि हम आखिर में क्या चाहते हैं। और हम चाहते हैं कि किसी भी फ़ंक्शन को करी और आंशिक रूप से लागू करने का अवसर मिले जिसे C ++ में कहा जा सकता है। जो हैं:

लंबोदर (सामान्य वाले सहित)
फ़ंक्शन ऑब्जेक्ट (फ़ंक्शनलर्स)
किसी भी कार्य के कार्य (टेम्प्लेट सहित)
परिवर्तन संबंधी कार्य
एक कक्षा के तरीके

वरीडिक फ़ंक्शंस पर करीने की तर्कों को निर्दिष्ट करके हम पर अंकुश लगाया जा सकता है। Std :: bind और इसके परिणाम के साथ मानक सहभागिता भी वांछनीय है। और निश्चित रूप से, हमें कई-चर कार्यों को लागू करने और नेस्टेड फ़ंक्शन को कॉल करने के लिए एक अवसर की आवश्यकता है ताकि ऐसा लगे कि हम एक घुमावदार फ़ंक्शन के साथ काम कर रहे हैं।

और हमें प्रदर्शन के बारे में भी नहीं भूलना चाहिए। हमें रैपर की कम्प्यूटेशनल लागत, तर्कों के स्थानांतरण और उनके भंडारण को कम करना होगा। इसका मतलब है कि हमें नकल करने के बजाय आगे बढ़ना है, केवल उसी चीज़ को स्टोर करें जो हमें वास्तव में चाहिए, और जितना संभव हो उतना तेज़ी से डेटा को वापस करें (आगे निकालें)।

लेखक, आप `std::bind` का आविष्कार करने की कोशिश कर रहे हैं `std::bind` एक बार फिर से `std::bind` !

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

 int foo(int v1, int v2, int v3, int v4) { return v1 + v2 + v3 + v4; } // std::bind auto c0 = std::bind(foo, _1, _2, _3, _4); auto c1 = std::bind(c0, 15, _1, _2, _3); auto c2 = std::bind(c1, 20, 2, _1); auto rr = c2(5); std::cout << rr << std::endl; // output: 42 // kari.hpp auto c0 = kari::curry(foo); auto c1 = c0(15); auto c2 = c1(20, 2); auto rr = c2(5); std::cout << rr << std::endl; // output: 42

एपीआई

 namespace kari { template < typename F, typename... Args > constexpr decltype(auto) curry(F&& f, Args&&... args) const; template < typename F, typename... Args > constexpr decltype(auto) curryV(F&& f, Args&&... args) const; template < std::size_t N, typename F, typename... Args > constexpr decltype(auto) curryN(F&& f, Args&&... args) const; template < typename F > struct is_curried; template < typename F > constexpr bool is_curried_v = is_curried<F>::value; template < std::size_t N, typename F, typename... Args > struct curry_t { template < typename... As > constexpr decltype(auto) operator()(As&&... as) const; }; }

kari::curry(F&& f, Args&&... args)

वैकल्पिक फ़ंक्शन curry_t साथ या दिए गए फ़ंक्शन f के लिए तर्कों के आवेदन के परिणाम के साथ curry_t प्रकार (एक करी फ़ंक्शन) का फ़ंक्शन ऑब्जेक्ट लौटाता है (फ़ंक्शन फ़ंक्शन शून्य है, या स्थानांतरित किए गए तर्क इसे कॉल करने के लिए पर्याप्त थे)।

यदि f पैरामीटर में वह फ़ंक्शन होता है जो पहले से ही कर दिया गया है, तो वह अपनी कॉपी को दिए गए तर्कों के साथ लागू करता है।

kari::curryV(F&& f, Args&&... args)

चर संख्या के साथ कार्यों को करीने की अनुमति देता है। उसके बाद इन कार्यों का उपयोग किया जा सकता है () ऑपरेटर बिना किसी तर्क के। उदाहरण के लिए:

 auto c0 = kari::curryV(std::printf, "%d + %d = %d"); auto c1 = c0(37, 5); auto c2 = c1(42); c2(); // output: 37 + 5 = 42

यदि f पैरामीटर में एक फ़ंक्शन होता है जो पहले से ही क्यूरेट किया गया है, तो वह अपनी कॉपी को बदल दिया जाता है, जिस तरह के तर्कों के साथ परिवर्तन किए गए तर्कों के लिए कई प्रकार के आवेदन किए जाते हैं।

kari::curryN(F&& f, Args&&... args)

हम जिस तर्क को लागू करना चाहते हैं, उसकी सटीक संख्या N निर्दिष्ट करके तर्कों की चर संख्या के साथ करी क्रियाओं की अनुमति देता है ( args में दिए गए को छोड़कर)। उदाहरण के लिए:

 char buffer[256] = {'\0'}; auto c = kari::curryN<3>(std::snprintf, buffer, 256, "%d + %d = %d"); c(37, 5, 42); std::cout << buffer << std::endl; // output: 37 + 5 = 42

यदि f पैरामीटर में एक फ़ंक्शन होता है जो पहले से ही कर दिया गया है, तो यह एन कॉपी के लिए बदल दिए गए प्रकार के आवेदन के साथ अपनी कॉपी लौटाता है, जो कि तर्कों के साथ लागू होता है।

kari::is_curried<F>, kari::is_curried_v<F>

जाँच के लिए कुछ सहायक संरचनाएँ यदि किसी फ़ंक्शन को पहले से ही कर दिया गया है। उदाहरण के लिए:

 const auto l = [](int v1, int v2){ return v1 + v2; }; const auto c = curry(l); // output: is `l` curried? no std::cout << "is `l` curried? " << (is_curried<decltype(l)>::value ? "yes" : "no") << std::endl; // output: is `c` curried? yes std::cout << "is `c` curried? " << (is_curried_v<decltype(c)> ? "yes" : "no") << std::endl;

kari::curry_t::operator()(As&&... as)

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

 int foo(int v1, int v2, int v3, int v4) { return v1 + v2 + v3 + v4; } auto c0 = kari::curry(foo); auto c1 = c0(15, 20); // partial application auto rr = c1(2, 5); // function call - foo(15,20,2,5) std::cout << rr << std::endl; // output: 42

यदि आप curryV या curryN का उपयोग करते हुए curryV किसी तर्क के एक फ़ंक्शन को कॉल करते हैं, तो यह कहा जाएगा कि क्या पर्याप्त तर्क हैं। अन्यथा, यह आंशिक रूप से लागू फ़ंक्शन लौटाएगा। उदाहरण के लिए:

 auto c0 = kari::curryV(std::printf, "%d + %d = %d"); auto c1 = c0(37, 5); auto c2 = c1(42); // force call variadic function std::printf c2(); // output: 37 + 5 = 42

कार्यान्वयन का विवरण

जब आप कार्यान्वयन का विवरण देते हैं, तो मैं लेख का पाठ छोटा रखने और अनावश्यक स्पष्टीकरण और ढेर किए गए SFINAE से बचने के लिए C ++ 17 का उपयोग करने जा रहा हूं, साथ ही कार्यान्वयन के उदाहरणों को मुझे C ++ में जोड़ना होगा। 14 मानक। इन सभी को आप प्रोजेक्ट रिपॉजिटरी में पा सकते हैं, जहाँ आप इसे अपने पसंदीदा में भी जोड़ सकते हैं :)

make_curry(F&& f, std::tuple<Args...>&& args)

एक सहायक फ़ंक्शन जो फ़ंक्शन ऑब्जेक्ट curry_t बनाता है या दिए गए फ़ंक्शन f को तर्कों के लिए लागू करता है।

 template < std::size_t N, typename F, typename... Args > constexpr auto make_curry(F&& f, std::tuple<Args...>&& args) { if constexpr ( N == 0 && std::is_invocable_v<F, Args...> ) { return std::apply(std::forward<F>(f), std::move(args)); } else { return curry_t< N, std::decay_t<F>, Args... >(std::forward<F>(f), std::move(args)); } } template < std::size_t N, typename F > constexpr decltype(auto) make_curry(F&& f) { return make_curry<N>(std::forward<F>(f), std::make_tuple()); }

अब, इस समारोह के बारे में दो दिलचस्प बातें हैं:

हम इसे केवल तर्कों पर लागू करते हैं यदि यह इन तर्कों के लिए कॉल करने योग्य है और एप्लिकेशन काउंटर N शून्य पर है
यदि फ़ंक्शन कॉल करने योग्य नहीं है, तो हम इस कॉल को आंशिक अनुप्रयोग curry_t हैं और फ़ंक्शन और तर्क युक्त फ़ंक्शन ऑब्जेक्ट curry_t बनाते हैं

struct curry_t

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

 template < std::size_t N, typename F, typename... Args > struct curry_t { template < typename U > constexpr curry_t(U&& u, std::tuple<Args...>&& args) : f_(std::forward<U>(u)) , args_(std::move(args)) {} private: F f_; std::tuple<Args...> args_; };

ऐसे कई कारण हैं, args_ कारण हम std :: tuple में तर्क args_ के बैकलॉग को संग्रहीत करते हैं:

1) एसटीडी के साथ स्थितियाँ :: रेफरी को संचय करने के लिए स्वचालित रूप से संभाला जाता है, जब हमें मूल्य के आधार पर डिफ़ॉल्ट रूप से आवश्यकता होती है
2) अपने तर्कों के अनुसार किसी फ़ंक्शन का सुविधाजनक अनुप्रयोग ( std :: apply )
3) यह रेडीमेड है, इसलिए आपको इसे खरोंच से नहीं लिखना है :)

हमारे पास हमारे द्वारा कॉल की गई वस्तु और फ़ंक्शन f_ को उसके मूल्य से भी संग्रहीत किया जाता है, और एक बनाते समय प्रकार का चयन करते समय सावधान रहें (मैं नीचे इस मुद्दे पर विस्तार करने जा रहा हूं), या सार्वभौमिक संदर्भ का उपयोग करके इसे स्थानांतरित करना, या इसकी प्रतिलिपि बनाना। निर्माता।

एक टेम्प्लेट पैरामीटर N वैरेडिक फ़ंक्शंस के लिए एप्लिकेशन काउंटर के रूप में कार्य करता है।

curry_t::operator()(const As&...)

और, ज़ाहिर है, वह चीज जो इसे सभी काम करती है - ऑपरेटर जो फ़ंक्शन ऑब्जेक्ट को कॉल करता है।

 template < std::size_t N, typename F, typename... Args > struct curry_t { // 1 constexpr decltype(auto) operator()() && { return detail::make_curry<0>( std::move(f_), std::move(args_)); } // 2 template < typename A > constexpr decltype(auto) operator()(A&& a) && { return detail::make_curry<(N > 0 ? N - 1 : 0)>( std::move(f_), std::tuple_cat( std::move(args_), std::make_tuple(std::forward<A>(a)))); } // 3 template < typename A, typename... As > constexpr decltype(auto) operator()(A&& a, As&&... as) && { return std::move(*this)(std::forward<A>(a))(std::forward<As>(as)...); } // 4 template < typename... As > constexpr decltype(auto) operator()(As&&... as) const & { auto self_copy = *this; return std::move(self_copy)(std::forward<As>(as)...); } }

कॉलिंग ऑपरेटर के पास चार कार्य ओवरलोड हैं।

एक ऐसा फंक्शन जिसमें कोई पैरामीटर नहीं है जो वैरिएडिक फंक्शन ( curryV या curryN द्वारा बनाया गया) को लागू करने की अनुमति देता है। यहां हम एप्लिकेशन काउंटर को शून्य तक घटा देते हैं, जिससे यह स्पष्ट हो जाता है कि फ़ंक्शन लागू होने के लिए तैयार है, और फिर हम वह सब कुछ देते हैं जो उसके लिए आवश्यक है फ़ंक्शन बनाने के लिए।
एकल तर्क का एक फ़ंक्शन जो अनुप्रयोग काउंटर को 1 से args_ (यदि यह शून्य पर नहीं है) और हमारे नए तर्क को तर्क के बैकलॉग में डालता है args_ और यह सब args_ स्थानांतरित करता है।
एक चर समारोह जो वास्तव में विभिन्न तर्कों के आंशिक अनुप्रयोग के लिए एक चाल है। यह क्या करता है उन्हें एक, एक-एक करके लागू होता है। अब, दो कारण हैं कि वे सभी को एक बार में लागू क्यों नहीं किया जा सकता है:
- आवेदन काउंटर शून्य से नीचे उतर सकते हैं इससे पहले कि कोई तर्क नहीं बचा है
- फ़ंक्शन f_ को पहले कहा जा सकता है और एक और करी फ़ंक्शन को वापस कर सकता है, इसलिए इसके लिए सभी अगले तर्क दिए जाएंगे
अंतिम फ़ंक्शन curry_t का उपयोग करके कॉल करने और rvalue का उपयोग करके कॉलिंग फ़ंक्शन के बीच एक पुल के रूप में कार्य करता है।

रेफ-योग्य कार्यों के टैग पूरी प्रक्रिया को लगभग जादुई बनाते हैं। इसे कम करने के लिए, उनकी मदद से हमें पता चलता है कि किसी वस्तु को rvalue reference का उपयोग करके बुलाया गया था और हम अंतिम कॉलिंग फ़ंक्शन make_curry में कॉपी करने के बजाय तर्क को स्थानांतरित कर सकते हैं। अन्यथा हमें इस फ़ंक्शन को फिर से कॉल करने के लिए तर्कों को कॉपी करना होगा, यह सुनिश्चित करने के लिए कि तर्क अभी भी हैं।

बोनस

निष्कर्ष पर आगे बढ़ने से पहले, मैं आपको कारी चीनी के उदाहरणों के एक जोड़े को दिखाना चाहता हूं जो कि उनके पास kari.hpp में हैं जो बोनस के रूप में योग्य हो सकते हैं।

संचालक खंड

प्रोग्रामर जो पहले से ही हास्केल के साथ काम कर चुके हैं, उन्हें लागू किए गए ऑपरेटरों के संक्षिप्त विवरण देने की अनुमति देने वाले ऑपरेटर वर्गों से परिचित होना चाहिए। उदाहरण के लिए, संरचना (*2) , एकल-तर्क फ़ंक्शन उत्पन्न करता है, इस तर्क के गुणन का परिणाम 2 से लौटाता है। इसलिए, जो मैं चाहता था वह सी ++ में ऐसा कुछ लिखने की कोशिश करना था। जल्दी से नहीं कहा!

 using namespace kari::underscore; std::vector<int> v{1,2,3,4,5}; std::accumulate(v.begin(), v.end(), 0, _+_); // result: 15 std::transform(v.begin(), v.end(), v.begin(), _*2); // v = 2, 3, 6, 8, 10 std::transform(v.begin(), v.end(), v.begin(), -_); // v = -2,-3,-6,-8,-10

क्रिया रचना

और निश्चित रूप से अगर मैं एक समारोह रचना लिखने की कोशिश नहीं की है तो मैं पूरी तरह से निराला नहीं बनूंगा। रचना संचालक के रूप में मैंने मैथ्स में रचना संकेत के लिए उपलब्ध सभी प्रतीकों के निकटतम (के रूप में) operator * चुना। मैंने इसका उपयोग तर्क के लिए परिणामी फ़ंक्शन को लागू करने के लिए भी किया। तो, मुझे यही मिला:

 using namespace kari::underscore; // 1 std::cout << (_*2) * (_+2) * 4 << std::endl; // output: 12 // 2 std::cout << 4 * (_*2) * (_+2) << std::endl; // output: 10

कार्यों की संरचना (*2) और (+2) 4 लागू होती है। (4 + 2) * 2 = 12
फ़ंक्शन (*2) 4 लागू होता है और फिर हम परिणाम पर (+2) लागू होते हैं। (4 * 2 + 2) = 10

उसी तरह से आप पॉइंटफ्री शैली में काफी जटिल रचनाएँ बना सकते हैं , लेकिन केवल हास्केल प्रोग्रामर ही इन्हें समझ पाएँगे :)

 // (. (+2)) (*2) $ 10 == 24 // haskell analog std::cout << (_*(_+2))(_*2) * 10 << std::endl; // output: 24 // ((+2) .) (*2) $ 10 == 22 // haskell analog std::cout << ((_+2)*_)(_*2) * 10 << std::endl; // output: 22

निष्कर्ष

मुझे लगता है कि इससे पहले यह स्पष्ट था कि वास्तविक परियोजनाओं में इन तकनीकों का उपयोग करने की कोई आवश्यकता नहीं है। लेकिन फिर भी, मुझे इसका उल्लेख करना चाहिए। आखिरकार, मेरा लक्ष्य खुद को साबित करना और नए सी ++ मानक की जांच करना था। क्या मैं ऐसा कर पाऊंगा? और C ++ होगा? खैर, मुझे लगता है, आपने अभी देखा कि हम दोनों ने ऐसा किया है। और मैं वास्तव में उन सभी लोगों का आभारी हूं जिन्होंने पूरी बात पढ़ी।

C ++ 14 में करी और आंशिक अनुप्रयोग