एक और मोनाद गाइड (भाग 3: मोनाद कानून)

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

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

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

आइए एक नज़र डालते हैं पूरी मोनाद टाइप क्लास परिभाषा पर:

वर्ग मोनाड जहां
( >> = ) :: एम ए -> ( ए -> एम बी ) -> एम बी
वापसी :: a -> m a
( >> ) :: एम ए -> एम बी -> एम बी
विफल :: स्ट्रिंग -> एम ए

हम परिचित को देखते हैं: >> = ऑपरेटर और एक ही प्रकार के साथ वापसी फ़ंक्शन, लेकिन उनके अलावा >> ऑपरेटर और असफल फ़ंक्शन भी है। उनका क्या मतलब है?

फेल फंक्शन शुरू में एक त्रुटि की रिपोर्ट करने का एक बहुत ही प्रमुख तरीका है। यह तब कहा जाता है जब >> = ऑपरेटर मिलान त्रुटियों के कारण a -> mb प्रकार के फ़ंक्शन के प्रकार का मान बाँध नहीं सकता है। मैं अब इस तंत्र के विवरण में नहीं जाना चाहता, क्योंकि यह उबाऊ है; यदि आपको इसकी आवश्यकता है तो Haskell वेबसाइट पर प्रलेखन देखें। ज्यादातर मामलों में, असफलता के बारे में चिंता करना आवश्यक नहीं है।

>> ऑपरेटर थोड़ा और दिलचस्प है। उसका यह प्रकार है:

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

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

mv1 >> mv2 = mv1 >> = ( \ _ -> mv2 )

हम यहां देख सकते हैं कि मानदिक मान mv1 से अनपैक किया गया कोई भी मान खारिज कर दिया गया है, और फिर अंतिम मानद मान mv2 लौटा दिया गया है । ऑपरेटर तब उपयोगी होता है जब अनपैक्ड वैल्यू का प्रकार होता है () , यानी यह एक खाली प्रकार है। PutStrLn फ़ंक्शन को एक अच्छा उदाहरण माना जा सकता है:

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

कल्पना करें कि आप दो लाइनों को प्रिंट करना चाहते हैं, एक के बाद एक, प्रत्येक के बाद लाइन टूटने के साथ। आप यह कर सकते हैं:

putStrLn "यह स्ट्रिंग 1 है।" >> putStrLn "यह स्ट्रिंग 2 है।"

और यह काम क्यों करता है? आइए देखें प्रकार:

( putStrLn "This is string 1." ) :: IO ( )
( putStrLn "This is string 2." ) :: IO ( )

यही है, >> ऑपरेटर प्रकार IO () के दो एकात्मक मानों को एक प्रकार के IO () के परिणामस्वरूप मानदिक मान से जोड़ता है। चलो >> ऑपरेटर लेते हैं और इसे हमारे मामले के लिए विशेषज्ञ करते हैं:

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

यदि मी IO है , और a और b हैं () , तो हम प्राप्त करते हैं:

( >> ) :: IO ( ) -> IO ( ) -> IO ( )

लिखकर, हम कह सकते हैं कि, शायद, >> ऑपरेटर एक पंक्ति में दो "क्रियाएं" करता है - एक पंक्ति प्रिंट करना।

अब एक और अधिक जटिल उदाहरण। हमें टर्मिनल से पाठ की एक पंक्ति को पढ़ने और इसे दो बार प्रिंट करने की आवश्यकता है। हम इसे इस तरह से कर सकते हैं:

