C ++ 14 में लैम्ब्डा की नई विशेषताएं

हर कोई जानता है कि आधुनिक प्रोग्रामिंग भाषाओं में कार्यात्मक प्रोग्रामिंग तेजी से फैल रही है। हाल के उदाहरण जावा 8 और सी ++ हैं, दोनों अब लंबो कार्यों का समर्थन करते हैं।



तो, चलिए शुरू करते हैं (और मजा हमारे साथ आ सकता है)। स्लाइड्सशेयर पर स्लाइड के रूप में यह पाठ भी उपलब्ध है। इस लेख के लेखक JSON निर्माता डगलस क्रॉकफोर्ड से प्रेरित थे।



एक पहचान समारोह जो एक तर्क लेता है और एक ही तर्क देता है:

auto Identity = [](auto x) { return x; }; Identity(3); // 3
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अनुवादक का नोट : C ++ 11 की तुलना में नया टाइप नामों को निर्दिष्ट नहीं करने की क्षमता है।



फ़ंक्शंस जोड़ते हैं, उप और मुल, जो दो तर्क लेते हैं और क्रमशः उनका योग, अंतर और उत्पाद वापस करते हैं:

 auto add = [](auto x, auto y) { return x + y; }; auto sub = [](auto x, auto y) { return x - y; }; auto mul = [](auto x, auto y) { return x * y; };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

 auto identityf = [](auto x) { class Inner { int x; public: Inner(int i): x(i) {} int operator() () { return x; } }; return Inner(x); }; identityf(5)(); // 5
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक और पहचान लागू करना जो एक वस्तु नहीं लौटाता है, लेकिन एक फ़ंक्शन (हाँ, अब आप फ़ंक्शन वापस कर सकते हैं):

 auto identityf = [](auto x) { return [=]() { return x; }; }; identityf(5)(); // 5
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

नोट: लंबोदर कार्य functions बंद:

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

एक फ़ंक्शन जो एक जनरेटर फ़ंक्शन देता है जो किसी दिए गए अंतराल से नंबर देता है:

 auto fromto = [](auto start, auto finish) { return [=]() mutable { if(start < finish) return start++; else throw std::runtime_error("Complete"); }; }; auto range = fromto(0, 10); range(); // 0 range(); // 1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक फ़ंक्शन जो एक बार में एक नंबर लेता है और उन्हें जोड़ता है:

 auto addf = [](auto x) { return [=](auto y) { return x+y; }; }; addf(5)(4); // 9
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक फ़ंक्शन जो दूसरे फ़ंक्शन के तर्कों को स्वैप करता है:

 auto swap =[](auto binary) { return [=](auto x, auto y) { return binary(y, x); }; }; swap(sub)(3, 2); // -1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक बाइनरी फ़ंक्शन लेता है और दो बार बाइनरी के लिए एक तर्क गुजरता है कि एक unary फ़ंक्शन देता है:

 auto twice =[](auto binary) { return [=](auto x) { return binary(x, x); }; }; twice(add)(11); // 22
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक फ़ंक्शन जो एक बाइनरी फ़ंक्शन लेता है और एक फ़ंक्शन देता है जो बदले में दो तर्क लेता है:

 auto applyf = [](auto binary) { return [=](auto x) { return [=](auto y) { return binary(x, y); }; }; }; applyf(mul)(3)(4); // 12
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक करी फ़ंक्शन जो एक बाइनरी फ़ंक्शन और एक तर्क लेता है और एक फ़ंक्शन देता है जो दूसरा तर्क लेता है:

 auto curry = [](auto binary, auto x) { return [=](auto y) { return binary(x, y); }; }; curry(mul, 3)(4); // 12
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

नोट: करी (schrying, schönfinkeling) एक फ़ंक्शन का परिवर्तन है जो कई तर्कों को एक तर्क लेने वाले कार्यों की श्रृंखला में ले जाता है।

• एक λ-विश्लेषण में, सभी फ़ंक्शन केवल एक तर्क लेते हैं।
• आपको यह समझने की जरूरत है कि हास्केल सीखने के लिए करी कैसे काम करती है।
• करी एक फ़ंक्शन का एक आंशिक अनुप्रयोग है।

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

 auto addFour = [](auto a, auto b, auto c, auto d) { return a+b+c+d; }; auto partial = [](auto func, auto a, auto b) { return [=](auto c, auto d) { return func(a, b, c, d); }; }; partial(addFour,1,2)(3,4); //10
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

तीन विकल्प, एक फ़ंक्शन कैसे प्राप्त करें जो एक नया फ़ंक्शन बनाए बिना तर्क में जोड़ता है:

 auto inc = curry(add, 1); auto inc = addf(1); auto inc = applyf(add)(1);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

कार्यों की संरचना का कार्यान्वयन:

 auto composeu =[](auto f1, auto f2) { return [=](auto x) { return f2(f1(x)); }; }; composeu(inc1, curry(mul, 5))(3) // (3 + 1) * 5 = 20
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक फ़ंक्शन जो एक बाइनरी फ़ंक्शन लेता है और इसे संशोधित करता है ताकि इसे केवल एक बार कहा जा सके:

 auto once = [](auto binary) { bool done = false; return [=](auto x, auto y) mutable { if(!done) { done = true; return binary(x, y); } else throw std::runtime_error("once!"); }; }; once(add)(3,4); // 7
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक फ़ंक्शन जो एक बाइनरी फ़ंक्शन लेता है और एक फ़ंक्शन देता है जो दो तर्क और कॉलबैक लेता है:

 auto binaryc = [](auto binary) { return [=](auto x, auto y, auto callbk) { return callbk(binary(x,y)); }; }; binaryc(mul)(5, 6, inc) // 31 binaryc(mul)(5, 6, [](int a) { return a+1; }); //   
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अंत में, हम निम्नलिखित तीन कार्य लिखते हैं:

• इकाई पहचान के रूप में ही है;
• stringify - अपने तर्क को एक स्ट्रिंग में बदल देता है और उस पर इकाई लागू करता है;
• bind - इकाई का परिणाम लेता है और एक फ़ंक्शन देता है जो कॉलबैक लेता है और इकाई के परिणाम पर इसे लागू करने का परिणाम देता है।

 auto unit = [](auto x) { return [=]() { return x; }; }; auto stringify = [](auto x) { std::stringstream ss; ss << x; return unit(ss.str()); }; auto bind = [](auto u) { return [=](auto callback) { return callback(u()); }; };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अब सुनिश्चित करें कि सब कुछ काम करता है:

 std::cout << "Left Identity " << stringify(15)() << "==" << bind(unit(15))(stringify)() << std::endl; std::cout << "Right Identity " << stringify(5)() << "==" << bind(stringify(5))(unit)() << std::endl;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इकाई और बाइंड कार्यों के बारे में क्या दिलचस्प है? तथ्य यह है कि यह एक सन्यासी है ।



लेखक की ब्लॉग श्रृंखला की दूसरी पोस्ट पढ़ें।