एक और मोनाद गाइड (भाग 4: शायद मोनाद और सूची मोनाद)

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

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

शायद मोनाद

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

डेटा शायद ए = कुछ नहीं | बस ए

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

डेटा शायद Int = कुछ नहीं | बस int

केवल अब हमें इसे सीधे लिखने की आवश्यकता नहीं है, क्योंकि उपरोक्त सार परिभाषा सभी प्रकारों पर लागू होती है।

प्रकार का मान शायद मौजूद हो या न हो। यदि मान कुछ भी नहीं है , तो यह "जैसे कि नहीं" है, और यदि यह x के कुछ मान के लिए सिर्फ x है , तो यह x का मान है। आप इसे एक कंटेनर के रूप में सोच सकते हैं जिसमें या तो 0 तत्व हैं, या यह एक है। (याद रखें: मैंने एक बार कहा था कि विवादास्पद मूल्यों को कभी-कभी गलती से कंटेनर के रूप में प्रस्तुत किया जाता है। यह मामला है।)

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

f :: a -> शायद b

फ़ंक्शन f एक प्रकार का मान लेता है और या तो कुछ भी नहीं लौटाता है (विफलता का संकेत) या मान Just x , जहाँ x का प्रकार b है । एफ जैसे कार्य शायद मोनाड में काम करेंगे, और दो ऐसे कार्यों की संरचना इस प्रकार है:

f :: a -> शायद b - मान लें कि f को कहीं परिभाषित किया गया है
g :: b -> शायद c - मान जी कहीं परिभाषित है

h :: a -> हो सकता है c - f और g की मोनडिक रचना हो
h = f > => g - याद रखें:> => monadic संरचना का संचालक है

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

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

हम (>> =) कैसे सेट कर सकते हैं और हो सकता है ?

सबसे पहले, हम >> = के लिए परिभाषा रूपरेखा लिखते हैं, टाइप के एक बाएं ऑपरेंड के दो संभावित मामलों को कवर करते हैं हो सकता है :

कुछ नहीं = = f = {- जोड़ने की आवश्यकता है -}
बस x >> = f = {- जोड़ने की आवश्यकता है -}

जहाँ x एक प्रकार का है । परिभाषा के बाईं ओर एक और तरीके से लिखा जा सकता है:

( >> = ) कुछ नहीं f = {- जोड़े जाने की आवश्यकता है -}
( >> = ) ( बस x ) f = {- जोड़ने की आवश्यकता है -}

लेकिन यह बेहतर है अगर ऑपरेटर (>> =) को एक ऑपरेटर के रूप में निर्दिष्ट किया जाता है, और फ़ंक्शन के रूप में नहीं, और हास्केल हमें ऐसा करने की अनुमति देता है।

इस परिभाषा को पूरा करने के लिए, आइए हम इस बारे में सोचें कि हम शायद मोनाड में मोनैडिक रचना से क्या चाहते हैं। चलो हमारे उदाहरणों को f और g के कार्यों के साथ लेते हैं, जो उन्हें मिलाते हैं और फ़ंक्शन प्राप्त करते हैं:

f :: a -> शायद b
g :: b -> शायद c
h :: a -> शायद c
h = f > => जी

यदि हम फ़ंक्शन f के लिए एक तर्क पास करते हैं और यह कुछ भी नहीं लौटाता है (अर्थात यह विफल रहता है), तो फ़ंक्शन h को क्या लौटना चाहिए?

f x = कुछ भी नहीं
h x = ( f > => g ) x = ???

यह स्पष्ट प्रतीत होता है कि यदि fx कुछ भी नहीं देता है, तो h को भी कुछ नहीं लौटाना चाहिए, क्योंकि यदि अभिव्यक्ति का कोई भाग (फ़ंक्शन f ) परिणाम वापस नहीं कर सकता है, तो संपूर्ण अभिव्यक्ति (फ़ंक्शन h ) इसे वापस करने में सक्षम नहीं होगी। एकमात्र विकल्प जब h मान लौटाता है, जब f परिणाम लौटाता है (चलो इसे y कहते हैं), इसे फ़ंक्शन g को पास कर दिया जाएगा, और gy का सही परिणाम भी होगा। यदि f या g विफल रहता है, तो h भी विफल होगा, अर्थात hx की गणना कुछ नहीं होगी।

