एक और मोनाद गाइड (भाग 2: कार्य >> = और वापसी)

माइक वनियर द्वारा

दो मौलिक मौद्रिक संचालन

याद रखें, मैंने कहा कि भिक्षु रचना और कार्यों के अनुप्रयोग को सामान्य करते हैं? हम यहां इस बारे में बात करेंगे। धैर्य रखें, हमें कुछ समय लगेगा।

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

मान लीजिए कि हमारे पास ऐसे मौद्रिक कार्य हैं:

एफ :: ए -> एम बी
g :: b -> m c

कुछ मोनाड के लिए। यदि आप एक और अधिक विशिष्ट उदाहरण चाहते हैं, तो आप कल्पना कर सकते हैं कि I और monad में f और g कार्य हैं:

f :: a -> IO b
g :: b -> IO c

हालांकि, अन्य साधुओं के लिए भी यही सच है। स्मरण करो ( IO के मामले के लिए) कि फ़ंक्शन च प्रकार का मान लेता है और प्रकार b का एक मान उत्पन्न करता है, और इस प्रक्रिया में, शायद, इनपुट / आउटपुट ( IO ) के साथ बातचीत करता है। फ़ंक्शन जी , बदले में, टाइप बी का मान लेता है और टाइप सी का मान प्रदर्शित करता है, और इस प्रक्रिया में, शायद, यह इनपुट / आउटपुट के साथ काम करता है। इन कार्यों की संरचना का उपयोग करते हुए, हम फ़ंक्शन एच प्राप्त करने की उम्मीद करते हैं:

h :: a -> IO c

यही है, परिणाम एक ऐसा फ़ंक्शन है जो टाइप a का मान लेता है, प्रकार c का मान आउटपुट करता है , और इस प्रक्रिया में इनपुट / आउटपुट (जहां इनपुट / आउटपुट क्या f और g do का एक संयोजन है ) के साथ काम करता है। छद्म भाषा में, हम इसे इस तरह लिख सकते हैं:

कनेक्ट समारोह:
( f :: a -> IO b )
समारोह के साथ:
( g :: b -> IO c )
पाने के लिए:
( h :: a -> IO c )

हालांकि, हास्केल में, रचना ऑपरेटर (डॉट) को IO प्रकार के बारे में कुछ भी नहीं पता है, इसलिए यह हमारे f और g फ़ंक्शन के साथ काम नहीं करेगा। तुलना के लिए, आइए बिना किसी IO के सामान्य प्रकार p , q , r के शुद्ध कार्यों को देखें:

पी :: ए -> बी
क्यू :: बी -> सी
आर :: ए -> सी

ऑपरेटर (।) और (>।>) यहाँ उपयुक्त हैं:

( । ) :: ( b -> c ) -> ( a -> b ) -> ( a -> c )
आर = क्यू । पी
( >।> ) :: ( ए -> बी ) -> ( बी -> सी ) -> ( ए -> सी )
r = p >> क्यू

लेकिन उनमें से कोई भी राक्षसी कार्यों के साथ काम नहीं करेगा:

f :: a -> IO b
g :: b -> IO c
h :: a -> IO c
जी । f -> टाइपिंग एरर ! IO b और b के बीच बेमेल
f >> g -> टाइपिंग त्रुटि ! IO b और b के बीच बेमेल

यदि टाइप b की आवश्यकता है तो आप IO b प्रकार के एक मान का उपयोग नहीं कर सकते हैं। (यह हास्केल मोनैडिक कार्यक्रमों द्वारा की गई सबसे आम गलती है।) हमें एक विशेष मोनडिक कंपोजिशन फंक्शन की जरूरत है, जिसे मैं mcompose (" monadic compose " से) कहता हूं। उसके पास निम्न प्रकार है:

mcompose :: ( a -> m b ) -> ( b -> m c ) -> ( a -> m c )

यह किसी भी सन्यासी के लिए काम करता है, जिसमें IO मोनाद भी शामिल है। IO को प्रतिस्थापित करते हुए, हमें फ़ंक्शन की संबंधित परिभाषा मिलती है:

mcompose :: ( a -> IO c ) -> ( b -> IO c ) -> ( a -> IO c )

हम इसका इस्तेमाल मोनडिक कार्यों को करने के लिए कर सकते हैं f और g । फ़ंक्शन प्रकार h सही होगा:

f :: a -> IO b
g :: b -> IO c
h :: a -> IO c
h = f `mcompose` जी

(यहाँ, mcompose फ़ंक्शन उल्टे एपोस्ट्रोफ़्स से घिरा हुआ है। यह एक सुंदर वाक्य रचना चीनी है जो आपको दो-तर्क फ़ंक्शन से एक infix ऑपरेटर बनाने की अनुमति देता है। यह मत भूलो कि हास्केल में ऑपरेटरों को केवल उनके ऑपरेंड के बीच रखा गया कार्य है।) कुछ रहस्यमय तरीके से (अभी भी रहस्यमय)। , mcompose फ़ंक्शन (या ऑपरेटर, यदि आप चाहते हैं) सक्षम है:

