C ++ वैरिएडिक टेम्प्लेट। करी और आंशिक उपयोग

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

 def sum3(x: int, y: int, z: int): int //   { x + y + z; }; def sum3y = sum3(_, 5, _); //     def sum3yz = sum3y(_, 5); //    def sum3yzx = sum3yz(5); // … ,  15 

Haskell:

 sum3 xyz = x + y + z --   sum3x = sum3 5 --     sum3xy = sum3x 5 --   sum3xyz = sum3xy 5 -- … ,  15 

व्यक्तिगत रूप से, मुझे लगता है कि आपको दोनों संस्थाओं को लागू करने की आवश्यकता है। इसके अलावा, पर्याप्त समय पहले ही उस समय से गुजर चुका है जब अवसर आगामी सी ++ मानक, अर्थात् वैराडिक टेम्पलेट्स से दिखाई दिए। जैसा कि आप समझते हैं, लेख वैरिएडिक टेम्पलेट्स का उपयोग करके C ++ के लिए करी और आंशिक अनुप्रयोग के कार्यान्वयन का सुझाव देता है। काम के दौरान, MinGW gcc 4.6.1 और कोड :: ब्लॉक 10.05 का उपयोग किया गया था।

currying

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

 std::function< int(int, int, int) > f = [] ( int x, int y, int z ) { return x + y + z; }; auto f1 = carry(f); auto f2 = f1(5, 5); auto v15 = f2(5); 

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

 template< class, class, class > class CarryHolder; template< class OUT_TYPE, class... IN_TYPES, uint32_t... CAP_INDEXES, uint32_t... RES_INDEXES > class CarryHolder< std::function< OUT_TYPE ( IN_TYPES... ) >, UintContainer< CAP_INDEXES... >, //    UintContainer< RES_INDEXES... > > //    { public: typedef std::function< OUT_TYPE ( IN_TYPES... ) > FuncType; //    typedef std::tuple< typename UnQualify< //  const  & typename GetNthType< CAP_INDEXES, TypeContainer<IN_TYPES...> >::Result >::Result... > CleanCapTupleType; //      typedef std::function< OUT_TYPE ( typename GetNthType< RES_INDEXES, TypeContainer<IN_TYPES...> >::Result... ) > ReturnFuncType; //    public: CarryHolder( FuncType const& f, typename UnQualify< typename GetNthType< CAP_INDEXES, TypeContainer<IN_TYPES...> >::Result >::Result const&... capturedValues ): _function(f), _capturedData( capturedValues... ) { }; CarryHolder( CarryHolder const& other ): _function(other._function), _capturedData( other._capturedData ) { }; //    inline OUT_TYPE operator()( typename GetNthType< RES_INDEXES, TypeContainer<IN_TYPES...> >::Result... other_values ) { //        return _function( std::get< CAP_INDEXES > (_capturedData)..., other_values ... ); }; private: CarryHolder(); FuncType _function; CleanCapTupleType _capturedData; }; template< class > class Carry; template< class OUT_TYPE, class... IN_TYPES > class Carry< std::function< OUT_TYPE (IN_TYPES...) > > { public: typedef typename std::function< OUT_TYPE (IN_TYPES...) > FuncType; constexpr static uint32_t ArgsCount = GetTypesLength< TypeContainer<IN_TYPES...> >::Result; Carry( Carry const& carry ): _function( carry._function ) { }; Carry( FuncType const& f ): _function( f ) { }; template< class... INNER_IN_TYPES > inline auto operator()( INNER_IN_TYPES const& ... values ) -> typename CarryHolder< FuncType, //      typename UintRange< GetTypesLength< TypeContainer<INNER_IN_TYPES...> >::Result >::Result, //      typename UintRangeFromTo< GetTypesLength< TypeContainer<INNER_IN_TYPES...> >::Result, ArgsCount >::Result >::ReturnFuncType //  CarryHolder   std::function { typedef CarryHolder< FuncType, typename UintRange< GetTypesLength< TypeContainer<INNER_IN_TYPES...> >::Result >::Result, typename UintRangeFromTo< GetTypesLength< TypeContainer<INNER_IN_TYPES...> >::Result, ArgsCount >::Result > CarryHolderSpec; return CarryHolderSpec( _function, values... ); }; private: Carry(); FuncType _function; }; template< class FUNC_TYPE > Carry<FUNC_TYPE> carry( FUNC_TYPE const& f ) //    { return Carry<FUNC_TYPE>(f); }; 