readAndPrintLineTwice :: IO ( )
readAndPrintLineTwice = getLine >> = ( \ s -> ( putStrLn s >> putStrLn s )

ऑपरेटरों की प्राथमिकताओं के कारण, रिकॉर्ड को कोष्ठक के बिना छोड़ा जा सकता है:

readAndPrintLineTwice :: IO ( )
readAndPrintLineTwice = getLine >> = \ s -> putStrLn s >> putStrLn s

तो इसका क्या मतलब है? getLine - monadic value ("कार्रवाई"), जो टर्मिनल से पाठ की एक पंक्ति पढ़ती है। >> = ऑपरेटर "एक मोनडिक मूल्य से इस" स्ट्रिंग को अनपैक करता है और इसे s नाम से जोड़ता है (क्योंकि \ s -> putStrLn s >> putStrLn s एक मोनैडिक फ़ंक्शन है, >> = ऑपरेटर का दूसरा तर्क)। फिर s नामक लाइन का उपयोग monadic value putStrLn s >> putStrLn s द्वारा किया जाता है, जो इसे उत्तराधिकार में दो बार प्रिंट करता है।

यदि आप जो कहते हैं वह रहस्यपूर्ण लगता है, तो यह आपकी गलती नहीं है। यहाँ गहराई में कुछ अजीब हो रहा है, लेकिन जब तक मैंने राज्य के मठ के बारे में बात नहीं की, मैं इसे नहीं समझा सकता। लेकिन अब आपको पता लगाने में सक्षम होना चाहिए कि क्या हो रहा है, भले ही आप अभी भी पूरी तरह से समझ नहीं पा रहे हों कि यह कैसे होता है।

अभी मैं थोड़ा पीछे जा रहा हूं और मोनाद कानूनों को देखता हूं। वे >> = ऑपरेटर और प्रत्येक विशेष मोनड के लिए रिटर्न फ़ंक्शन का उपयोग करने में एक बड़ी भूमिका निभाते हैं। उसके बाद हम और अधिक व्यावहारिक सामग्रियों की ओर रुख करेंगे।

तीन कानूनवाद के

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

>> = ऑपरेटर और रिटर्न फ़ंक्शन किसी विशेष मोनाड के लिए मान्य होने के लिए, उनके पास उस मोनाड के लिए सही प्रकार होना चाहिए। इसलिए, उदाहरण के लिए, परिभाषाएँ = = और शायद मोनड के लिए वापसी इसके प्रकार में शामिल हैं:

( >> = ) :: शायद a -> ( a -> शायद b ) -> शायद b
वापसी :: a -> शायद a

और भिक्षुओं के लिए, IO प्रकार IO होते हैं:

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

हालांकि, यह पर्याप्त नहीं है। इन कार्यों / संचालकों को तीन "मोनड कानूनों" को पूरा करना भी आवश्यक है। मोनाड कानून वास्तव में बहुत सरल हैं; वे यह सुनिश्चित करने के लिए डिज़ाइन किए गए हैं कि मोनैडिक रचना अनुमानित रूप से काम करती है। पहले मैं आपको मोनाद कानूनों का एक "अच्छा" संस्करण दूंगा, और फिर मैं (बदसूरत) रास्ता दिखाऊंगा, जैसा कि वे आमतौर पर वर्णित हैं। (मुझे धन्यवाद कहें: "अच्छा" विकल्प समझने में बहुत आसान है।)

अच्छा संस्करण है

यहां मोनैडिक रचना के संदर्भ में व्यक्त किए गए तीन विवादास्पद कानूनों की एक अच्छी परिभाषा है (याद रखें कि ऑपरेटर (> =>) कार्यों की संरचना का एक राक्षसी ऑपरेटर है):

१ । वापसी > => एफ == एफ
२ । f > => वापसी == f
३ । ( f > => g ) > => h == f > => ( g > = = h )

ये कानून हमें क्या बता रहे हैं?

कानून 1 और 2 कहते हैं कि क्या वापसी होनी चाहिए: यह कार्यों की मोनैडिक संरचना के लिए इकाई (तटस्थ तत्व) है (पहला नियम बताता है कि वापसी बाईं इकाई है, और दूसरी यह कि दाएं)। दूसरे शब्दों में, monadic function f और लौटने (किसी भी क्रम में) की रचना करने से फंक्शन f वापस आ जाता है । एनालॉग्स को 0 माना जा सकता है - पूर्णांक जोड़ने के कार्य के लिए एक तटस्थ तत्व, और 1 - पूर्णांक गुणन फ़ंक्शन के लिए एक तटस्थ तत्व; प्रत्येक मामले में, संबंधित फ़ंक्शन का उपयोग करके सामान्य मूल्य से जुड़ा तटस्थ तत्व बस इस मान को वापस कर देगा।

नियम 3 में कहा गया है कि रचना का मौद्रिक कार्य साहचर्य है: जब हम तीन मानस संबंधी कार्यों ( f , g , h ) को संयोजित करना चाहते हैं, तो इससे कोई फर्क नहीं पड़ता कि हम पहले कौन से दो को जोड़ते हैं। यह इस तथ्य के अनुरूप है कि पूर्णांकों पर लागू होने पर जोड़ और गुणन भी सहयोगी होते हैं।

क्या ये कानून आपको परिचित नहीं लगते हैं? आइए हम संबंधित "कानूनों" पर एक नज़र डालें, जो रचना के सामान्य कार्य से संतुष्ट हैं:

१ । आईडी। च == च
२ । च । आईडी == एफ
३ । ( f । g ) ज == च । ( जी । एच । )

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

प्रोग्रामर के दृष्टिकोण से इन कानूनों का क्या मतलब है? चूँकि हम चाहते हैं कि हमारे संन्यासी बुद्धिमानी से व्यवहार करें, हमारी वापसी की परिभाषाएँ और >> = इन कानूनों को पूरा करना चाहिए। हम जल्द ही सीखेंगे कि कैसे >> = की परिभाषा को सत्यापित करें और वापस लौटें । [ध्यान दें कि >>>> ऑपरेटर के रूप में मोनैडिक कानूनों को व्यक्त किया जाता है, न कि >> = ऑपरेटर के रूप में, लेकिन हम संस्करण का उपयोग करते हुए देखेंगे = , यह समकक्ष है।]

हालांकि , एक पकड़ है: हास्केल मोनाड कानूनों की जांच नहीं करता है ! जाँच की एकमात्र बात यह है कि वापसी और >> = परिभाषा प्रकार सही हैं। कानून लागू हो रहे हैं या नहीं, प्रोग्रामर को जांच करनी चाहिए।

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

बदसूरत संस्करण

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

>> = ऑपरेटर और रिटर्न फ़ंक्शन के संदर्भ में, मोनड कानून इस तरह दिखते हैं:

१ । वापसी x >> = f == f x
२ । mv >> = वापसी == mv
३ । ( mv >> = f ) >> = g == mv >> = ( \ x -> ( f x >> = g ) )

जहां विभिन्न प्रकार के मूल्य हैं:

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

कुछ प्रकारों के लिए ए , बी , सी और कुछ प्रकार के मोनाड एम ।

एक अच्छे संस्करण से मोनाद कानूनों के एक बदसूरत संस्करण को प्राप्त करना

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

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

नियम 1:

वापसी > => एफ == एफ
\ x -> ( वापसी x >> = f ) == \ x -> f x
वापसी x >> = f == f x - QED ("जैसा साबित करने के लिए आवश्यक है")

ध्यान दें कि \ x -> fx केवल f के समान है।

नियम 2:

f> => वापसी == f
\ x -> (fx >> = वापसी) == \ x -> fx
fx >> = वापसी == fx
let mv == fx
mv >> = वापसी == mv - QED

नियम 3:

( f > => g ) > => h == f > => ( g > = = h )
\ x -> ( ( f > => g ) x >> = h ) == \ x -> ( f x >> = = ( g > = = h ) )
( f > = = g ) x >> = h == f x >> = ( g > = = h )
(( y y -> ( f y >> = g ) ) x >> = h == f x >> = ( \ y -> ( g y >> = h ) )
- गणना (\ y -> (f y >> = g)) x हमें प्राप्त होता है: (f x >> = g)
( f x >> = g ) >> = h == f x >> = ( \ y -> ( g y >> = h ) )
- mv = f x करें, फिर:
( mv >> = g ) >> = h == mv >> = ( \ y -> ( g y >> = h ) )
- g से f, h को g से बदलें:
( mv >> = f ) >> = g == mv >> = ( \ y -> ( f y >> = g ) )
- y को सही अभिव्यक्ति में x से बदलें और प्राप्त करें:
( mv >> = f ) >> = g == mv >> = ( \ x -> ( f x >> = g ) )

गणना चरण (\ y -> (fy >> = g)) x में, हम बस पूरे फ़ंक्शन ( \ y -> ... ) को तर्क x पर लागू करते हैं ; इस स्थिति में, y को फ़ंक्शन बॉडी में वेरिएबल x द्वारा बदल दिया जाता है (यह दीर्घवृत्त (...) द्वारा इंगित किया जाता है), और फ़ंक्शन बॉडी को परिणाम के रूप में लौटाया जाता है। लिंगो कार्यात्मक प्रोग्रामिंग भाषा में, इस ऑपरेशन को बीटा कमी कहा जाता है। {1: इस मामले में, हम गणित के एक खंड के बारे में बात कर रहे हैं, जिसे लैम्ब्डा कैलकुलस कहा जाता है, जो वर्णन करता है, बीटा कमी।} बीटा कमी कार्यों की गणना करने का मुख्य तरीका है। अंतिम चरण, जहां y को x से बदल दिया गया है, सही है क्योंकि निम्नलिखित दो कार्य सही हैं:

\ x -> f x
\ y -> च y

- यह एक और एक ही है (औपचारिक तर्क का नाम कोई फर्क नहीं पड़ता)। लिंगो कार्यात्मक भाषा में, हम कहेंगे कि दो कार्य अल्फा समतुल्य हैं । आप अन्य चरणों को समझ गए होंगे।

क्या विचार है?

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

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

करो- अमूर्त

याद रखें रीडऑपप्रिंटलाइनवाइस फ़ंक्शन को ऊपर परिभाषित किया गया है:

readAndPrintLineTwice :: IO ( )
readAndPrintLineTwice = getLine >> = \ s -> putStrLn s >> putStrLn s

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

इस सिंटैक्टिक शुगर का आधार यह है कि मोनाडिक कोड में बड़ी संख्या में ऑपरेशन दो रूपों में लिखे गए हैं:

- ऑनलाइन फॉर्म।
- एमवी :: एम ए
- f :: a -> m b

mv >> = \ x -> mf x

- फॉर्म।
- एमवी :: एम ए
- एमवी 2 :: एम बी

mv >> mv2

इन दोनों रूपों को पठनीय बनाने के इरादे से नोटेशन तैयार किया गया था। यह do कीवर्ड से शुरू होता है, इसके बाद कुछ मोनैडिक ऑपरेशन होते हैं। तो हमारे ये दो उदाहरण do -notation में लिखे जाएंगे:

- फॉर्म, डू-नोटेशन।
do v <- mv
एफ वी

- फॉर्म 2, डू-नोटेशन।
एम.वी.
mv2

फॉर्म 1 में, पहली पंक्ति का मतलब है कि हम एक मानदार मान mv और "अनपैक" लेते हैं, इसे एक नियमित v में बुलाया जाता है। दूसरी पंक्ति सिर्फ v से f की गणना कर रही है। स्ट्रिंग fv का परिणाम संपूर्ण अभिव्यक्ति का परिणाम है।

फॉर्म 2 में, पहली पंक्ति में मौद्रिक मान ("एक्शन") mv "निष्पादित" होता है। दूसरी पंक्ति "अन्य क्रियात्मक मूल्य" (कार्रवाई) " mv2 " चलाता है । इस प्रकार, हमारे पास एक संकेतन है जो mv और mv2 को एक अनुक्रम में बदलता है , जैसा कि >> ऑपरेटर करता है।

हास्केल कंपाइलर फॉर्म 1 और फॉर्म 2 के लिए एक सुविधाजनक डू- नोटेशन को धर्मान्तरित करता है। यह सिर्फ एक सिंटैक्स रूपांतरण है, और दोनों प्रविष्टियों का अर्थ समान है। इसके अलावा, दोनों रूपों को प्रत्येक संकेतन की एक अभिव्यक्ति में मिलाया जा सकता है। एक उदाहरण:

- एमवी :: एम ए
- v1 :: ए
- f :: a -> m b
- वी 2 :: बी
- एमवी 3 :: एम सी

करना
v1 <- एम.वी.
v2 <- f v1
mv3
वापसी v2

यह बिल्कुल वैसा ही है:

mv >> = ( \ v1 ->
( f v1 >> = ( \ v2 ->)
( mv3 >>
( वापसी v2 ) ) ) ) ))