1. प्रकार का प्रारंभिक मूल्य स्वीकार करें a ;
2. फ़ंक्शन को इसे लागू करें (कार्यों का सामान्य अनुप्रयोग) और प्रकार का परिणाम प्राप्त करें IO b ;
3. फ़ंक्शन f से टाइप IO b का मान लें और प्रकार b का मान निकालें (यह वही है जो हम नहीं कर सकते हैं);
4. प्रकार बी का मान लें और फ़ंक्शन जी को लागू करें (फिर से, कार्यों का सामान्य अनुप्रयोग) प्रकार का मान प्राप्त करने के लिए IO c , जो वांछित परिणाम है।

केवल एक चीज जो हम अभी भी नहीं कर सकते हैं वह है चरण (3) - प्रकार के मान से प्राप्त करने के लिए IO प्रकार का मान। चलो एक निकालने के समारोह के साथ आते हैं जिसे हम निकालने के लिए उपयोग कर सकते हैं। यहाँ उसका प्रकार है:

अर्क :: आईओ बी -> बी

और अगर हम सभी भिक्षुओं के लिए सामान्यीकरण करते हैं, तो हम प्राप्त करते हैं:

अर्क :: एम बी -> बी

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

* सीमांत नोट। * वास्तव में, कुछ साधुओं के लिए अर्क समारोह के बराबर होता है, जिससे कोई समस्या नहीं होती है। हालांकि, मुझे यह कहना होगा कि सभी मोनड्स के लिए सामान्यीकृत अर्क फ़ंक्शन निषिद्ध है।

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

hh :: a -> c

कभी भी एक रीड / राइट ऑपरेशन (एक फ़ाइल या कंसोल के साथ) को लागू नहीं करेगा, क्योंकि अन्यथा इसका एक प्रकार होना चाहिए

hh :: a -> IO c

इस तरह की गारंटी, एक प्रकार की प्रणाली द्वारा समर्थित, हास्केल की मुख्य ताकत में से एक है। वे हमें एक फ़ंक्शन की परिभाषा पर एक नज़र में, 100% सुनिश्चित करते हैं कि यह इनपुट / आउटपुट (उदाहरण के लिए) के साथ बातचीत नहीं करता है।

हालाँकि, अगर हमारे पास एक्स्ट्रेक्ट फंक्शन था, तो हम hh बना सकते हैं - अशुद्ध से माना जाने वाला शुद्ध फंक्शन, I / O का संचालन करना:

ff :: a -> IO b
gg :: b -> c
hh = ff >> अर्क >> gg - या एक ही चीज: hh = gg। निकालें। एफएफ

यहां तक ​​कि अगर यह कभी भी इरादा नहीं था कि hh फ़ंक्शन I / O करेगा, तो आप इसे अर्क और सामान्य रचना ऑपरेटर का उपयोग करके बना सकते हैं, और hh प्रकार साफ होगा - लेकिन अंदर, I / O संचालन अभी भी किया जाएगा। और शुद्ध गणनाओं से IO (साथ ही अन्य विवादास्पद गणनाओं) को अलग करने से काम नहीं चलेगा। (लेकिन यह भिक्षुओं को पेश करने के मुख्य कारणों में से एक है।) ध्यान दें, वास्तव में, यह स्थिति अधिकांश साधारण प्रोग्रामिंग भाषाओं के साथ हो रही है, यही कारण है कि उनके प्रकार सिस्टम गारंटी नहीं देते हैं कि फ़ंक्शन साफ ​​हैं। हास्केल के विपरीत, हम इसके शुद्ध कार्यों के तंत्र को पसंद करते हैं, इसकी प्रकार प्रणाली, जिसके लिए शुद्ध कार्यों को शुद्ध होने की आवश्यकता होती है, और इसलिए हास्केल के पास निकालने का कार्य नहीं है।

एक छोटी सी समस्या है जो मैंने अभी कहा है: वास्तव में यह एक झूठ है। IO प्रकार a -> a के साथ एक असुरक्षित प्रीफॉर्मियो फ़ंक्शन है , अर्थात, यह IO मोनाड के लिए एक्सट्रैक्ट वर्जन है। शब्द "असुरक्षित" यह संकेत देता है कि आपको इस फ़ंक्शन से बचना चाहिए यदि आप नहीं जानते कि आप वास्तव में क्या करना चाहते हैं या अजीब विफलताओं के लिए तैयार नहीं हैं। मुझे कभी भी असुरक्षित माल का उपयोग नहीं करना पड़ा, लेकिन कानूनी मामले हैं, उदाहरण के लिए, हास्केल संकलक के कार्यान्वयन में गहरी। बस भूल जाओ मैंने तुमसे कहा था कि, ठीक है? मैं इस बारे में शर्मिंदा हूं। माफ़ कीजिए। {3}

