प्रोग्रामिंग भाषाओं में फनकार

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

सी ++ में फ़नकार

C ++ में फ़ंक्टर "फ़ंक्शनल ऑब्जेक्ट्स " के लिए कम हैं । एक कार्यात्मक वस्तु C ++ वर्ग का एक उदाहरण है जिसमें operator() परिभाषित किया गया है। यदि आप सी ++ वर्ग के लिए operator() को परिभाषित करते हैं, तो आपको एक ऑब्जेक्ट मिलता है जो एक फ़ंक्शन के रूप में कार्य करता है, लेकिन राज्य को भी पकड़ सकता है। उदाहरण के लिए

 #include <iostream> #include <string> class SimpleFunctor { std::string name_; public: SimpleFunctor(const char *name) : name_(name) {} void operator()() { std::cout << "Oh, hello, " << name_ << endl; } }; int main() { SimpleFunctor sf("catonmat"); sf(); //  "Oh, hello, catonmat" } 

ध्यान दें कि हम main फ़ंक्शन में sf() कह सकते हैं, हालाँकि sf एक ऑब्जेक्ट है। ऐसा इसलिए है क्योंकि SimpleFunctor वर्ग में इसके लिए operator() परिभाषित किया गया है।

अक्सर, C ++ में फंक्शनल का उपयोग विधेय, छद्म क्लोजर, या एसटीएल एल्गोरिदम में तुलना कार्यों के रूप में किया जाता है। यहाँ एक और उदाहरण है। मान लीजिए कि आपके पास पूर्णांकों की एक सूची है और आप सभी अवधियों का योग और सभी विषमों का योग ज्ञात करना चाहते हैं। फंक्टर और for_each लिए आदर्श है।

 #include <algorithm> #include <iostream> #include <list> class EvenOddFunctor { int even_; int odd_; public: EvenOddFunctor() : even_(0), odd_(0) {} void operator()(int x) { if (x%2 == 0) even_ += x; else odd_ += x; } int even_sum() const { return even_; } int odd_sum() const { return odd_; } }; int main() { EvenOddFunctor evenodd; int my_list[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; evenodd = std::for_each(my_list, my_list+sizeof(my_list)/sizeof(my_list[0]), evenodd); std::cout << " : " << evenodd.even_sum() << "\n"; std::cout << " : " << evenodd.odd_sum() << std::endl; // : //  : 30 //  : 25 } 

यहाँ EvenOddFunctor उदाहरण for_each EvenOddFunctor दिया गया है। for_each my_list में प्रत्येक आइटम पर पुनरावृत्त करता है और एक फ़नकार कहता है। उसके बाद, यह evenodd की एक प्रति लौटाता है, जिसमें सम और विषम तत्वों का योग होता है।

Standart ML में फ़नकार

OOP के संदर्भ में तैयार करना मुश्किल है: ML में फंक्शंस इंटरफेस के सामान्य कार्यान्वयन हैं। एमएल के संदर्भ में, फंक्शंस एमएल मॉड्यूल सिस्टम का हिस्सा हैं और वे आपको संरचनाओं की रचना करने की अनुमति देते हैं।

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

हस्ताक्षर प्लगइन =
sig
वैल प्रदर्शन : इकाई -> इकाई
अंत ;

अब जब हमने प्लगइन्स के लिए इंटरफ़ेस (हस्ताक्षर) को परिभाषित किया है, तो हम दो प्लगइन्स को लागू कर सकते हैं, LoudPlugin और SilentPlugin कह सकते हैं। कार्यान्वयन संरचनाओं के माध्यम से है,

संरचना लाउडप्लगिन :> प्लगिन =
struct
मजेदार प्रदर्शन ( ) = प्रिंट "जॉब लोड! \ n"
अंत ;

और साइलेंटप्लगिन,

संरचना SilentPlugin :> प्लगइन =
struct
मजेदार प्रदर्शन ( ) = प्रिंट "चुपचाप कार्य निष्पादित करें \ n"
अंत ;

अब हम फंक्शनलर्स के करीब हैं। ML में फ़ंक्शंस तर्क के रूप में संरचनाएं लेते हैं, इसलिए हम लिख सकते हैं कि Plugin को एक तर्क के रूप में आवश्यक है,