इसे ध्यान में रखते हुए, h की हमारी परिभाषा से हम प्राप्त करते हैं:

h = f > => जी
h = \ x -> ( f x >> = g ) - समतुल्य (परिभाषा से = =>)
h x = f x >> = g - समकक्ष
- मान लीजिए f x == कुछ भी नहीं
h x = ( कुछ नहीं >> = जी )
= कुछ भी नहीं
- इस तरह से:
कुछ नहीं = = जी = कुछ नहीं

अब हम जानते हैं कि ऑपरेटर (>> =) कुछ भी नहीं तर्क पर प्रतिक्रिया करता है - यह केवल कुछ भी नहीं लौटाता है:

कुछ नहीं = = f = कुछ भी नहीं
बस x >> = f = {- जोड़ने की आवश्यकता है -}

कृपया ध्यान दें कि मैंने g को यहाँ f से बदल दिया है , और यह सही है, क्योंकि फ़ंक्शन के नाम महत्वपूर्ण नहीं हैं। व्यवहार में, हम आम तौर पर फ़ंक्शन नामों से छुटकारा पाते हैं, यदि संभव हो, और उन्हें विशेष ऑपरेटर _ (अंडरस्कोर) के साथ प्रतिस्थापित करें, जैसे:

कुछ नहीं = = _ = कुछ भी नहीं

यह दूसरे समीकरण के साथ नहीं किया जा सकता है, क्योंकि हम अभी भी परिभाषा में फ़ंक्शन च का उपयोग करेंगे।

अब दूसरे रास्ते पर चलते हैं। यदि fx विफल नहीं होता है, तो परिणाम कुछ y के लिए Just y का मूल्य होगा। हमें बस y से y के मूल्य को "अनपैक" करने की आवश्यकता है, जिसे हम तब फंक्शन g में पास करेंगे, और gy पूरे फंक्शन h का परिणाम है:

h = f > => जी
h = \ x -> ( f x >> = g ) - समतुल्य (परिभाषा से = =>)
h x = f x >> = g - समकक्ष
- मान लीजिए f x == बस y
h x = ( बस y >> = g )
= जी वाई

जो हमें परिभाषा का दूसरा भाग देता है:

कुछ नहीं = = f = कुछ भी नहीं
बस x >> = f = f x

ध्यान दें कि मैंने y को x और g को f के साथ बदल दिया है। जब तक आप संगत हैं तब तक चर और फ़ंक्शन नाम मायने नहीं रखते।

यह शायद मोनड के लिए >> = ऑपरेटर की परिभाषा को समाप्त करता है। अब हमें इस सन्यासी के लिए वापसी करने की आवश्यकता है:

वापसी x = ???

एक्स के किसी भी मूल्य के लिए। हमारे पास क्या विकल्प हैं? हम बस इतना ही कह सकते थे

वापसी x = कुछ भी नहीं

किसी भी एक्स के लिए । हालाँकि, अगर हमने ऐसा किया तो हम मोनाद कानूनों का उल्लंघन करेंगे:

वापसी x >> = f == f x
कुछ नहीं >> = f == f x
कुछ नहीं == f x - गलत!

यह मानते हुए कि कम से कम कुछ एफएक्स कुछ भी नहीं हैं (उदाहरण के लिए, मानदंड फ़ंक्शन एफएक्स = जस्ट एक्स पर विचार करें), हमें एक त्रुटि मिलती है। एक और विकल्प है:

रिटर्न एक्स = जस्ट एक्स

और यह मठ के कानूनों को संतुष्ट करता है:

वापसी x >> = f
= ( बस x ) >> = एफ - परिभाषा के अनुसार, शायद मोनाड के लिए वापसी
= एफ x - परिभाषा के अनुसार = = मठ के लिए शायद
- पहले मोनाड कानून का कार्यान्वयन

बस x >> = वापसी
= वापसी x - परिभाषा के अनुसार = = शायद सन्यासी के लिए
= बस x - परिभाषा के अनुसार, शायद मोनड के लिए वापस लौटें
- दूसरे मोनाड कानून का कार्यान्वयन