लेकिन चलो जारी रखें। इस बिंदु पर, हमने स्थापित किया है: (ए) राक्षसी कार्यों की एक संरचना की आवश्यकता है; (ख) - सामान्य रचना संचालक इसके लिए उपयुक्त नहीं है, क्योंकि हम सामान्य प्रकार के सामान्य प्रकारों को कम नहीं कर सकते हैं; और (c) - आप एक्सट्रैक्ट फंक्शन सेट नहीं कर सकते, क्योंकि यह पूरी भाषा की शुद्धता को बिगाड़ देता है। तो हम क्या करें?

खैर, सबसे पहले, चलो mcompose की तुलना में कुछ सरल के साथ आने की कोशिश करते हैं। मान लें कि कुछ फ़ंक्शन मैपली ( मोनैडिक एप्लिकेशन) हैं, जिसमें निम्न प्रकार हैं:

mapply :: m b -> ( b -> m c ) -> m c

और अगर आप आम साधुओं से IO तक नीचे जाते हैं, तो हमें यह मिलता है:

mapply :: IO b -> ( b -> IO c ) -> IO c

फ़ंक्शन के सामान्य ऑपरेटर अनुप्रयोग के लिए इसकी समानता के कारण इसे मैपली कहा जाता है। स्मरण करो, उदाहरण के लिए, ऑपरेटर > $> , पहले इस तरह से परिभाषित किया गया है:

( > $> ) :: बी -> ( बी -> सी ) -> सी

केवल mapply के रूप में ही, कोई "m" नहीं हैं (प्रकार राक्षसी नहीं हैं)। mcompose को तुच्छ रूप से व्यक्त किया जाता है:

mcompose :: ( a -> m b ) -> ( b -> m c ) -> ( a -> m c )
mcompose f g x = ( f x ) `mapply` g - या: mapply (f x) g

चूंकि टाइप डेफिनिशन में एरो ( -> ) राइट-एसोसिएटिव है, हम अंतिम एलिमेंट के कोष्ठकों को छोड़ सकते हैं:

mcompose :: ( a -> m b ) -> ( b -> m c ) -> a -> m c
mcompose f g x = ( f x ) `mapply` जी

हो सकता है कि मोम्मोस के इस संस्करण को पिछले एक की तुलना में समझना आसान है, लेकिन वे एक और एक ही हैं। यह ध्यान देने योग्य है कि x एक प्रकार का है , और परिणाम का प्रकार mc है । हम यहां क्या करते हैं: हम प्रकार mb का मान प्राप्त करने के लिए फ़ंक्शन को x पर लागू करते हैं; तब हम इस प्रकार (प्रकार mb ) और फ़ंक्शन g के mapply पास करते हैं, इस प्रकार हमारे लिए ब्याज के प्रकार mc का मान प्राप्त करते हैं। यह पता चला है कि हमारे लिए कहीं न कहीं mcompose फंक्शन होना अनावश्यक है ; अगर हमारे पास पहले से ही mapply है , तो इसके माध्यम से हम खुद mcompose लिख सकते हैं। और, वास्तव में, मप्पली दो मौलिक मौद्रिक कार्यों में से एक है। इसे आमतौर पर "बाइंड" कहा जाता है और इसे एक प्रतीकात्मक इन्फिक्स ऑपरेटर के रूप में लिखा जाता है >> = :

( >> = ) :: एम ए -> ( ए -> एम बी ) -> एम बी

यह ध्यान देने योग्य है कि मैंने टाइप परिभाषा को थोड़ा बदल दिया: बी के साथ ए और सी के साथ बी को बदल दिया। लेकिन यह महत्वपूर्ण नहीं है, चूंकि ए , बी , सी टाइप चर हैं, वे किसी भी प्रकार के साथ काम करते हैं।

मैं इस बात पर जोर देना चाहूंगा कि >> = ऑपरेटर अत्यधिक सार है। इसका पहला तर्क प्रकार मा का एक मूल्य है, जहां किसी भी प्रकार का कोई भी हो सकता है, और मीटर किसी भी प्रकार का रचनाकार है। दूसरा तर्क फ़ंक्शन a -> mb है , जहां a और b भी किसी भी प्रकार के होते हैं, और m , फिर से, किसी भी प्रकार का एक प्रकार का कंस्ट्रक्टर होता है। अंत में, रिटर्न वैल्यू टाइप mb का है , जहाँ b किसी भी प्रकार का हो सकता है और m किसी भी प्रकार का मोनडिक हो सकता है। (अनुभवी हास्केल प्रोग्रामर के लिए, इस प्रकार की परिभाषाएं दूसरी प्रकृति बन जाती हैं, लेकिन शुरुआती लोगों के लिए यह मुश्किल हो सकता है।) आप IO सनक से पहले परिभाषा को विशेषज्ञ कर सकते हैं, और IO सनक पर एक मोनडिक एप्लिकेशन ऑपरेटर प्राप्त कर सकते हैं:

