अधिक विस्तार से अजगर में मठ

आपका दिन शुभ हो!

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


सामग्री काफी हद तक आप महान के लिए हास्केल लर्न के व्यक्तिगत अध्यायों को दोहराएगी , लेकिन मेरी समझ के चश्मे के माध्यम से और पायथन भाषा के ढांचे के भीतर। मैं स्वयं पुस्तक को पढ़ने की अत्यधिक सलाह देता हूं, भले ही आपको हास्केल में इस तरह के कार्य को लिखने की कोई योजना नहीं है: आपके क्षितिज का काफी विस्तार होगा। मैं शुरू करूँगा, शायद।

प्रसंग

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

functors

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

हम निम्नलिखित प्रोटोटाइप वर्ग को लागू करते हैं:

class Functor(Infixable): ''' ''' def fmap(self, func): raise NotImplementedError() #    -  

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

वैसे, पायथन में सूची सबसे मजेदार है, और फ़ंक्शन को सूची की सामग्री पर लागू करने के लिए तंत्र नक्शा () है। नक्शा (एब्स, [-2, -1,0,1,2]) - यह सूची के तत्वों का निष्कर्षण है, प्रत्येक में फ़ंक्शन को लागू करता है, और इसे वापस सूची में डालता है।
एक फ़नकार के रूप में सूची की कल्पना करें:

 class List(Functor): def __init__(self, *items): super(List, self).__init__() self._items = items def fmap(self, func): self._items = map(func, self._items) #     - , .. map() return self @property def result(self): return self._items 

अब आप यह कर सकते हैं:

 >>> print List(-2,-1,0,1,2).fmap(abs).fmap(lambda x: x*2).fmap(str).result ['4', '2', '0', '2', '4'] 

हास्केल में, टाइप सिस्टम आपको फ़नकार प्रकार वर्ग को लागू करने की अनुमति देता है, और सभी डेटा प्रकार जो इस वर्ग के हैं (और वे कर सकते हैं और, आमतौर पर, कई प्रकार के वर्ग के हैं)। उपयोग में प्रकार वर्ग विधि एक नियमित कार्य की तरह लगती है:

 fmap abs [-2,-1,0,1,2] 

यह कुछ हद तक सौंदर्यवादी है, लेकिन पायथन संस्करण लागू है।

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

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

Infix संकेतन