functor Performer ( P : Plugin ) =
struct
मजेदार काम ( ) = पी। प्रदर्शन ( )
अंत ;

यह फ़नकार Plugin को P के तर्क के रूप में लेता है और इसे job फ़ंक्शन के लिए उपयोग करता है, जो P प्लगइन के perform फ़ंक्शन को कॉल करता है।
अब आइए Performer functor का उपयोग करके देखें। याद रखें कि एक फ़नकार एक संरचना लौटाता है,

संरचना LoudPerformer = कलाकार ( LoudPlugin ) ;
संरचना साइलेंटप्रफॉर्मर = कलाकार ( साइलेंटप्लगिन ) ;

LoudPerformer। नौकरी ( ) ;
SilentPerformer। नौकरी ( ) ;

इसकी कटौती की जाएगी

  हम समय से पहले ही परवाह करते हैं!
 चुपचाप कार्य करें 

यह मानक एमएल फंक्शनलर्स का सबसे सरल उदाहरण है।

हास्केल में फनकार

हास्केल फंक्शनलर्स वही होते हैं जो वास्तविक फंक्शनलर्स होने चाहिए। हास्केल फंक्शनलर्स श्रेणी सिद्धांत में गणितीय फंक्शंस की याद ताजा करते हैं। श्रेणी सिद्धांत में, फ़न्क्टर एफ श्रेणियों के बीच एक मानचित्रण है, जैसे कि श्रेणी की संरचना संरक्षित है या, दूसरे शब्दों में, यह दो श्रेणियों के बीच एक समरूपता है।

हास्केल में, इस परिभाषा को एक साधारण प्रकार के वर्ग के रूप में लागू किया जाता है,

क्लास फनकार च जहाँ
fmap :: ( a -> b ) -> f a -> f b

उदाहरण के लिए, एमएल को वापस देखना, हास्केल में एक प्रकार का वर्ग हस्ताक्षर के समान है, सिवाय इसके कि यह प्रकार के लिए परिभाषित किया गया है। यह परिभाषित करता है कि किसी दिए गए वर्ग का एक उदाहरण होने के लिए एक ऑपरेशन को किस प्रकार लागू करना चाहिए। इस मामले में, Functor न केवल प्रकारों पर परिभाषित किया Functor है, बल्कि टाइप f निर्माणकर्ता पर भी। इसका मतलब यह है कि fmap वह है जो fmap फ़ंक्शन को लागू करता है, जो एक फ़ंक्शन लेता है (टाइप a और रिटर्निंग प्रकार b ) और टाइप fa (टाइप f निर्माता से निर्मित एक प्रकार) का मान टाइप a ) और टाइप fb का मान लौटाता है।

यह समझने के लिए कि वह क्या कर रहा है, fmap को एक फ़ंक्शन के रूप में fmap जो कंटेनर में प्रत्येक तत्व के लिए एक ऑपरेशन लागू करता है।

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

प्रस्तावना> नक्शा (+1) [1,2,3,4,5]
[2,3,4,5,6]

इस सरल उदाहरण में, fmap Functor फंक्शन fmap सिर्फ एक map और टाइप f का कंस्ट्रक्टर [] - एक लिस्ट टाइप कंस्ट्रक्टर है। इसलिए, Functor , उदाहरण के लिए, सूचियों के रूप में परिभाषित किया गया है

उदाहरण फ़नकार [ ] जहाँ
नक्शा = नक्शा

आइए देखते हैं कि यह वास्तव में map बजाय fmap का उपयोग करके सच है,

प्रस्तावना> fmap (+1) [1,2,3,4,5]
[2,3,4,5,6]

लेकिन ध्यान दें कि फ़ंक्टर की परिभाषा संरचना को बनाए रखने के बारे में कुछ नहीं कहती है! इसलिए, किसी भी सामान्य फ़नकार को फंक्शंस के नियमों को स्पष्ट रूप से संतुष्ट करना होगा, जो गणितीय फ़ंक्शंस की परिभाषा का हिस्सा हैं। दो नियम नियम हैं:

fmap id = id
fmap (g। h) = fmap g। fmap h