( >> = ) :: IO a -> ( a -> IO b ) -> IO b

हम जल्द ही देखेंगे कि हास्केल प्रकार प्रणाली आपको विभिन्न प्रकार के भिक्षुओं के लिए जेनेरिक ऑपरेटर = = का उपयोग करने की अनुमति देती है (यह अच्छा है, ठीक है?)।

मान लें कि हमारे पास एक >> = ऑपरेटर है, इसके साथ हम h पाने के लिए f और g को जोड़ सकते हैं:

- मान लीजिए हमें दिया गया है:
एफ :: ए -> एम बी
g :: b -> m c

- एच की परिभाषा:
h :: a -> m c
h x = f x >> = g

हम दूसरे तरीके से h को फिर से लिख सकते हैं:

h = \ x -> f x >> = g

जहां \ x -> ... जैसा कि पहले उल्लेख किया गया है, हास्केल {4} में अनाम कार्यों का पदनाम (इस मामले में, एक तर्क x के साथ ); h के दोनों संस्करणों का मतलब एक ही है। Mcompose का उपयोग करके , हम इस समीकरण को लिख सकते हैं:

h = f `mcompose` g = mcompose f g = \ x -> ( f x >> = g )

यही है, हमारे mcompose को परिभाषित किया गया है

mcompose f g = \ x -> ( f x >> = g )

वास्तव में, हास्केल के पास पहले से ही एक मानक रचना संचालक है > => :

f > => g = \ x -> ( f x >> = g ) के रूप में ही है (f `mcompose` छ) लेकिन कम।

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

अब याद करते हैं कि हमने सामान्य एप्लिकेशन ऑपरेटर को दो तरीकों से रिकॉर्ड किया है:

( $ ) :: ( a -> b ) -> a -> b

और

( > $> ) :: a -> ( a -> b ) -> b

इनमें से कौन सा ऑपरेटर उपयोग करना है यह उस आदेश पर निर्भर करता है जिसमें हम तर्क पारित करना चाहते थे। (सुविधाजनक होने पर उनका उपयोग करने के लिए दोनों ऑपरेटरों को परिभाषित करना बहुत अच्छा है।) हम दो तरीकों से मोनडिक एप्लिकेशन ऑपरेटर भी लिख सकते हैं। पहला तरीका बाइंड ऑपरेटर है = = प्रकार के साथ

( >> = ) :: एम ए -> ( ए -> एम बी ) -> एम बी

जो सामान्य अनुप्रयोग ऑपरेटर > $> के अनुरूप है। रिवर्स ऑर्डर में तर्क देने वाले मोनैडिक एप्लिकेशन ऑपरेटर को तुच्छ रूप से परिभाषित किया जाता है:

( = << ) :: ( a -> m b ) -> m a -> m b
f = << x = x >> = f

आप फ्लिप फ़ंक्शन भी ले सकते हैं, जो दो तर्कों का कार्य लेता है और एक ही फ़ंक्शन देता है, लेकिन तर्कों के विपरीत क्रम के साथ:

फ्लिप :: ( a -> b -> c ) -> ( b -> a -> c )
फ्लिप f = \ x y -> f y x

ऑपरेटर = << इसके माध्यम से निम्नानुसार परिभाषित किया गया है:

( = << ) = फ्लिप ( >> = )

यदि आपकी परिभाषाएँ इस प्रकार संक्षिप्त हैं, तो आपको अतिरिक्त कार्यात्मक स्थिति अंक {5} मिलेंगे।

और फिर से: हम ऑपरेंड के रिवर्स ऑर्डर के लिए एक मोनडिक कंपोजिशन ऑपरेटर को निर्दिष्ट कर सकते हैं:

( > => ) :: ( ए -> एम बी ) -> ( बी -> एम सी ) -> ( ए -> एम सी ) - पहले से मौजूद है