या बिना स्कोकबोक:

mv >> = \ v1 ->
f v1 >> = \ v2 ->
mv3 >> वापसी v2

आप कल्पना कर सकते हैं कि जब उन्मादी भाव बढ़ते हैं, तो डू -फॉर्म पढ़ने में उतना ही आसान रहता है, जबकि बिना किए फॉर्म (जिसे "सुगंधित" भी कहा जाता है) अक्सर अपठनीय हो जाता है। यही कारण है कि अमूर्त मौजूद है। यह महान है कि सभी साधुओं के लिए सार काम करता है, केवल एक नहीं।

इसके अलावा, आप एक अभिव्यक्ति में डू-नोटेशन और शुगरलेस नोटेशन को मिला सकते हैं। इस तरह:

करना v1 <- एम.वी.
v2 <- f v1
mv3 >> वापसी v2

यह कभी-कभी उपयोगी होता है, लेकिन अक्सर खराब कोड पठनीयता का कारण बन सकता है।

आइए देखते हैं कि हमारे पिछले उदाहरणों को कैसे करना होगा।

- लाइन पढ़ें, फिर प्रिंट करें।
readAndPrintLine :: IO ( )
readAndPrintLine =
करना
लाइन <- getLine
putStrLn लाइन

- हम दो लाइनों को प्रिंट करते हैं, एक के बाद एक।
- कोई फ़ंक्शन नहीं।
करना
putStrLn "यह स्ट्रिंग 1 है।"
putStrLn "यह स्ट्रिंग 2 है।"