पहला नियम कहता है कि एक कंटेनर में प्रत्येक तत्व के लिए एक पहचान फ़ंक्शन को मैप करने का कोई प्रभाव नहीं पड़ता है। दूसरा नियम बताता है कि कंटेनर में प्रत्येक तत्व के ऊपर दो फ़ंक्शन की संरचना पहले फ़ंक्शन के प्रदर्शन और फिर दूसरे के प्रदर्शन के समान है।

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

चलो पहले एक पेड़ को परिभाषित करते हैं,

डेटा ट्री a = नोड ( ट्री ) ( ट्री ए )
| पत्ती ए
व्युत्पन्न शो

यह परिभाषा कहती है कि Tree टाइप या तो दो Tree (लेफ्ट और राइट ब्रांच) की एक Node (शाखा) या Leaf (पत्ती) है। deriving Show अभिव्यक्ति हमें शो फ़ंक्शन के माध्यम से पेड़ का निरीक्षण करने की अनुमति देती है।

अब हम पेड़ों के पेड़ों पर Functor को परिभाषित कर सकते हैं,

उदाहरण फ़नकार ट्री जहाँ
fmap g ( लीफ v ) = लीफ ( g v )
fmap g ( Node l r ) = नोड ( fmap g l ) ( fmap g r )

यह परिभाषा कहती है कि मान v साथ Leaf ऊपर एक फंक्शन g का fmap g से v लिए लागू होता है। और बाएं शाखा l और दाएं r साथ Node पर g से fmap बाईं और दाईं शाखाओं के मूल्यों पर लागू किए गए fmap से सिर्फ Node है।

अब आइए हम fmap कि पेड़ों के साथ fmap कैसे काम करता है। आइए String पत्तियों के साथ एक पेड़ का निर्माण करें और प्रत्येक शीट की लंबाई का पता लगाने के लिए उनके ऊपर लंबाई फ़ंक्शन का उपयोग करें।

प्रस्तावना दें> पेड़ = (नोड (पत्ती "नमस्ते") (पत्ती "फू")) (पत्ती "बर"))
प्रस्तावना> लम्बाई का पेड़
नोड (नोड 5) (पत्ती 3) (पत्ती 4)

यहाँ हमने निम्नलिखित पेड़ बनाए हैं,

  *
           / \ _
          / \ _
         * "बर"
        / \ _
       / \ _
      / \ _
     / \ _
  "हैलो" "फू" 

और इसके ऊपर की length प्रदर्शित करना हमें देता है

  *
           / \ _
          / \ _
         * ४
        / \ _     
       / \ _
      / \ _
     / \ _
    ५ ३ 

यह कहने का एक और तरीका है कि fmap क्या करता है (मूल दुनिया में, "सामान्य दुनिया" से एक समारोह " f दुनिया")।

वास्तव में, एक फनकार हास्केल में एक मौलिक प्रकार का वर्ग है क्योंकि मोनाड्स, ऐप्लिकेटिव फ़ंक्शंस और तीर सभी फ़ंक्शंस हैं। मैं कहूंगा कि हास्केल शुरू होता है जहां फंक्शंस शुरू होते हैं।

यदि आप हास्केल में टाइप कक्षाओं के बारे में अधिक जानना चाहते हैं, तो उत्कृष्ट टाइपेकेलोपेडिया लेख (पृष्ठ 17 पर शुरू) से शुरू करें।

प्रोलोग में फनकार

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

? - पसंद ( मैरी , पिज्जा )

पहला परमाणु, likes एक फ़नकार है।

दूसरा एक अंतर्निहित विधेय है जिसे functor कहा जाता है। यह एरिटी और स्ट्रक्चर फन्क्टर को लौटाता है। उदाहरण के लिए

? - functor ( पसंद ( mary , पिज़्ज़ा ) , Functor , Arity ) ।
फ़नकार = पसंद
धम = २

यहाँ आपके पास Prolog में फंक्शन्स हैं।

निष्कर्ष

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

मूल लेख: www.catonmat.net/blog/on-functors

और, यहाँ ऐसी बात ... मुझे यहाँ बताया गया था कि, यह पता चला, जिस व्यक्ति का लेख मैंने हब पर लिखा है =)
वे यह भी कहते हैं कि लेख में प्रोलॉग का हिस्सा गलत है ।