( <= < ) :: ( b -> m c ) -> (( a -> m b ) -> ( a -> m c )
( <= < ) = फ्लिप ( > => )

इसलिए, हमने ऑपरेंड के किसी भी ऑर्डर के लिए मोनैडिक एप्लिकेशन ऑपरेटर्स और कंपोज़िशन को परिभाषित किया, जैसा कि हमने साधारण (नॉन-मॉनेडिक) ऑपरेटर्स के साथ किया था। व्यवहार में, हालांकि, हास्केल प्रोग्रामर >> = ऑपरेटर का सबसे अधिक उपयोग करते हैं (या कम से कम मैं इसका सबसे अधिक उपयोग करता हूं)।

यदि आप यह सब समझते हैं, तो बधाई! सबसे कठिन हिस्सा पीछे है। मुझे उम्मीद है। {6}

एक और मौलिक मौद्रिक ऑपरेशन है जिसके बारे में मैं बात करने जा रहा हूं। बीज के लिए, निम्नलिखित परिदृश्य पर विचार करें। आपको एक नॉनमॉडिक फ़ंक्शन के साथ एक मोनोएडिक फ़ंक्शन को संयोजित करने की आवश्यकता है। दूसरे शब्दों में, आपके पास ये कार्य हैं:

f :: a -> m b - monadic
जी :: बी -> सी - नॉनमेडिक

समस्या इस प्रकार है। आप सामान्य संरचना फ़ंक्शन का उपयोग f और g के लिए नहीं कर सकते, क्योंकि mb b के समान नहीं है। और मोनैडिक रचना भी फिट नहीं होती है - यह टाइप बी -> सी के बारे में कुछ भी नहीं जानता है, इसे एक मोनडिक प्रकार बी -> एमसी की आवश्यकता है । आप क्या करेंगे?

यदि आपके पास पहले निकाला गया फ़ंक्शन था, तो आप इस तरह से दो कार्यों को जोड़ सकते हैं:

एच :: ए -> सी
h = f >> अर्क >> जी

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

h :: a -> m c
h = f [ किसी तरह जी के साथ गठबंधन ]

वैसे, हम जानते हैं कि एक मोनोडिक रचना अच्छी नहीं है, क्योंकि जी में गलत प्रकार है (जिसे b -> mc होना चाहिए)। हालाँकि, यह काम में आएगा यदि हम एक साधारण कार्य को एक एकादश में बदल सकते हैं। ऐसे रूपांतरण करने वाले फ़ंक्शन को functionToMonadicFunction कहा जाता है ।

functionToMonadicFunction :: ( b -> c ) -> ( b -> m c )

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

h :: a -> m c
h = f > => ( functionToMonadicFunction जी )

यह पता चला है कि सभी की जरूरत है functionToMonadicFunction फ़ंक्शन को परिभाषित करना है , और यह बहुत सरल है, क्योंकि पहले से ही नाम (संभवतः भ्रामक) वापसी के साथ एक मौनिक फ़ंक्शन मौजूद है। उसके पास निम्न प्रकार है:

वापसी :: a -> m a

जहाँ कोई भी प्रकार है, और एम किसी भी प्रकार का एक प्रकार का निर्माणकर्ता है। वापसी फ़ंक्शन सामान्य मान को किसी भी monad m के लिए संबंधित मानसिक मान में परिवर्तित करता है, और यह सब करता है। अब हम इसका उपयोग कर रहे हैं।

यदि आपके पास वापस लौटा है , तो functionToMonadicFunction को इसके माध्यम से व्यक्त किया जाता है:

functionToMonadicFunction :: ( a -> b ) -> ( a -> m b )
functionToMonadicFunction f = \ x -> वापसी ( f x )

या, यदि आप शांत रहना चाहते हैं, तो आप कार्यों की संरचना का उपयोग कर सकते हैं:

functionToMonadicFunction :: ( a -> b ) -> ( a -> m b )
functionToMonadicFunction f = वापसी । च

या यहां तक ​​कि:

functionToMonadicFunction :: ( a -> b ) -> ( a -> m b )
functionToMonadicFunction = ( वापसी )

अंतिम उदाहरण में, "अनुभाग" नामक एक अद्भुत हास्केल सुविधा शामिल है। तीनों विकल्प बराबर हैं।

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

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

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

आइए, अपने मोनैडिक फंक्शन f को नॉन-मोनैडिक फंक्शन g के साथ monadic h को जोड़ने के लिए सर्कुलेशन में वापस लाएं।

h = f > => ( रिटर्न जी । )

और यह वापसी के बाद से सही प्रविष्टि है । g एक monadic फ़ंक्शन के लिए g को कनवर्ट करता है।

आखिरकार, यह कहा गया है, आप शायद आश्चर्य करते हैं कि उन सभी को निर्धारित करने से पहले हमें और कितने मौद्रिक संचालन करने होंगे। जैसा कि प्रोफेसर फ़ार्न्सवर्थ कहते थे: "अच्छी खबर!" उनमें से केवल दो हैं! सुविधा के लिए, हमने कुछ और महत्वपूर्ण संचालन नहीं करने के लिए कहा, लेकिन उनमें से केवल = = और वापसी ही होनी चाहिए।

वापसी के साथ एक और अजीबोगरीब पल है। ऐसा कहा जाता है कि रिटर्न प्रकार एक -> मा की तरह दिखता है। जब हम कहते हैं, उदाहरण के लिए, 10 लौटें , तो इस अभिव्यक्ति का प्रकार क्या होगा? यह IO Int , हो सकता है Int, या कुछ अन्य monadic Int हो सकता है । हमें कैसे पता चलेगा कि यहां किस तरह का मोनाड है। आखिरकार, IO Int का मोनैडिक अर्थ समान इंट के समान नहीं है; इसलिए हम केवल सही प्रकार में रुचि नहीं रखते हैं, हम यह समझना चाहते हैं कि यह मान क्या है - 10 लौटें !

हास्केल में, वापसी 10 का अर्थ संदर्भ से निर्धारित होता है। प्रकार चेकर को यह सुनिश्चित करना चाहिए कि फ़ंक्शन सही प्रकारों के साथ तर्क प्राप्त करते हैं, इसलिए यदि रिटर्न 10 को एक फ़ंक्शन से पास किया जाता है जहां IO Int की उम्मीद है, तो वापसी 10 को IO Int के रूप में माना जाएगा। (अन्य मुनियों के लिए भी यही नियम सही है।) दूसरे शब्दों में, रिटर्न 10 का मूल्य इस बात पर निर्भर करता है कि यह किस संदर्भ में प्रयोग किया जाता है। यदि आप चाहें, तो आप स्पष्ट रूप से रिटर्न 10 के प्रकार का उपयोग करके सेट कर सकते हैं, उदाहरण के लिए, एक रिकॉर्ड ( वापसी 10 :: आईओ इंट ), लेकिन यह शायद ही कभी आवश्यक है।

जो कहा गया है उसका संक्षेप में वर्णन करना।

• : «bind» ( >>= ) return .
• Bind- — . , : >=> .
• return . .

?

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

इसलिए, हमने कहा कि आप एक ऐसे अर्क फ़ंक्शन को परिभाषित नहीं कर सकते हैं जो एक सामान्य मूल्य से सामान्य बात करेगा। हालाँकि, अगर हमें दो मोनैडिक कार्यों को एक तिहाई में संयोजित करने की आवश्यकता है, तो किसी भी तरह हमें अभी भी सामान्य मानों को निकालना होगा।

( >=> ) :: ( a -> m b ) -> ( b -> m c ) -> ( a -> m c )
f >=> g = {- - -}

यहाँ दिखाया गया है: फ़ंक्शन एफ टाइप a का मान लेता है और टाइप mb का एक मान मूल्य देता है ; function g टाइप b का मान लेता है और प्रकार mc का मान लौटाता है । और यह, ज़ाहिर है, जैसे कि अंदर कहीं दिखता है, सामान्य अर्थ "अनपैकड" है जो मोनडिक से है। हमने इस बात पर भी चर्चा की कि हम एक वैयक्तिक संरचना को परिभाषित कर सकते हैं > = >> मोनैडिक एप्लिकेशन ( >> = ) के संदर्भ में । फिर से देखिए >> = :

( >>= ) :: m b -> ( b -> m c ) -> m c
mv >>= g

जहां mv प्रकार के कुछ monadic मूल्य है एमबी । और भी - किसी भी बिना निकालने , - कैसे प्रकार का एक मूल्य है ख प्रकार का एक मूल्य के एमबी समारोह को पास करने की, जी ?

सभी मठों का उत्तर अलग है। प्रत्येक मोनाड का अपना "अनपैकिंग" करने का अपना तरीका होता है, जो कि एक दूसरे मॉनाडिक फंक्शन में हमेशा की तरह ट्रांसफर करने के लिए मॉनेडिक का अर्थ है। दूसरे शब्दों में, >> = ऑपरेटर सभी मठों के लिए विशिष्ट है, और इसके कार्यान्वयन में यह छिपा हुआ है कि कैसे मानदिक मूल्य को अनपैक किया और पास किया गया है। प्रत्येक सन्यासी का अपना विवरण भी होता है ।

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

अब जब हम यह सब जान गए हैं, तो चलिए मोनाड टाइप क्लास के बारे में बात करते हैं । बाद में हम कुछ भिक्षुओं के लिए >> = ऑपरेटर की परिभाषा को देखेंगे , और आप सीखेंगे कि वहां कैसे अनपैकिंग की जाती है।

मोनाड टाइप क्लास

>> = - यह मोनैडिक एप्लिकेशन ऑपरेटर है, और रिटर्न - यह सामान्य मूल्य को किसी भी मोनोडिक में परिवर्तित करने का कार्य है। तो मैंने ऊपर कहा। हालांकि, यह शब्दावली सटीक नहीं है, क्योंकि यह भी कहा गया था कि प्रत्येक संन्यासी के पास इन ऑपरेटरों / कार्यों के अपने संस्करण होने चाहिए जो दूसरों के लिए अलग हैं। दूसरी ओर, >> = को कॉल करना और विवरणों को अलग-अलग वापस करना बिल्कुल भी अच्छा नहीं है । हम इस तरह से गंदा चीजें प्राप्त करेंगे:

IO >>= :: IO a -> ( a -> IO b ) -> IO b
IOreturn :: a -> IO a

Maybe >>= :: Maybe a -> ( a -> Maybe b ) -> Maybe b
Maybereturn :: a -> Maybe a

हास्केल में मैंने जो लिखा है, वह सिंटैक्स चेक पास नहीं करेगा। आप पहचानकर्ताओं में वर्णमाला और गैर-अक्षर वर्णों को नहीं मिला सकते हैं, और आप किसी फ़ंक्शन के पहले अक्षर को कैपिटल में नहीं बना सकते हैं।

समस्या को हस्केल भाषा के "प्रकार वर्ग" द्वारा खूबसूरती से हल किया गया है। (याद रखें, मैंने कहा था कि यदि आप पहले से ही टाइप क्लास से परिचित हैं तो मैनुअल आसान हो जाएगा। टाइप की कक्षाओं का ओओपी से कक्षाओं से कोई लेना-देना नहीं है, ये पूरी तरह से अलग चीजें हैं। हास्केल टाइप क्लास कंपाइल-टाइम इंटरफेस की तरह हैं) एक प्रकार का वर्ग यह कहने का एक तरीका है कि विभिन्न प्रकारों के एक समूह के लिए एक ही नाम (या ऑपरेटर) के कार्यों के विभिन्न अवतार हैं। इसलिए, उदाहरण के लिए, Eq प्रकार वर्ग में a = > a -> बूल (जहां सभी एक ही प्रकार है) के साथ == ऑपरेटर होता है । टाइप करना हैएक वर्ग प्रकार के अंतर्गत आता है Eq , उपयुक्त ऑपरेटर इसके लिए मौजूद होना चाहिए == (समानता तुलना)। अंकीय प्रकार Int और Float Eq प्रकारों के वर्ग के होते हैं (हम यह भी कह सकते हैं कि वे Eq वर्ग के उदाहरण हैं ), जिसका अर्थ है कि उनमें से प्रत्येक का अपना सार्थक संचालक == है । हास्केल में, इस प्रकार लिखा गया है:

class Eq a where
( == ) :: a -> a -> Bool

instance Eq Int where
( == ) = intEquals -- intEquals : (Int -> Int -> Bool)

instance Eq Float where
( == ) = floatEquals -- floatEquals : (Float -> Float -> Bool)

माना जाता है कि intEquals - के लिए तुलना समारोह है इंट , और floatEquals के लिए - फ्लोट । (मैंने असमानता ऑपरेटर के बारे में नहीं कहा है; एक ही विचार है।) बस इतना ही। अब हम पूर्णांक और वास्तविक संख्याओं की एक दूसरे से तुलना करने के लिए == ऑपरेटर का उपयोग कर सकते हैं । या किसी भी वस्तु की तुलना करने के लिए, यदि केवल ईक प्रकार वर्ग का एक उपयुक्त उदाहरण होगा । और यह बहुत सुविधाजनक है।इस बीच, ध्यान दें कि == आवश्यकता है कि तुलना की जाने वाली वस्तुओं का प्रकार समान हो; आप, Int , और Float की तुलना नहीं कर सकते ।

हम और आगे बढ़ें।मैं वही दोहराता हूं जो मैंने पहले ही कहा है: हास्केल में सभी मोनडर्स टाइप कंस्ट्रक्टर हैं, और हमने दिखाया है कि सभी मोनड्स >> = ऑपरेटर और रिटर्न फ़ंक्शन का एक स्वतंत्र कार्यान्वयन प्रदान करते हैं । इन दो शोधों से, हम यह निष्कर्ष निकाल सकते हैं कि एक प्रकार का वर्ग है (जिसे आपने इसे सही माना है) मोनाड , जिसे मूल रूप से इस प्रकार परिभाषित किया गया था:

वर्ग मोनाड m जहाँ
( >> = ) :: ma -> ( a -> mb ) -> mb
return :: a - a - ma

द मोनड टाइप क्लास ईक से ज्यादा जटिल नहीं है । केवल दो फ़ंक्शन / ऑपरेटर को परिभाषित करना आवश्यक है - यह इतनी बड़ी बात नहीं है, क्योंकि हम पहले से ही यह जानते हैं। दो कार्यों / ऑपरेटरों के प्रकार समान हैं, जैसा कि हमने ऊपर चर्चा की है। मोनाड

प्रकार वर्ग के साथ विषमता यह है कि यह ईक के समान नहीं है । मोनाड एक "क्लास कंस्ट्रक्टर" है, जिसके लिए इंस्टेंस ( एम द्वारा चिह्नित ) टाइप नहीं हैं, लेकिन टाइप कंस्ट्रक्टर हैं; हमने पहले ही देखा है कि सभी मोनाडर्स टाइप कंस्ट्रक्टर होने चाहिए। यह है कि हम क्लास कंस्ट्रक्टर के उदाहरण को परिभाषित करते हैं (उदाहरण के लिए, शायद मोनाड लिया गया है ):

उदाहरण मोनाड शायद जहाँ
(( = = ) = {- संस्करण (>> =) शायद के लिए -}
वापसी = {- संस्करण वापसी के लिए शायद-}

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

कंस्ट्रक्टरक्लास मोनाड एम जहां
(( = = ) :: ma -> ( a -> mb ) -> mb
return :: a -> ma

कन्स्ट्रक्टरइन्स्टैन्स मोनाड शायद जहाँ
(( = = ) = {- के शायद संस्करण (>> =) ) -}
रिटर्न = {- रिटर्न का शायद संस्करण -}

लेकिन यह बहुत विस्तृत है। आमतौर पर यह समझने के लिए पर्याप्त संदर्भ है कि क्या हो रहा है।

अब एक सरल उदाहरण लेते हैं, और फिर मोनाड प्रकार वर्ग के बारे में बात करते हैं ।

उदाहरण

IO सनद के साथ सबसे सरल कार्यक्रमों में से एक टर्मिनल से पाठ पढ़ता है और इसे वापस प्रिंट करता है (अंत में एक नई पंक्ति के साथ)। स्वाभाविक रूप से, getLine और putStrLn का उपयोग इसके लिए किया जाता है । उनके प्रकारों को याद करें:

getLine :: IO स्ट्रिंग
putStrLn :: स्ट्रिंग -> IO ( )

आप उनके लिए monadic कंपोजिशन ऑपरेटर > => का उपयोग नहीं कर सकते हैं , क्योंकि getLine में एक monadic value का रूप है, न कि एक monadic फंक्शन। लेकिन हम ऑपरेटर को ले सकते हैं >> = :

readAndPrintLine = getLine >> = putStrLn

यहाँ हम getLine monadic मान के लिए putStrLn monadic फ़ंक्शन का एक ( monadic ) अनुप्रयोग कर रहे हैं । जिन "क्रियाओं" के बारे में हमने पहले बात की थी, हम इस तरह से सोच सकते हैं: getLine एक "क्रिया" है, जो टर्मिनल से पाठ की एक पंक्ति को पढ़ता है और इसका "मान" लौटाता है; >> = ऑपरेटर "अनपैक" को मोनडिक मान से दर्ज स्ट्रिंग में डाल देता है , इसे पुट्र्र्लन के पास भेज देता है ; putStrLn, बदले में, इसे टर्मिनल में प्रिंट करता है और कुछ भी नहीं देता है (वास्तव में एक विमुद्रीकृत मूल्य के रूप में खाली () लौटता है )। हम इसे स्पष्ट रूप से लिख सकते हैं:

readAndPrintLine = getLine >>= ( \s -> putStrLn s )

ध्यान दें कि संकेतन (\ s -> putStrLn s) बिल्कुल पुटस्ट्रॉन फ़ंक्शन के समान है, जो नोटेशन (\ x -> cos x) के समान है , जो कि केवल cos के अलावा और कुछ नहीं है । इसलिए हमने यहां कुछ भी महत्वपूर्ण नहीं बदला है। लेकिन यह अधिक स्पष्ट हो जाता है कि कैसे कुछ (पाठ की एक पंक्ति), गेटलाइन से लौटाया जा रहा है , पुटस्ट्रल को पास किया जाता है और टर्मिनल में मुद्रित किया जाता है।

हम इस सरल उदाहरण और श्रृंखला के अगले लेख में इसके बदलावों पर ध्यान देंगे, जैसे ही हम मोनाड वर्ग के अन्य कार्यों का अध्ययन करेंगे ।

सामग्री

भाग 1: मूल बातें
भाग 2: कार्य >> = और वापसी
भाग 3: मोनाद कानून
भाग 4: शायद मोनाड और सूची मोनाड

नोट

{१} मूल में - "रचनाशीलता"।
{३} मूल में - "मेरे हाथ धोते समय मुझे क्षमा करें।" - लेखक की उलझन, जो कहा गया था, से उसका निष्कासन और आत्म-उत्पीड़न को व्यक्त करते हुए एक लगभग अवास्तविक स्थिर अभिव्यक्ति। यहाँ, मुझे लगता है, रूसी वाक्यांश "मैं अपने हाथों को धोता हूं।" शब्दों के करीब यहां अनुचित होगा। अगले पैराग्राफ की शुरुआत में वाक्य है "ठीक है, मैं वापस आ गया हूं।", जिसका अर्थ है कि लेखक अपने हाथों को धोने के बाद वापस आ गया। अर्थ को बनाए रखने के लिए प्रतिस्थापित।
{4} अनाम फ़ंक्शंस का दूसरा नाम: लैम्ब्डा फ़ंक्शंस।
{५} मूल में - "कार्यात्मक शीतलता के लिए अतिरिक्त बिंदु"
{६} मूल में - स्थिर अभिव्यक्ति "यह सब यहाँ से डाउनहिल है"। इसका एक विडंबनापूर्ण अर्थ है, दो विपरीतों को मिलाना: 1. ऊंचाई पर चढ़ना, वंश आसान होगा; 2. आगे यह केवल खराब हो जाएगा।