उन लोगों के लिए जो अजीब चाहते हैं: अजगर में भिक्षु

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

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


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

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

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

class _MaybeMonad(object): def __init__(self, just=None, nothing=False): self._just = just self._nothing = nothing def __rshift__(self, fn): if not self._nothing: res = fn(self._just) assert isinstance(res, _MaybeMonad), ( "In Maybe context function result must be Maybe") self._just = res._just self._nothing = res._nothing return self @property def result(self): return (self._nothing, self._just) 

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

संक्षिप्त रूप में इस वर्ग का उपयोग करना अधिक सुविधाजनक है:

 nothing = lambda: _MaybeMonad(nothing=True) just = lambda val: _MaybeMonad(just=val) 

पहला एक असफल परिणाम बनाता है, दूसरा - एक मूल्य के साथ सफल

गणना के अनुक्रम के लिए प्रारंभिक मूल्य पैकेज करने के लिए, मैंने एक उपनाम बनाया:

 returnM = just 

अब आप साधारण कार्य लिख सकते हैं जो एक सामान्य परिणाम देता है:

 def divM(value, divider): '''  .   . "" ''' if divider: return just(value // divider) return nothing() div100by = lambda x: divM(100, x) # ,    def sqrtM(value): if value >= 0: return just(math.sqrt(value)) return nothing() 

एक बांधने की मशीन आप इन चीजों को करने की अनुमति देता है:

 do = returnM(4) >> div100by >> sqrtM # 4 -  error, result = do.result 

क्रियाओं का यह क्रम आम तौर पर एक पैरामीटर के बजाय एक नकारात्मक मान को पचाता है (जिस पर math.sqrt ठोकर खाएगा); विभाजन ऑपरेशन आम तौर पर 0 को एक भाजक के रूप में ले जाएगा और कुछ भी नहीं लौटाएगा (), जो पूरी अभिव्यक्ति का परिणाम होगा।
इस प्रकार, अपवाद अत्यधिक मामलों के लिए बने रहते हैं।

आप इस फ़ंक्शन को शामिल कर सकते हैं:

 lift = lambda fn: lambda val: just(fn(val)) 

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

अब, एक अंतिम स्पर्श के रूप में, आंशिक रूप से लागू करी (धन्यवाद, निश्चित ) जोड़ें:

 curried = lambda fn, *cargs: lambda *args: fn(*(cargs + args)) 

अंत में, एक अधिक व्यापक उदाहरण:

 def calc(x): do = ( returnM(x) >> curried(maybe_div, 100) >> lift(lambda x: x+75) >> lift(int) ) #   failed, result = do.result if failed: print "  ((" else: print ": %s" % result calc(0) #   100 / 0 calc(4) 

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