पायथन में कस्टम फ़ंक्शन के लिए कोई सामान्य इन्फिक्स नोटेशन नहीं है - सिंटैक्स जमे हुए हैं। और कभी-कभी मैं वास्तव में कुछ लागू करना चाहता हूं जैसे:

 (/*/) = lambda x,y: (x + y) * (x - y) print 5 /*/ 4 /*/ 3 

काश, कोई रास्ता नहीं। मैंने एक वर्ग लिखा है जो ऑब्जेक्ट विधियों के लिए infix संकेतन के उपयोग की अनुमति देता है। खुद कक्षा:

 class Infixable(object): INFIX_OPS = [{}] def __init__(self): self._last_is_opcode = False self._op = None table = {} for sub_table in self.INFIX_OPS: table.update(sub_table) self._op_table = table def __add__(self, val): if self._last_is_opcode: method = getattr(self, self._op_table[self._op]) method(val) else: self._op = val self._last_is_opcode = not self._last_is_opcode return self 

इस श्रेणी में + ऑपरेटर अतिभारित है, और सभी नमक INFIX_OPS वर्ग की विशेषता में समाहित है। यदि एक निश्चित MyObj - Infixable का वंशज है - mmm (स्वयं, मान) विधि को लागू करता है और INFIX_OPS को फ़ॉर्म के शब्दकोश के साथ पूरक करता है {'/ * /': 'mmm', ...}, तो उदाहरण पर संचालन के अनुक्रम को रिकॉर्ड करने का यह रूप संभव हो जाएगा:

 obj = MyObj() +'/*/+ 1 +'/*/'+ 2 +'/*/'+ 3 

बहुत सुंदर नहीं है, लेकिन यह काम करता है। शायद तब मुझे कोई विकल्प मिल जाएगा।

एप्लाइड फंक्शनल

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

 class Applicative(Functor): INFIX_OPS = Functor.INFIX_OPS + [{ '<*>': 'applicate' }] def applicate(self, value): raise NotImplementedError() 

इस वर्ग के वंशजों को आवेदक (मूल्य) विधि प्राप्त होगी और इसके लिए इन्फिक्स ऑपरेटर '<*> है।
ऊपर सूचीबद्ध पूर्वजों की सूची को उपादेय के साथ बदलें और नई पद्धति का कार्यान्वयन जोड़ें। यह सूची घोंसले के स्तर को कम करने के लिए एक सहायक समारोह की आवश्यकता होगी ([[ए, बी], [सी, डी]] -> [ए, बी, सी, डी])। समारोह और वर्ग:

 def _concat(lists): return reduce(lambda x, y: x + y, lists, []) class List(Applicative): ... #      List,  Functor def applicate(self, value): # value -    ( -  ) self._items = _concat([ map(fn, value._items) for fn in self._items ]) return self 

अब आप यह कर सकते हैं:

 >>> List(str).applicate(List(1,2,3,4,5)).result ['1', '2', '3', '4', '5'] 

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

 >>> print ( ... List(str, abs) +'<*>'+ List(-10, -20) ... ).result ['-10', '-20', 10, 20] 

हमें सभी कार्यों को सभी मापदंडों पर लागू करने का परिणाम मिला। और आप यह कर सकते हैं:

 >>> add = lambda x: lambda y: x + y #   >>> mul = lambda x: lambda y: x * y #   >>> print ( ... List(add, mul) +'<*>'+ List(1, 2) +'<*>'+ List(10, 100) ... ).result [11, 101, 12, 102, 10, 100, 20, 200] 

सबसे पहले, सभी तर्कों के सभी कार्यों को सभी पहले तर्कों पर लागू किया जाता है। फ़ंक्शंस करी जाती हैं और दूसरे तर्क के कार्यों को वापस करती हैं, जो सभी दूसरे तर्कों पर लागू होते हैं!

अब हम कार्यों को संदर्भ में रखने और संदर्भ में मूल्यों पर लागू करने में सक्षम हैं: बॉक्स में प्रत्येक पत्रक पर, बॉक्स के प्रत्येक महसूस किए गए टिप पेन को खींचकर, टिप-टिप पेन को बाहर निकालते हैं, जो कागज के प्रत्येक टुकड़े पर खींचे जाने के बाद ही हटाए जाते हैं।

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

इकाई

मोनोटाइप क्लास प्रोटोटाइप:

 class Monad(Applicative): INFIX_OPS = Applicative.INFIX_OPS + [{ '>>=': 'bind', '>>': 'then', }] def bind(self, monad_func): raise NotImplementedError() def then(self, monad_func): raise NotImplementedError() @property def result(self): raise NotImplementedError() 

सन्यासी 2 तरीके बाँध (>> =) और फिर (>>) प्रदान करता है।
बाइंड () को संदर्भ से मान मिलता है, मोनाड फ़ंक्शन को पास करता है, जो संदर्भ में अगला मान (मोनड वैल्यू) लौटाता है।
तब () पिछले मोनड मूल्य को त्यागता है, बिना किसी तर्क के एक फ़ंक्शन को कॉल करता है, जो नए मान मूल्य को वापस करता है।

मोनाद सूची

अब, सूची का पूरा कार्यान्वयन हमारे सामने कर दिया गया:

 def _concat(lists): return reduce(lambda x, y: x + y, lists, []) class List(Monad): def __init__(self, *items): super(List, self).__init__() self._items = items def fmap(self, func): self._items = map(func, self._items) return self def applicate(self, monad_value): self._items = _concat([ map(fn, monad_value._items) for fn in self._items ]) return self def bind(self, monad_func): self._items = _concat(map(lambda x: monad_func(x)._items, self._items)) return self def then(self, monad_func): self._items = monad_func()._items return self @property def result(self): return self._items liftList = lambda fn: lambda x: List( *(fn(x)) ) 

LifList संदर्भ में एक नियमित कार्य को "खींचता है": "खींचा" फ़ंक्शन एक मान मूल्य देता है

और यहां एक मोनड के रूप में सूची का उपयोग करने का एक उदाहरण है: कार्य यह जांचना है कि क्या यह संभव है कि शतरंज के बोड पर एक निर्दिष्ट बिंदु से दूसरे निर्दिष्ट बिंदु तक घोड़े के साथ 3 चाल चलें।

 #  ,       raw_jumps = lambda (x, y): List( (x + 1, y + 2), (x + 1, y - 2), (x - 1, y + 2), (x - 1, y - 2), (x + 2, y + 1), (x + 2, y - 1), (x - 2, y + 1), (x - 2, y - 1), ) #  ,     if_valid = lambda (x, y): List( (x, y) ) if 1 <= x <= 8 and 1 <= y <= 8 else List() #          jump = lambda pos: List(pos) +'>>='+ raw_jumps +'>>='+ if_valid # ,        #     3   in3jumps = lambda pos_from, pos_to: pos_to in ( List(pos_from) +'>>='+ jump +'>>='+ jump +'>>='+ jump ).result print in3jumps((3,3), (5,1)) #  print in3jumps((3,3), (5,2)) #  

शायद मोनाद

शायद मोनाद एक संदर्भ को लागू करता है जिसमें एक मानद मूल्य दो राज्यों में से एक को दर्शाता है:
- पिछला चरण सफलतापूर्वक पूरा हुआ, कुछ मूल्य (सिर्फ x) के साथ
- पिछला चरण विफल (कुछ भी नहीं)

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

यदि हो सकता है कि हो सकता है कि हो सकता है कि संदर्भ-संदर्भ और तर्कों के अंदर एक फ़ंक्शन है (हो सकता है, एक ऐप्लिकेटर फ़ंक्टर की तरह), तो फ़ंक्शन लागू किया जाएगा यदि यह है और सभी तर्क हैं, अन्यथा परिणाम तुरंत विफल हो जाएगा।

शायद मोनाद क्लास:

 class Maybe(Monad): def __init__(self, just=None, nothing=False): super(Maybe, self).__init__() self._just = just self._nothing = nothing def fmap(self, func): if not self._nothing: self._just = func(self._just) return self def applicate(self, monad_value): if not self._nothing: assert isinstance(monad_value, Maybe) app_nothing, just = monad_value.result if app_nothing: self._nothing = True else: self._just = self._just(just) return self def bind(self, monad_func): if not self._nothing: monad_value = monad_func(self._just) assert isinstance(monad_value, Maybe) nothing, just = monad_value.result if nothing: self._nothing = True else: self._just = just return self def then(self, monad_func): monad_value = monad_func() assert isinstance(monad_value, Maybe) self._nothing, just = monad_value.result if not self._nothing: self._just = just return self @property def result(self): return (self._nothing, self._just) just = lambda x: Maybe(just=x) nothing = lambda: Maybe(nothing=True) liftMaybe = lambda fn: lambda x: just(fn(x)) 

बस (x) और कुछ नहीं () अधिक आसानी से मेल खाते मोनाड मान बनाने के लिए शॉर्टकट हैं। LifMaybe - शायद संदर्भ में "खींच"।

एक फनकार और एपेक्टिव फन्क्टर के रूप में उपयोग के उदाहरण:

  def showMaybe(maybe): nothing, just = maybe.result if nothing: print "Nothing!" else: print "Just: %s" % just # ==== Maybe as functor ==== showMaybe( just(-3).fmap(abs) ) # ==== Maybe as applicative functor ==== add = lambda x: lambda y: x+y #   -   showMaybe( nothing() +'<*>'+ just(1) +'<*>'+ just(2) ) #      -   showMaybe( just(add) +'<*>'+ nothing() +'<*>'+ just(2) ) showMaybe( just(add) +'<*>'+ just(1) +'<*>'+ nothing() ) #    -    showMaybe( just(add) +'<*>'+ just(1) +'<*>'+ just(2) ) 

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

 #      to_left = lambda num: lambda (l, r): ( nothing() if abs((l + num) - r) > 4 else just((l + num, r)) ) #      to_right = lambda num: lambda (l, r): ( nothing() if abs((r + num) - l) > 4 else just((l, r + num)) ) #   banana = lambda x: nothing() #   def show(maybe): falled, pole = maybe.result print not falled #   begin = lambda: just( (0,0) ) show( begin() +'>>='+ to_left(2) +'>>='+ to_right(5) +'>>='+ to_left(-2) #    ) show( begin() +'>>='+ to_left(2) +'>>='+ to_right(5) +'>>='+ to_left(-1) ) #      show( begin() +'>>='+ to_left(2) +'>>='+ banana #    +'>>='+ to_right(5) +'>>='+ to_left(-1) ) 

एक आफ्टरवर्ड के बजाय

इसी तरह, आप अन्य प्रसिद्ध मठों, या अपने स्वयं के कुछ को लागू कर सकते हैं।
आप केवल एक फ़नकार बना सकते हैं, लेकिन, उदाहरण के लिए, संबंधित वस्तुओं पर एक पेड़ के लिए।

टिप्पणी

मैंने जानबूझकर मोनाद कानूनों के विषय को नहीं छुआ, यह महत्वपूर्ण है, लेकिन यह विषय पहले से ही बड़ा था। अगली बार कुछ बताना होगा।

बदला

टिप्पणी के लिए धन्यवाद (धन्यवाद, कवक) मैंने लिस्ट मोनाद के संदर्भ में मोनड कार्यों द्वारा लौटाए गए मूल्यों के बारे में विरोधाभास को समाप्त कर दिया। अब उन्हें परिणाम के रूप में सूची उदाहरण बिल्कुल वापस आ जाना चाहिए।

नया संस्करण

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