- लाइन पढ़ें और दो बार प्रिंट करें।
readAndPrintLineTwice :: IO ( )
readAndPrintLineTwice =
करना
लाइन <- getLine
putStrLn लाइन
putStrLn लाइन

यहां, कोड को टू-नोटेशन के लिए धन्यवाद पढ़ना बहुत आसान है। दिलचस्प रूप से, इसका एक अतिरिक्त लाभ (या नुकसान है, जिसके आधार पर आप विचार करते हैं): हास्केल में कोड अनिवार्य दिखता है! यदि हम ऊपर से नीचे तक कोड पढ़ते हैं, तो यह एक अनिवार्य भाषा की तरह दिखता है, जो तीर को असाइन करने के बजाय <- । मान लें कि readAndPrintLine को निम्नानुसार वर्णित किया जा सकता है: “जिस लाइन को हम लाइन चर में रखते हैं, उसे पढ़ने के लिए गेटलाइन को कॉल करें; तब हम इस चर को प्रिंट करने के लिए पुस्टर्न कहते हैं। "यह निश्चित रूप से ऐसा नहीं है जो वास्तव में होता है (उदाहरण के लिए, रेखा चर नहीं है), लेकिन आप इसे इस तरह से पढ़ सकते हैं। बहुत सारे कोड जो बहुत सारे इनपुट और आउटपुट करते हैं, के लिए do- abstract लिखना बहुत ही सुविधाजनक तरीका है।

नोटेशन के अन्य उपयोगी गुण हैं। उदाहरण के लिए, आप do -notations के शरीर में लेट-एक्सप्रेशंस और केस-एक्सप्रेशन एम्बेड कर सकते हैं, जो अक्सर सुविधाजनक होता है। मैं विवरण में नहीं जाऊंगा क्योंकि यह एक दिनचर्या है - इस बिंदु का पता लगाने के लिए किसी अन्य हास्केल ट्यूटोरियल को लें।

अगली बार

अगले लेख में, मैं शायद मोनड्स के बारे में बात करना शुरू कर दूंगा, हो सकता है कि शुरुआत (गणना के लिए मोनाद जिसमें कोई त्रुटि हो सकती है) और सूची के साथ समाप्त होता है मोनाड (कई परिणामों के साथ गणना के लिए)।

सामग्री

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