15 मिनट में मोनाड

प्रविष्टि

YOW पर! 2013 हास्केल भाषा के डेवलपर्स में से एक, प्रोफेसर। फिलिप वाडलर ने दिखाया कि कैसे भिक्षु शुद्ध कार्यात्मक भाषाओं को अनिवार्य रूप से अनिवार्य परिचालन जैसे इनपुट-आउटपुट और अपवाद से निपटने की अनुमति देते हैं। आश्चर्य नहीं कि इस विषय में दर्शकों की रुचि इंटरनेट पर भिक्षुओं के बारे में प्रकाशनों में विस्फोटक वृद्धि हुई है। दुर्भाग्य से, इनमें से अधिकांश प्रकाशन कार्यात्मक भाषाओं में लिखे गए उदाहरणों का उपयोग करते हैं, जिसका अर्थ है कि कार्यात्मक प्रोग्रामिंग के नए लोग मठों के बारे में सीखना चाहते हैं। लेकिन भिक्षु हास्केल या कार्यात्मक भाषाओं के लिए विशिष्ट नहीं हैं, और अनिवार्य प्रोग्रामिंग भाषाओं में उदाहरण द्वारा अच्छी तरह से चित्रित किया जा सकता है। यही इस गाइड का उद्देश्य है।

यह मार्गदर्शिका बाकियों से अलग कैसे है? हम केवल अंतर्ज्ञान और पायथन कोड के कुछ प्राथमिक उदाहरणों का उपयोग करके 15 मिनट से अधिक समय में मठों को खोलने की कोशिश करेंगे। इसलिए, हम ब्यूरिटोस, स्पेस सूट , डेस्क और एंडोफुन्क्टरों के बारे में बात करते हुए, सिद्धांत में सिद्धांत और सिद्धांत नहीं देंगे।

प्रेरक उदाहरण

हम कार्यों की संरचना से संबंधित तीन मुद्दों पर विचार करेंगे। हम उन्हें दो तरीकों से हल करेंगे: सामान्य अनिवार्यता और मोनाड्स का उपयोग करना। फिर हम विभिन्न तरीकों की तुलना करते हैं।

1. लॉगिंग

मान लीजिए कि हमारे तीन कार्य हैं: f1 , f2 और f3 , जो एक संख्या लेते हैं और इसे क्रमशः 1, 2 और 3 तक बढ़ाकर वापस कर देते हैं। प्रत्येक फ़ंक्शन एक संदेश भी उत्पन्न करता है, जो पूर्ण किए गए ऑपरेशन पर एक रिपोर्ट है।

 def f1(x): return (x + 1, str(x) + "+1") def f2(x): return (x + 2, str(x) + "+2") def f3(x): return (x + 3, str(x) + "+3") 

हम पैरामीटर x को संसाधित करने के लिए उन्हें एक साथ चेन करना चाहेंगे, दूसरे शब्दों में, हम x+1+2+3 गणना करना चाहेंगे। इसके अलावा, हमें एक मानव-पठनीय स्पष्टीकरण प्राप्त करने की आवश्यकता है कि प्रत्येक फ़ंक्शन ने क्या किया।

हमें निम्नलिखित तरीके से परिणाम की आवश्यकता हो सकती है:

 log = "Ops:" res, log1 = f1(x) log += log1 + ";" res, log2 = f2(res) log += log2 + ";" res, log3 = f3(res) log += log3 + ";" print(res, log) 

यह समाधान आदर्श नहीं है, क्योंकि इसमें बड़ी संख्या में नीरस मिडलवेयर शामिल हैं। यदि हम अपनी श्रृंखला में एक नया कार्य जोड़ना चाहते हैं, तो हम इस लिंकिंग कोड को दोहराने के लिए बाध्य होंगे। इसके अलावा, res और log चर के साथ जोड़तोड़ कोड की पठनीयता को बिगाड़ते हैं, जिससे कार्यक्रम के मुख्य तर्क का पालन करना मुश्किल हो जाता है।

आदर्श रूप से, एक प्रोग्राम को कार्यों की एक साधारण श्रृंखला की तरह दिखना चाहिए, जैसे कि f3(f2(f1(x))) । दुर्भाग्य से, डेटा प्रकार f1 और f2 द्वारा लौटाए गए पैरामीटर प्रकार f2 और f3 मेल नहीं खाते हैं। लेकिन हम श्रृंखला में नए कार्य जोड़ सकते हैं:

 def unit(x): return (x, "Ops:") def bind(t, f): res = f(t[0]) return (res[0], t[1] + res[1] + ";") 

अब हम समस्या का समाधान इस प्रकार कर सकते हैं:

 print(bind(bind(bind(unit(x), f1), f2), f3)) 