कुछ नहीं >> = वापस
= कुछ भी नहीं - परिभाषा के द्वारा = शायद मोनद के लिए
- दूसरे मोनाड कानून का कार्यान्वयन

एक बार कानूनों का सम्मान हो जाने के बाद हम इसका विकल्प लेंगे। शायद मोनद की पूरी परिभाषा इस तरह दिखती है:

उदाहरण मोनाद शायद जहाँ
वापसी x = बस x

कुछ नहीं = = f = कुछ भी नहीं
बस x >> = f = f x

वाह! हमने सिर्फ अपना पहला मोनाड बनाया!

बस खुद को बचाने के लिए, हम यह सत्यापित करेंगे कि यह तीसरे विवादास्पद कानून को संतुष्ट करता है, जिसमें कहा गया है:

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

सबसे पहले, मामले के लिए कानून की जाँच करें जब mv = कुछ नहीं:

( कुछ भी नहीं ) = एफ ) >> = जी - बाईं ओर
= कुछ नहीं = = जी - परिभाषा के द्वारा = =
= कुछ भी नहीं - परिभाषा से = =

कुछ नहीं >> = ( \ x -> ( f x >> = g ) ) - दाईं ओर
= कुछ भी नहीं - परिभाषा से = =

खैर, जाँच सफल रही। अब देखते हैं कि यह mv = v के लिए काम करता है या नहीं, जहाँ v कुछ मान है:

( ( बस v ) >> = f ) >> = जी - बाईं ओर
= f v >> = g - परिभाषा के द्वारा = =

( बस v ) >> = ( \ x -> ( f x >> = g ) ) - दाईं ओर
= ( \ x -> ( f x >> = g ) ) v - परिभाषा से = =
= f v >> = g - फ़ंक्शन का सामान्य उपयोग (बीटा कमी)

और सफलतापूर्वक भी। तो कानून का क्रियान्वयन हो रहा है! यह वास्तव में सन्यासी की सही परिभाषा है! और दर्शक पागल हो रहे हैं!

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

च :: इंट -> हो सकता है इंट
f x = यदि x ` mod` 2 == 0 तो कुछ और नहीं बस ( 2 * x )

g :: इंट -> शायद इंट
g x = यदि x ` mod` 3 == 0 तो कुछ नहीं बस ( 3 * x )

एच :: इंट -> शायद इंट
h x = यदि x ` mod` 5 == 0 तो कुछ और नहीं बस ( 5 * x )

हम उन्हें एक फ़ंक्शन में संयोजित करना चाहेंगे, जो क्रम f , g , h में लागू करने का परिणाम है:

k :: Int -> हो सकता है इंट

और यदि तीन कार्यों में से कोई भी विफल रहता है, तो फ़ंक्शन k को कुछ भी नहीं लौटना चाहिए। यह फ़ंक्शन इनपुट संख्या को 30 से गुणा करता है यदि यह पूर्णांक 2, 3 या 5 से विभाज्य नहीं है (और यदि यह विभाज्य है, तो फ़ंक्शन कुछ भी नहीं लौटाता है)।

पिछली सामग्री से, यदि आप इसे अच्छी तरह से समझते हैं, तो यह स्पष्ट होना चाहिए कि आप एक मुद्रीकृत रचना के माध्यम से कश्मीर को निर्दिष्ट कर सकते हैं:

k = f > => g > => ज

या आप >> = ऑपरेटर ले सकते हैं:

k x = f x >> = g >> = h

या शायद आपको क्या पसंद है - सार:

k x = do y <- f x
z <- g y
ज z द

यह सरल है, जो कोई भी कह सकता है। {1: मूल में, निरंतर अभिव्यक्ति "किसी भी तरह से आप इसे टुकड़ा करते हैं", अर्थ में समान। - नोट ट्रांस।}

सामान्य तौर पर, फंक्शन h को बिना मोनाड कंस्ट्रक्शन के पूरी तरह से परिभाषित किया जा सकता है; यह इस तरह दिखेगा:

k x = केस f x
कुछ नहीं -> कुछ नहीं
बस y -> केस g y
कुछ नहीं -> कुछ नहीं
बस z -> h z

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

f11 = f1 > => f2 > => f3 > => f4 > => f5 > => f6 > => f7 > => f8 > => f9 > => f10

या ( >> का उपयोग कर = ):

f11 x = f1 x >> = f2 >> = f3 >> = f4 >> = f5 >> = f6 >> = f7 >> = f8 >> = f9 >> = f10

मठों का उपयोग करते हुए, राक्षसी कार्यों की संरचना साधारण (गैर-राक्षसी) कार्यों की संरचना के समान सरल है।

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

अब चलते हैं अगले संन्यासी की ओर।

मोनाद सूची (सूची)

अगर हो सकता है कि आपको सिर्फ मोनाद ही पसंद आए, तो आपको लिस्ट मोनाद भी पसंद आएगी। ;-) इस मामले में, हम निम्नलिखित परिभाषा को भरेंगे:

उदाहरण मोनाद [ ] जहां
( >> = ) = {- सूचियों के लिए >> = की परिभाषा -}
वापसी = {- सूचियों की वापसी की परिभाषा -}

ध्यान दें कि एक खाली सूची [] का प्रतिनिधित्व करने के लिए , हम एक सूची प्रकार कंस्ट्रक्टर का उपयोग करते हैं। यह एक छोटी हैक है (हास्केल में सूचियों के लिए विशेष सिंटैक्स समर्थन प्रदान किया गया है)। लेकिन कुछ भी नहीं किया जाना है।

सभी संन्यासियों की तरह, पहला काम यह समझना होगा कि इस सन्यासी के काम क्या हैं। एक सूची के लिए, monadic function f कुछ इस तरह दिखता है:

f :: a -> [ b ]

(जहां [बी] का अर्थ है, निश्चित रूप से, "प्रकार बी के तत्वों की एक सूची")। स्मरण करो कि एक राक्षसी कार्य की सामान्यीकृत परिभाषा निम्नानुसार लिखी गई है:

एफ :: ए -> एम बी

कुछ मोनाड मी के लिए , जो एक प्रकार का कंस्ट्रक्टर होना चाहिए। एक सूची एक मोनाड के लिए एक स्पष्ट उम्मीदवार है, क्योंकि "की सूची" एक प्रकार का निर्माता है (भले ही इसका सिंटैक्स हास्केल में हार्ड-वायर्ड है); वैकल्पिक रूप से, हम सूची को स्वयं परिभाषित कर सकते हैं:

data List a = Nil | विपक्ष ( एक सूची )

इसके लिए विमुद्रीकरण के प्रकार इस प्रकार दिखेंगे:

f :: a -> सूची b

लेकिन हम अभी भी मानक सिंटैक्स का पालन करेंगे।

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

एफ :: इंट -> [ इंट ]
g :: इंट -> [ इंट ]

यहाँ, f और g दोनों समान Int मान लेते हैं और कई Int मान लौटाते हैं। लेकिन क्या होगा अगर हम फ़ंक्शन के प्रत्येक परिणाम को लेना चाहते हैं और एप्लिकेशन के परिणामों को एकत्रित करते हुए फ़ंक्शन जी के प्रत्येक परिणाम पर लागू करें? यह बहुत अच्छा होगा अगर यह सीधे कार्य किया जा सकता है, प्रत्येक तत्व को फ़ंक्शन जी और एफ की परिणाम सूचियों से अनपैक किए बिना। और यह सूची में मोनड का उपयोग करके किया जा सकता है।

आइए इन कार्यों के अधिक मूर्त उदाहरणों की ओर बढ़ें:

एफ :: इंट -> [ इंट ]
f x = [ x - 1 , x , x + 1 ]

g :: इंट -> [ इंट ]
g x = [ - x , x ]

हम इन दो कार्यों को कैसे "रचना" करते हैं? एफएक्स एक सूची देता है, और प्रत्येक तत्व के लिए जी लागू करने के लिए, हमें मानचित्र फ़ंक्शन की आवश्यकता है:

f 10 -> [ 9 , 10 , 11 ]
नक्शा g ( f 10 ) -> [ [ - ९ , ९ ] , [ - १० , १० ] , [ - ११ , ११ ]

यह नया परिणाम दिलचस्प है, लेकिन यह f और g की संरचना नहीं हो सकता है, क्योंकि इसमें एक अलग प्रकार ( Int सूचियों की सूची है, न कि केवल एक Int सूची)। हम इसे एक सरल सूची में कॉनकैट फ़ंक्शन के साथ सुचारू कर सकते हैं (जो बस सूचियों को एक में समाहित करता है):

- कॉनसैट प्रकार पर विशेष ध्यान दें: [[a]] -> [a]
कॉनकट ( मानचित्र जी ( एफ 10 ) ) -> [ - 9 , 9 , - 10 , 10 , - 11 , 11 ]

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

                   जी |  -9
            |  ९ ----> |
            |  |  9
            |
        च |  जी |  -10
   10 ----> |  10 ----> |
            |  |  10
            |
            |  जी |  -11
            |  ११ ----> |
                       |  11 

यह स्पष्ट रूप से देखा जाता है कि f और g की संरचना f और g के बीच के सभी पथों का समुच्चय है।

उत्सुकता से, हमने सूची संचालक के लिए संचालक >> = को परिभाषित किया! यह इस तरह सेट है:

- एमवी :: [ए]
- g :: a -> [b]
mv >> = g = concat ( मानचित्र g mv )

जहाँ mv सूची मान में monadic मान है (जो केवल प्रकार के मूल्यों की एक सूची है )। पिछले उदाहरण में, mv f 10 की गणना का परिणाम है। खाली सूची [] के लिए भी परिभाषा काम करती है, क्योंकि किसी फ़ंक्शन को खाली सूची में मैप करने से खाली सूची मिल जाएगी, और खाली सूची के लिए कॉनैट भी हमेशा एक खाली सूची होती है। परिणाम ऑपरेटर की एक बहुत ही सरल परिभाषा है = = ।

[GHC प्रशंसकों के लिए ध्यान दें: मेरा मानना ​​है कि GHC संकलक में >> = ऑपरेटर को अधिक कुशलता से और एक अलग तरीके से कार्यान्वित किया जाता है, हालांकि यह ऐसा ही करता है।]

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

वापसी :: a -> [ b ]
वापसी x = [ x ]

यही है, वापसी एक तत्व से एक सूची बनाता है। जांचें कि क्या इस मामले में मोनाद कानूनों का सम्मान किया जाता है:

- f :: a -> [b]
- x :: a
return x >> = f = concat ( मैप f ( रिटर्न x ) ) - परिभाषा से = =
= समापक ( मानचित्र f [ x ] ) - परिभाषा वापसी द्वारा
= संक्षिप्त रूप [ एफ x ] - परिभाषा मानचित्र द्वारा
= एफ एक्स - परिभाषा के अनुसार, समतल
- पहले मोनाड कानून का कार्यान्वयन

- एमवी :: [ए]
mv >> = return = concat ( मैप रिटर्न mv ) - परिभाषा से = =
= समवर्ती ( मानचित्र ( \ x -> [ x ] ) mv ) - परिभाषा वापसी द्वारा
- दो मामले:
- केस 1: mv == []
= संक्षिप्त ( मानचित्र ( \ x -> [ x ] ) [ ] ) - परिभाषा के अनुसार, एम.वी.
= संक्षिप्त रूप [ ] - परिभाषा मानचित्र द्वारा
= [ ] - परिभाषा समास द्वारा
= mv - परिभाषा mv द्वारा
- केस 2: mv == [v1, v2, ...]
= संक्षिप्त ( मानचित्र ( \ x -> [ x ] ) [ v1 , v2 , ... ] ) - परिभाषा के अनुसार, एम.वी.
= संक्षिप्त रूप [ [ v1 ] , [ v2 ] , ... ] - परिभाषा मानचित्र द्वारा
= [ v1 , v2 , ... ] - परिभाषा समास द्वारा
= mv - परिभाषा mv द्वारा
- दूसरे मोनाड कानून का कार्यान्वयन

वैसे, सन्यासी के लिए दो कानून सिद्ध होते हैं। आप वापसी की अन्य परिभाषाओं की कोशिश कर सकते हैं (जब रिटर्न लौटाते हैं, उदाहरण के लिए, एक विशिष्ट सूची [0, 2, 3] , या जब यह अपने तर्क की अनंत संख्या लौटाता है), और आप देखेंगे कि वे सभी विवादास्पद कानूनों का उल्लंघन करते हैं। यह राक्षसी कानूनों का अभ्यास करने का एक अच्छा तरीका है।

सूची को असली मोनाड कहने से पहले यह तीसरा मौद्रिक कानून साबित होता है। यह कहा जाना चाहिए, यह अधिक कठिन है, लेकिन हम वैसे भी कोशिश करेंगे। अपने कार्य को सरल बनाने के लिए, हम तीसरे मोनडिक कानून के "सुखद" रूप को लेते हैं (जिसे मोनोडिक रचना के माध्यम से परिभाषित किया गया है)। पहले हमें सूचियों की एकादशी रचना की परिभाषा चाहिए:

- तीसरा मोनडिक कानून (सुखद संस्करण):
( f > => g ) > => h = f > => ( g > = = h )
- परिभाषा के अनुसार:
f > => g = \ x -> f x >> = g
- सूची के लिए परिभाषा >> = = लें:
f > => g = \ x -> समतल ( मानचित्र g ( f x ) )
- आप रचना ऑपरेटर (।) के माध्यम से अभिव्यक्ति को फिर से लिख सकते हैं:
f > => g = समतल । नक्शा जी । च

इसके अलावा, मैं कॉनकैट और मानचित्र कार्यों के कई गुणों का उपयोग करूंगा। आपको उन्हें अभी के लिए विश्वास पर लेना होगा; तो मैं उन्हें कैसे दिखाऊंगा:

- समीकरण 1:
map ( f । g ) = map f । नक्शा जी
- समीकरण 2:
नक्शा च । concat = कॉनकट । नक्शा ( नक्शा f )
- समीकरण 3:
समतल । concat = कॉनकट । मानचित्र

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

तो, सबूत के निष्कर्ष, कहा गया है कि सभी को ध्यान में रखते हुए:

( f > => g ) > => एच
= ( संक्षिप्त नाम । मानचित्र जी । एफ ) > => एच - परिभाषा द्वारा = =>
= समास । नक्शा h । ( कॉन्कैट । मैप जी । एफ ) - परिभाषा के द्वारा = =>
= समास । नक्शा h । समतल । नक्शा जी । f - अनावश्यक कोष्ठक हटाएं

f > => ( g > => h )
= f > => ( कॉन्कैट । मैप h । g ) - परिभाषा के द्वारा = =>
= समास । मानचित्र ( concat । मानचित्र h । g ) f - परिभाषा से = =>
= समास । map ( ( concat । map h ) । g ) f बराबर परिवर्तन है
= समास । ( नक्शा ( कोनैट मैप h ) ) । ( नक्शा छ ) । f - समीकरण 1 के अनुसार
= समास । नक्शा ( concat । नक्शा h ) । नक्शा जी । f - अनावश्यक कोष्ठक हटाएं
= समास । मानचित्र नक्शा ( नक्शा h ) । नक्शा जी । f - समीकरण 1 के अनुसार

अब हमें यह दिखाने की आवश्यकता है:

समतल । नक्शा h । concat = कॉनकट । मानचित्र नक्शा ( नक्शा h )

आइए इसे साबित करते हैं।

- स्पष्टता के लिए कोष्ठक जोड़ें:
समतल । ( मैप h । कॉनकट ) = concat । मानचित्र नक्शा ( नक्शा h )
- समीकरण 2 के अनुसार:
समतल । समतल । map ( नक्शा h ) = समतल । मानचित्र नक्शा ( नक्शा h )
- स्पष्टता के लिए कोष्ठक जोड़ें:
( concat । कॉनकट ) । map ( नक्शा h ) = समतल । मानचित्र नक्शा ( नक्शा h )
- समीकरण 3 के अनुसार:
समतल । मानचित्र map ( नक्शा h ) = समतल । मानचित्र नक्शा ( नक्शा h )

और यह अंत है। Fuuuh! वास्तव में, हास्केलिस्ट शायद ही कभी ऐसा करते हैं, लेकिन सबूत दिखाने के लिए आवश्यक है कि कथित मोनाड वास्तव में एक सन्यासी है।

सीमांत नोट: मानचित्र / समापक (समीकरण 1, 2 और 3) के साथ पहचान की व्युत्पत्ति

ट्रेनिंग

पहचान के प्रमाण के साथ आगे बढ़ने से पहले, हमें पहले कई अन्य (गणित कठिन है!) को साबित करने की आवश्यकता है। हम उन्हें सूचीबद्ध करते हैं:

- अभिव्यक्ति 4:
concat ( x: xs ) = x ++ concat xs
- अभिव्यक्ति 5:
concat ( x ++ y ) = concat x ++ concat y
- अभिव्यक्ति 6:
map f ( x ++ y ) = map f x ++ मैप f y

अभिव्यक्ति 4 अवतल की परिभाषा से निम्नानुसार है। एक्सपेरीमेंट 4 का उपयोग करके एक्स पर इंडक्शन द्वारा एक्सप्रेशन 5 आसानी से साबित होता है।

- आधार मामला: x - खाली सूची
concat ( [ ] ++ y ) = concat [ ] ++ concat y
concat y = [ ] ++ concat y - परिभाषा concat []
concat y = concat y -- ++
-- .

-- : x ; x1 - ; xs - .
concat ( ( x1:xs ) ++ y )
= concat ( x1 : ( xs ++ y ) ) -- ++
= x1 ++ concat ( xs ++ y ) -- 4
= x1 ++ concat xs ++ concat y -- inductive hypothesis

concat ( x1:xs ) ++ concat y
= x1 ++ concat xs ++ concat y -- 4
-- , .

6 :

-- : x -
map f ( [ ] ++ y ) = map f [ ] ++ map f y
map f y = [ ] ++ map f y
map f y = map f y
-- .

-- : x - ; x1 - ; xs - .
map f ( x ++ y )
= map f ( ( x1:xs ) ++ y )
= map f ( x1 : ( xs ++ y ) ) -- ++
= f x1 : map f ( xs ++ y ) -- map
= f x1 : ( map f xs ++ map f y ) -- inductive hypothesis
= ( f x1 : map f xs ) ++ map f y -- ++
= map f ( x1:xs ) ++ map f y -- map
= map f x ++ map f y -- x
-- , .

1, 2 3.

1:

map ( f . g ) = map f . map g

- , map :

-- :
map ( f . g ) [ ] = [ ]
( map f . map g ) [ ] = map f ( map g [ ] ) = map f [ ] = [ ]
-- OK

-- : :
map ( f . g ) ( x:xs )
= ( ( f . g ) x ) : ( map ( f . g ) xs ) -- map
= ( f ( g x ) ) : ( map ( f . g ) xs ) -- (.)
( map f . map g ) ( x:xs )
= map f ( map g ( x:xs ) ) -- (.)
= map f ( ( g x ) : ( map g xs ) ) -- map
= ( f ( g x ) ) : ( map f ( map g xs ) ) -- map
= ( f ( g x ) ) : ( ( map f . map g ) xs ) -- (.)
= ( f ( g x ) ) : ( map ( f . g ) xs ) -- inductive hypothesis
-- , .

2:

map f . concat = concat . map ( map f )

:

-- :
( map f . concat ) [ ] = map f ( concat [ ] ) = map f [ ] = [ ]
( concat . map ( map f ) ) [ ] = concat ( map ( map f ) [ ] ) = concat [ ] = [ ]
-- OK

-- :
( map f . concat ) ( x:xs )
= map f ( concat ( x:xs ) ) -- (.)
= map f ( x ++ concat xs ) -- 4
= map f x ++ ( map f ( concat xs ) ) -- 6
= map f x ++ ( ( map f . concat ) xs ) -- (.)
= map f x ++ ( ( concat . map ( map f ) ) xs ) -- inductive hypothesis
= map f x ++ concat ( map ( map f ) xs ) -- (.)

( concat . map ( map f ) ) ( x:xs )
= concat ( map ( map f ) ( x:xs ) ) -- (.)
= concat ( map f x : map ( map f ) xs ) -- map
= map f x ++ concat ( map ( map f ) xs ) -- 4
-- , .

3:

concat . concat = concat . map concat

, :

-- :
( concat . concat ) [ ] = concat ( concat [ ] ) = concat [ ] = [ ]
( concat . map concat ) [ ] = concat ( map concat [ ] ) = concat [ ] = [ ]
--

-- :
( concat . concat ) ( x:xs )
= concat ( concat ( x:xs ) ) -- (.)
= concat ( x ++ concat xs ) -- 4
= concat x ++ concat ( concat xs ) -- 5

( concat . map concat ) ( x:xs )
= concat ( map concat ( x:xs ) ) -- (.)
= concat ( concat x : map concat xs ) -- map
= concat x ++ concat ( map concat xs ) -- 4
= concat x ++ ( concat . map concat ) xs -- (.)
= concat x ++ ( concat . concat ) xs -- inductive hypothesis
= concatx ++ कॉन्कैट ( concat xs ) - परिभाषा (।) के अनुसार
- यह सही है, आवश्यकतानुसार।

मुझे उम्मीद है कि अब आपको कोई संदेह नहीं है कि सूची में शामिल सन्यासी वास्तव में एक सन्यासी है। ;-)