तर्क की अदला-बदली

आंशिक आवेदन को लागू करने के लिए, आप आगे कर्लिंग के साथ स्थानों में तर्कों को पुन: व्यवस्थित करने में शामिल दृष्टिकोण का उपयोग कर सकते हैं। यह इस तरह दिखेगा:

 std::function< int(int, int, int) > f = [] ( int x, int y, int z ) { return x + y + z; }; auto f1 = permute<2, 1, 0>(f); 

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

 template< class, class > class Permutation; template< class OUT_TYPE, class... IN_TYPES, uint32_t... INDEXES > class Permutation< std::function< OUT_TYPE (IN_TYPES...) >, //    UintContainer< INDEXES... > > //   { public: typedef std::function< OUT_TYPE (IN_TYPES...) > FuncType; typedef std::function< OUT_TYPE (typename GetNthType< INDEXES, TypeContainer<IN_TYPES...> >::Result...) > NewFuncType; Permutation( Permutation const& perm ): _function( perm._function ) { }; Permutation( FuncType const& f ): _function( f ) { }; private: //        template< uint32_t... INVERSE > inline OUT_TYPE apply( UintContainer< INVERSE... >, //    , ..  typename GetNthType< INDEXES, TypeContainer<IN_TYPES...> >::Result... values ) { //    std::tuple    std::tuple< typename GetNthType< INDEXES, TypeContainer<IN_TYPES...> >::Result... > data( values... ); //    std::tuple    return _function( std::get< INVERSE > (data)... ); }; public: inline OUT_TYPE operator()( typename GetNthType< INDEXES, TypeContainer<IN_TYPES...> >::Result... values ) { //    typename InversePermutation< UintContainer<INDEXES...> >::Result inverse; return apply( inverse, values... ); }; private: Permutation(); FuncType _function; }; //   ;  Permutation  std::function template< uint32_t... INDEXES, class FUNC_TYPE > auto permute( FUNC_TYPE const& f ) -> typename Permutation<FUNC_TYPE, //  , ..      typename ComplementRange< GetArgumentsCount<FUNC_TYPE>::Result, UintContainer < INDEXES... > >::Result >::NewFuncType { typedef Permutation<FUNC_TYPE, typename ComplementRange< GetArgumentsCount<FUNC_TYPE>::Result, UintContainer < INDEXES... > >::Result > PermutationType; return PermutationType(f); }; 

अब एक आंशिक अनुप्रयोग, जिसमें वर्णित कार्यक्षमता है, तुच्छ हो जाता है - नीचे कोड है।

 template< uint32_t... INDEXES, class FUNC_TYPE > auto partApply( FUNC_TYPE const& f ) -> decltype(carry(permute<INDEXES...>(f))) { return carry(permute<INDEXES...>(f)); }; 

और सूचकांकों के पूरक की संभावना को देखते हुए, यह सभी सूचकांकों को इंगित करके उपयोग किया जा सकता है:

 std::function< int(int, int, int) > f = [] ( int x, int y, int z ) { return x + y + z; }; auto f1 = permute<2>(f); //  <2, 0, 1> -  "   " 

ये विकल्प हैं जो वैरिएडिक टेम्प्लेट खोलते हैं। बाद में, अगर यह दिलचस्प है, तो मैं कोड बाहर रखूंगा।
वास्तव में, करीकरण काफी क्लासिक नहीं निकला, क्योंकि यह एक-चरणीय और "अनिवार्य" है, अर्थात्, करीने से सभी तर्कों को कार्यान्वित करना (कार्यान्वित कार्यात्मक के अर्थ में) फ़ंक्शन, हमें अभी भी एक फ़ंक्शन मिलता है जो कई तर्क लेता है। इसके अलावा, गैर-शास्त्रीय सार क्वालिफायर के हेरफेर के दौरान ध्यान देने योग्य है। लेकिन ये सभी C ++ की विशेषताएं हैं।

अद्यतन:
पाया गया कि CarryHolderSpec कैरी में :: ऑपरेटर () को अनावश्यक रूप से std :: function में लिपटे रहने की आवश्यकता नहीं है, क्योंकि तर्कों को फिर से कॉपी किया जाता है। लेकिन मुझे लगता है कि अस्थायी वस्तुओं के लिंक इस के आसपास पाने में मदद करेंगे।

अद्यतन:
विषय को "असामान्य प्रोग्रामिंग" पर ले जाया गया, मुझे लगता है कि यह उसके लिए यहां अधिक आरामदायक होगा।