निम्नलिखित चित्र x=0 पर होने वाली कम्प्यूटेशनल प्रक्रिया को दर्शाता है। यहां v1 , v2 और v3 unit और bind परिणामस्वरूप प्राप्त मान bind ।



unit फ़ंक्शन इनपुट पैरामीटर x को एक संख्या और एक स्ट्रिंग के ट्यूपल में परिवर्तित करता है। bind फ़ंक्शन एक पैरामीटर के रूप में पारित फ़ंक्शन को कॉल करता है और परिणाम को मध्यवर्ती चर t में जमा करता t ।

हम इसे bind फ़ंक्शन में रखकर मिडलवेयर को दोहराने से बचने में सक्षम थे। अब, अगर हमें फंक्शन f4 मिलता है, तो हम इसे चेन में शामिल करते हैं:

 bind(f4, bind(f3, ... )) 

और हमें कोई अन्य परिवर्तन करने की आवश्यकता नहीं है।

2. मध्यवर्ती मूल्यों की सूची

हम इस उदाहरण को सरल क्रियाओं के साथ भी शुरू करेंगे।

 def f1(x): return x + 1 def f2(x): return x + 2 def f3(x): return x + 3 

पिछले उदाहरण के अनुसार, हमें x+1+2+3 गणना करने के लिए इन कार्यों की रचना करने की आवश्यकता है। हमें अपने कार्यों के कार्य के परिणामस्वरूप प्राप्त सभी मूल्यों की एक सूची प्राप्त करने की आवश्यकता है, x , x+1 , x+1 , x+1+2 और x+1+2+3 ।

पिछले उदाहरण के विपरीत, हमारे कार्य रचना योग्य हैं, अर्थात, उनके इनपुट मापदंडों के प्रकार परिणाम के प्रकार के साथ मेल खाते हैं। इसलिए, एक साधारण श्रृंखला f3(f2(f1(x))) अंतिम परिणाम लौटाएगा। लेकिन इस मामले में, हम मध्यवर्ती मूल्यों को खो देते हैं।

आइए समस्या "सिर पर" हल करें:

 lst = [x] res = f1(x) lst.append(res) res = f2(res) lst.append(res) res = f3(res) lst.append(res) print(res, lst) 

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

इसलिए, हम पिछले उदाहरण में दो अतिरिक्त कार्य जोड़ते हैं:

 def unit(x): return (x, [x]) def bind(t, f): res = f(t[0]) return (res, t[1] + [res]) 

अब हम कॉल की एक श्रृंखला के रूप में कार्यक्रम को फिर से लिखते हैं:

 print(bind(bind(bind(unit(x), f1), f2), f3)) 

निम्नलिखित चित्र x=0 पर होने वाली कम्प्यूटेशनल प्रक्रिया को दर्शाता है। फिर से, v1 , v2 और v3 unit से प्राप्त मूल्यों को दर्शाते हैं और कॉल को bind हैं।

3. रिक्त मान

आइए अधिक दिलचस्प उदाहरण देने की कोशिश करें, इस बार कक्षाओं और वस्तुओं के साथ। मान लें कि हमारे पास दो तरीकों के साथ एक Employee वर्ग है:

 class Employee: def get_boss(self): # Return the employee's boss def get_wage(self): # Compute the wage 

Employee वर्ग के प्रत्येक ऑब्जेक्ट में एक प्रबंधक ( Employee वर्ग का एक और उद्देश्य) और एक वेतन होता है, जो उचित तरीकों से एक्सेस किया जाता है। दोनों विधियां भी वापस आ सकती हैं (कर्मचारी के पास प्रबंधक नहीं है, वेतन अज्ञात है)।

इस उदाहरण में, हम एक कार्यक्रम बनाएंगे जो इस कर्मचारी के नेता के वेतन को दर्शाता है। यदि प्रबंधक नहीं मिला है, या उसका वेतन निर्धारित नहीं किया जा सकता है, तो कार्यक्रम None लौटाएगा।

आदर्श रूप में, हमें कुछ लिखने की जरूरत है

 print(john.get_boss().get_wage()) 

लेकिन इस मामले में, यदि कोई भी विधि वापस None आती है, तो हमारा कार्यक्रम एक त्रुटि के साथ समाप्त होगा।

इस स्थिति को संभालने का एक स्पष्ट तरीका इस तरह दिखाई दे सकता है:

 result = None if john is not None and john.get_boss() is not None and john.get_boss().get_wage() is not None: result = john.get_boss().get_wage() print(result) 