और सबसे दिलचस्प यहाँ सवाल, ज़ाहिर है, यह है: क्या हम कर सकते हैं यह करने के इकाई-सूची के साथ, कि यह monads के बिना मुश्किल हो सकता है? यहाँ आपके लिए एक सरल उदाहरण दिया गया है: 1 और 6 के बीच की सभी संख्याएँ ज्ञात करें, जिनका योग 7 है (संख्याएँ, उदाहरण के लिए, पासा)। सूची का उपयोग करते हुए, समस्या को हल करना सरल है:

- हम <font color = blue> do </ font> -notation:
do n1 <- [ 1 .. 6 ]
n2 <- [ 1 .. 6 ] का उपयोग करते हैं
यदि n1 + n2 == 7 तो वापसी ( n1 , n2 ) अन्य [ ]
- परिणाम: [(१,६), (२,५), (३,४), (४,३), (५,२), (६,१)]

और, यदि आप अधिलेखित नहीं कर सकते कर -notatsii केवल स्पष्ट मिलती है:

[ 1 .. 6 ] >>= \n1 ->
[ 1 .. 6 ] >>= \n2 ->
if n1 + n2 == 7 then return ( n1 , n2 ) else [ ]

यह कैसे काम करता है?आप खुद का खर्च आएगा बैठते हैं और सभी के साथ जुड़े गणना निरीक्षण करने के लिए >> = और वापसी सूची में है, लेकिन यहां उंगलियों पर एक व्याख्या है। तो: [१..६] सूची में मठ में मानद मूल्य है, और एन १ एक समय में उन सभी के माध्यम से चलता है । n2 बिल्कुल समान है। और सभी जोड़े (n1, n2) जिनकी राशि सही है उन्हें वापस कर दिया गया है । यह है कि हम सभी तत्वों पर फ़ंक्शन की गणना करते हैं, जैसे कि वे एक तत्व थे। यह मोनाड सूची का सार है।

यदि आपको हास्केल प्रोग्रामिंग में बहुत ज्ञान है, तो आपने शायद अपने सिर में एक जलपरी को सुना हो। "ऐसा कैसे!" मैं आपका आक्रोश सुनता हूँ। “क्यों नहीं बस सूची समझ का उपयोग करें ); ”और वास्तव में:

[ ( n1 , n2 ) | n1 <- [ 1 .. 6 ] , n2 <- [ 1 .. 6 ] , n1 + n2 == 7 ]

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

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

अगली बार

अगले लेख में, हम उन भिक्षुओं से परिचित होंगे जो आपको त्रुटियों को ट्रैक करने की अनुमति देते हैं।

सामग्री

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