इस स्थिति में, हम get_boss और get_wage लिए अतिरिक्त कॉल की अनुमति देते हैं। यदि ये विधियां पर्याप्त रूप से भारी हैं (उदाहरण के लिए, डेटाबेस तक पहुंच), तो हमारा समाधान नहीं होगा। इसलिए, हम इसे बदलते हैं:

 result = None if john is not None: boss = john.get_boss() if boss is not None: wage = boss.get_wage() if wage is not None: result = wage print(result) 

गणना के संदर्भ में यह कोड इष्टतम है, लेकिन तीन नेस्टेड if कारण खराब पढ़ा जाता है। इसलिए, हम पिछले उदाहरणों के समान चाल का उपयोग करने का प्रयास करेंगे। दो कार्यों को परिभाषित करें:

 def unit(e): return e def bind(e, f): return None if e is None else f(e) 

और अब हम पूरे समाधान को एक पंक्ति में रख सकते हैं।

 print(bind(bind(unit(john), Employee.get_boss), Employee.get_wage)) 

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

यह भी ध्यान दें कि पायथन में हम ऐसे तरीकों का उपयोग कर सकते हैं, जो हमें john.get_boss() बजाय Employee.get_boss(john) लिखने की अनुमति देते हैं।

निम्नलिखित आरेख गणना प्रक्रिया को दिखाता है जब जॉन के पास एक नेता नहीं होता है, अर्थात् john.get_boss() None देता है।

निष्कर्ष

मान लीजिए हम एक ही प्रकार के कार्यों को संयोजित करना चाहते हैं f1 , f2 , … , fn । यदि उनके इनपुट पैरामीटर परिणाम के समान हैं, तो हम प्रपत्र fn(… f2(f1(x)) …) एक सरल श्रृंखला का उपयोग कर सकते हैं। निम्नलिखित आरेख एक सामान्यीकृत गणना प्रक्रिया को मध्यवर्ती परिणामों के साथ दिखाता है, जिन्हें v1 , v2 , … , vn रूप में दर्शाया गया है।



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

1. इंपीरियल निर्णय

सभी उदाहरणों में, हमने पहले सबसे सरल दृष्टिकोण का उपयोग किया, जिसे निम्नलिखित चित्र द्वारा दर्शाया जा सकता है:



f1 कॉल करने से पहले f1 हमने कुछ इनिशियलाइज़ेशन किया। पहले उदाहरण में, हमने एक सामान्य लॉग को संग्रहीत करने के लिए एक चर शुरू किया, दूसरे में मध्यवर्ती मूल्यों की सूची के लिए। उसके बाद, हमने एक निश्चित कनेक्टिंग कोड के साथ फ़ंक्शन कॉल को इंटरसेप्ट किया: हमने कुल मूल्यों की गणना की, None लिए परिणाम की जांच None ।

2. मोनाड

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

 bind(bind( ... bind(bind(unit(x), f1), f2) ... fn-1), fn) 

गणना प्रक्रिया को आरेख द्वारा दर्शाया जा सकता है:



unit(x) लिए एक कॉल v1 का एक प्रारंभिक मूल्य उत्पन्न करता है। फिर bind(v1, f1) एक नया मध्यवर्ती मूल्य v2 उत्पन्न करता है, जिसका उपयोग अगली कॉल में bind(v2, f2) । अंतिम प्रक्रिया प्राप्त होने तक यह प्रक्रिया जारी रहती है। विभिन्न unit को परिभाषित करके और इस टेम्पलेट के ढांचे के भीतर, हम गणना के एक श्रृंखला में विभिन्न कार्यों को जोड़ सकते हैं। मोनाड लाइब्रेरीज़ ( उदाहरण के लिए, पायमोनड या ओएसलैश - लगभग अनुवाद। ) आमतौर पर कार्यों की कुछ रचनाओं को लागू करने के लिए रेडी-टू- यूज़ मोनड ( unit और bind फ़ंक्शंस) bind ।

चेन फंक्शंस के लिए, unit और bind द्वारा लौटाए गए मान एक ही प्रकार के होने चाहिए, जैसे bind के इनपुट पैरामीटर। इस प्रकार को मोनैडिक कहा जाता है। उपरोक्त आरेख के संदर्भ में, वेरिएबल v1 , v2 , … , vn प्रकार एक मोनडिक प्रकार होना चाहिए।

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

 def pipeline(e, *functions): for f in functions: e = bind(e, f) return e 

अब इसके बजाय

 bind(bind(bind(bind(unit(x), f1), f2), f3), f4) 

हम निम्नलिखित संक्षिप्त नाम का उपयोग कर सकते हैं:

 pipeline(unit(x), f1, f2, f3, f4) 

निष्कर्ष

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

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

1. विकिपीडिया
2. अजगर में राक्षस (अच्छा वाक्यविन्यास के साथ!)
3. मोनाद ट्यूटोरियल समयरेखा