मोनाड (कार्यात्मक प्रोग्रामिंग)

For the concept in category theory, see Monad (category theory).

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

सिंहावलोकन

एक सन्यासी के लिए m, प्रकार का मान m a प्रकार के मान तक पहुंच का प्रतिनिधित्व करता है a मोनाड के संदर्भ में। -सी। ए मैककैन

अधिक सटीक रूप से, एक सन्यासी का उपयोग किया जा सकता है जहां परिदृश्य के लिए विशिष्ट कारणों से अप्रतिबंधित पहुंच अनुपयुक्त है। शायद मोनड के मामले में, ऐसा इसलिए है क्योंकि मूल्य मौजूद नहीं हो सकता है। आईओ मोनाड के मामले में, ऐसा इसलिए है क्योंकि मूल्य अभी तक ज्ञात नहीं हो सकता है, जैसे कि जब मोनाड उपयोगकर्ता इनपुट का प्रतिनिधित्व करता है जो केवल एक संकेत प्रदर्शित होने के बाद प्रदान किया जाएगा। सभी मामलों में जिन परिदृश्यों में पहुँच समझ में आती है, उन्हें मोनाड के लिए परिभाषित बाइंड ऑपरेशन द्वारा कैप्चर किया जाता है; हो सकता है कि मोनाड के लिए एक मान केवल मौजूद होने पर ही बाध्य होता है, और IO मोनाड के लिए एक मान केवल अनुक्रम में पिछले संचालन के बाद ही बाध्य होता है।

एक प्रकार के कन्स्ट्रक्टर एम और दो परिचालनों को परिभाषित करके एक मोनड बनाया जा सकता है:

• return :: a -> M a (अक्सर इकाई भी कहा जाता है), जो प्रकार का मान प्राप्त करता है a और इसे प्रकार के एक मोनडिक मूल्य में लपेटता है m a, और

• bind :: (M a) -> (a -> M b) -> (M b) (आमतौर पर के रूप में दर्शाया गया है >>=), जो एक समारोह प्राप्त करता है f ओवर टाइप a और मठवासी मूल्यों को बदल सकते हैं m a आवेदन करने वाले f अलिखित मूल्य के लिए a, एक मोनैडिक मान लौटा रहा है M b.

(एक वैकल्पिक लेकिन #muIsJoin|§ समतुल्य निर्माण का उपयोग कर join के बजाय कार्य करें bind ऑपरेटर बाद के खंड में पाया जा सकता है§ Derivation from functors.)

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

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

एक उदाहरण: शायद

Further information: Option type

एक सन्यासी का एक उदाहरण है Maybe प्रकार। अपरिभाषित अशक्त परिणाम एक विशेष दर्द बिंदु है जिससे निपटने के लिए कई प्रक्रियात्मक भाषाएं विशिष्ट उपकरण प्रदान नहीं करती हैं, जिसके लिए अपरिभाषित मानों को संभालने के लिए प्रत्येक ऑपरेशन में अमान्य मानों के परीक्षण के लिए अशक्त वस्तु पैटर्न या जांच की आवश्यकता होती है। यह बग का कारण बनता है और मजबूत सॉफ़्टवेयर बनाने में कठिन बनाता है जो त्रुटियों को अच्छी तरह से संभालता है। Maybe e> प्रकार प्रोग्रामर को परिणाम के दो राज्यों को स्पष्ट रूप से परिभाषित करके इन संभावित अपरिभाषित परिणामों से निपटने के लिए मजबूर करता है: Just ⌑result⌑, या Nothing. उदाहरण के लिए प्रोग्रामर एक पार्सर का निर्माण कर रहा हो सकता है, जो एक मध्यवर्ती परिणाम लौटाता है, या फिर एक ऐसी स्थिति का संकेत देता है जिसे पार्सर ने पता लगाया है, और जिसे प्रोग्रामर को भी संभालना चाहिए। शीर्ष पर थोड़े अतिरिक्त कार्यात्मक मसाले के साथ, यह Maybe प्रकार पूरी तरह से फीचर्ड मोनाड में बदल जाता है। अधिकांश भाषाओं में, शायद मोनड को एक विकल्प प्रकार के रूप में भी जाना जाता है, जो कि केवल एक प्रकार है जो यह दर्शाता है कि इसमें कोई मूल्य है या नहीं। आमतौर पर उन्हें किसी प्रकार के प्रगणित प्रकार के रूप में व्यक्त किया जाता है। इस जंग के उदाहरण में हम इसे कहेंगे Maybe<T> और इस प्रकार के वेरिएंट या तो सामान्य प्रकार का मान हो सकते हैं T, या खाली संस्करण: Nothing.

<वाक्यविन्यास प्रकाश लैंग = जंग> // <टी> एक सामान्य प्रकार टी का प्रतिनिधित्व करता है एनम शायद <टी> {

   बस टी),
   कुछ नहीं,

} </वाक्यविन्यास हाइलाइट>

Maybe<T> एक रैपिंग प्रकार के रूप में भी समझा जा सकता है, और यही वह जगह है जहां इसका कनेक्शन मोनैड से आता है। भाषाओं में किसी न किसी रूप में Maybe प्रकार, ऐसे कार्य हैं जो उनके उपयोग में सहायता करते हैं जैसे कि एक दूसरे के साथ मोनडिक कार्यों की रचना करना और यदि कोई परीक्षण करना Maybe एक मान होता है।

निम्नलिखित हार्ड-कोडेड उदाहरण में, a Maybe प्रकार का उपयोग उन कार्यों के परिणाम के रूप में किया जाता है जो विफल हो सकते हैं, इस मामले में यदि विभाजन-दर-शून्य होता है तो प्रकार कुछ भी वापस नहीं करता है।

एफएन डिवाइड (एक्स: दशमलव, वाई: दशमलव) -> शायद <दशमलव> {
    अगर y == 0 {वापसी कुछ नहीं}
    और {वापसी बस (एक्स / वाई)}
}
// डिवाइड (1.0, 4.0) -> रिटर्न जस्ट (0.25)
// डिवाइड (3.0, 0.0) -> कुछ भी नहीं लौटाता

यह जांचने का एक तरीका है कि a Maybe उपयोग करने के लिए एक मूल्य है if कथन। <वाक्यविन्यास लैंग = जंग>

चलो m_x = विभाजित (3.14, 0.0); // ऊपर विभाजित कार्य देखें // if स्टेटमेंट m_x से x निकालता है अगर m_x शायद का जस्ट वेरिएंट है अगर चलो बस (एक्स) = एम_एक्स {

   प्रिंट! (उत्तर: x)

} और कुछ {

   प्रिंट! (विभाजन विफल, शून्य त्रुटि से विभाजित करें...)

}

</syntaxhighlight>अन्य भाषाओं में पैटर्न मिलान

 हो सकता है
चलो परिणाम = विभाजित (3.0, 2.0);
मैच परिणाम {
    बस (एक्स) => प्रिंट! (उत्तर: एक्स),
    कुछ नहीं => प्रिंट! (विभाजन विफल, हम उन्हें अगली बार प्राप्त करेंगे।),
}

मोनाड वापस आने वाले कार्यों की रचना कर सकते हैं Maybe साथ में। ऐसा करने के लिए एक ठोस उदाहरण हो सकता है कि एक समारोह में शामिल हो Maybeएस और वापसी ए Maybe जैसे कि:

<वाक्यविन्यास प्रकाश लैंग = जंग> fn श्रंखला_विभाजन (शायद_x: शायद <दशमलव>, हो सकता है_य: शायद <दशमलव>) -> शायद <दशमलव> {

   मैच (शायद_x, शायद_y) {
       (सिर्फ (x), बस (y)) => {// यदि दोनों इनपुट जस्ट हैं, तो शून्य से विभाजन की जांच करें और तदनुसार विभाजित करें
           अगर y == 0 {वापसी कुछ नहीं}
           और {वापसी बस (एक्स / वाई)}
       },
       _ => रिटर्न नथिंग // अन्यथा रिटर्न नथिंग
   }

} श्रंखला_विभाजन (श्रृंखला_विभाजन (बस (2.0), बस (0.0)), बस (1.0)); // अंदर की श्रंखला_विभाजन विफल हो जाती है, बाहर की श्रंखला_विभाजन कुछ भी नहीं लौटाता है </वाक्यविन्यास हाइलाइट>

इस ठोस उदाहरण में मेब्स को लेने के लिए कार्यों को फिर से लिखने के लिए बहुत सारे बॉयलरप्लेट की आवश्यकता होती है (उन सभी को देखें Just भाव!)। इसके बजाय, हम बाइंड ऑपरेटर नामक किसी चीज़ का उपयोग कर सकते हैं। (मानचित्र , फ्लैटमैप , या शोव के रूप में भी जाना जाता है). यह ऑपरेशन एक मोनाड और एक फ़ंक्शन लेता है जो एक मोनाड लौटाता है और पारित मोनाड के आंतरिक मूल्य पर फ़ंक्शन चलाता है, फ़ंक्शन से मोनाड को वापस करता है। <वाक्यविन्यास लैंग = जंग> // जंग का उदाहरण .map का उपयोग करना। हो सकता है_x दो कार्यों के माध्यम से पारित किया गया है जो क्रमशः <दशमलव> और शायद <स्ट्रिंग> लौटाते हैं। // जैसा कि सामान्य फ़ंक्शन संरचना के साथ होता है, फ़ंक्शन के इनपुट और आउटपुट एक-दूसरे को खिलाते हैं, लिपटे प्रकारों से मेल खाना चाहिए। (अर्थात Add_one फ़ंक्शन को एक संभावित <दशमलव> वापस करना चाहिए, जिसे फिर दशमलव_to_string फ़ंक्शन के लिए एक दशमलव में अलिखित किया जा सकता है) चलो हो सकता है_x: हो सकता है <दशमलव> = बस (1.0) let might_result = might_x.map(|x| add_one(x)).map(|x| दशमलव_to_string(x)) </syntaxhighlight>हास्केल में, एक ऑपरेटर बाइंड है, या (>>=) जो इस मोनैडिक रचना को फ़ंक्शन रचना के समान अधिक सुरुचिपूर्ण रूप में अनुमति देता है। <वाक्यविन्यास लैंग = हैकेल> आधा :: इंट -> शायद इंट आधा एक्स

 | सम x = बस (x `div` 2)
 | विषम एक्स = कुछ नहीं
- यह कोड x को दो बार आधा करता है। यदि x 4 का गुणज नहीं है तो यह कुछ नहीं का मूल्यांकन करता है

आधा x >> = आधा </वाक्यविन्यास हाइलाइट>

साथ >>= उपलब्ध, chainable_division बेनामी फ़ंक्शन (लैम्ब्डा में) की सहायता से अधिक संक्षेप में व्यक्त किया जा सकता है। नीचे दिए गए व्यंजक में ध्यान दें कि कैसे दो नेस्टेड लैम्बडा पास किए गए रैप्ड वैल्यू पर काम करते हैं Maybe बाइंड ऑपरेटर का उपयोग कर मोनाड। <वाक्यविन्यास लैंग = हैकेल>

श्रंखला_विभाजन (एमएक्स, मेरा) = एमएक्स >> = ( λx -> मेरी >> = (λy -> बस (एक्स / वाई)))

</वाक्यविन्यास हाइलाइट>

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

मोनैडिक टाइप

प्रकार (Maybe)

यूनिट ऑपरेशन

एक प्रकार कनवर्टर (Just(x))

बाइंड ऑपरेशन

मोनैडिक कार्यों के लिए एक संयोजक ( >>= या .map())

एक सन्यासी बनाने के लिए ये 3 चीजें आवश्यक हैं। अन्य सन्यासी विभिन्न तार्किक प्रक्रियाओं को मूर्त रूप दे सकते हैं, और कुछ में अतिरिक्त गुण हो सकते हैं, लेकिन उन सभी में ये तीन समान घटक होंगे।

परिभाषा

कार्यात्मक प्रोग्रामिंग में एक मोनाड के लिए अधिक सामान्य परिभाषा, जिसका उपयोग उपरोक्त उदाहरण में किया गया है, वास्तव में श्रेणी सिद्धांत की मानक परिभाषा के बजाय क्लेस्ली ट्रिपल ⟨T, η, μ⟩ पर आधारित है। हालाँकि, दो निर्माण गणितीय रूप से समतुल्य हैं, इसलिए या तो परिभाषा एक वैध सन्यासी उत्पन्न करेगी। किसी भी अच्छी तरह से परिभाषित, बुनियादी प्रकार को देखते हुए T, U, एक सन्यासी में तीन भाग होते हैं:

• एक प्रकार का कंस्ट्रक्टर M यह एक मठवासी प्रकार बनाता है M T
• एक प्रकार का रूपांतरण, जिसे अक्सर इकाई या वापसी कहा जाता है, जो किसी वस्तु को एम्बेड करता है x मोनाड में:
  unit : T → M T
• एक संयोजक, जिसे आमतौर पर बाइंड कहा जाता है (जैसा कि बाध्य चर में होता है) और एक इंफिक्स नोटेशन#Usage के साथ दर्शाया जाता है >>= या फ़्लैटपाइप नामक एक विधि, जो एक मोनैडिक चर को खोलती है, फिर इसे एक मोनैडिक फ़ंक्शन/एक्सप्रेशन में सम्मिलित करती है, जिसके परिणामस्वरूप एक नया मोनैडिक मान होता है:
  (>>=) : (M T, T → M U) → M U so if mx : M T and f : T → M U, then (mx >>= f) : M U

हालांकि पूरी तरह से एक सन्यासी के रूप में अर्हता प्राप्त करने के लिए, इन तीन भागों को कुछ कानूनों का भी सम्मान करना चाहिए:

• unit एक पहचान तत्व है | वाम-पहचान के लिए bind:
  unit(x) >>= f ↔ f(x)
• unit के लिए एक सही-पहचान भी है bind:
  ma >>= unit ↔ ma
• bind अनिवार्य रूप से साहचर्य है:
  ma >>= λx → (f(x) >>= g) ↔ (ma >>= f) >>= g

बीजगणितीय रूप से, इसका मतलब है कि कोई भी मोनैड दोनों एक श्रेणी (जिसे क्लेस्ली श्रेणी कहा जाता है) को जन्म देता है और फ़ैक्टरों की श्रेणी में एक मोनोइड (मूल्यों से संगणना तक), मोनैडिक रचना के साथ मोनॉइड में एक बाइनरी ऑपरेटर के रूप में और unit मोनाड में पहचान के रूप में।

उपयोग

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

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

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

अनुप्रयोग

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

यहां कुछ ऐसे एप्लिकेशन दिए गए हैं जिनके डिजाइन के केंद्र में मोनैड हैं:

• पारसेक (पार्सर) पार्सर लाइब्रेरी सरल पदच्छेद नियमों को अधिक जटिल नियमों में संयोजित करने के लिए मोनैड का उपयोग करती है, और विशेष रूप से छोटे डोमेन-विशिष्ट भाषाओं के लिए उपयोगी है।
• xmonad एक टाइलिंग विंडो प्रबंधक है जो ज़िपर (डेटा संरचना) पर केंद्रित है, जिसे सीमांकित निरंतरता के एक विशिष्ट मामले के रूप में मोनोडिक रूप से माना जा सकता है।
• Microsoft द्वारा LINQ .NET फ्रेमवर्क के लिए एक क्वेरी भाषा प्रदान करता है जो कार्यात्मक प्रोग्रामिंग अवधारणाओं से बहुत अधिक प्रभावित होता है, जिसमें कोर ऑपरेटर्स शामिल होते हैं जो प्रश्नों को मोनोडिक रूप से लिखते हैं।
• ZipperFS एक सरल, प्रयोगात्मक फाइल सिस्टम है जो मुख्य रूप से अपनी विशेषताओं को लागू करने के लिए ज़िपर संरचना का उपयोग करता है।

गणितज्ञ रोजर गॉडमेंट 1950 के दशक के उत्तरार्ध में एक मोनाड (इसे एक मानक निर्माण करार देते हुए) की अवधारणा तैयार करने वाले पहले व्यक्ति थे, हालांकि शब्द मोनाड जो हावी हो गया था, वह श्रेणी-सिद्धांतवादी सॉन्डर्स मैक लेन द्वारा लोकप्रिय था। ऊपर परिभाषित प्रपत्र का उपयोग कर bindहालांकि, मूल रूप से 1965 में गणितज्ञ हेनरिक क्लेस्ली द्वारा यह साबित करने के लिए वर्णित किया गया था कि किसी भी मोनाड को दो (सहसंयोजक) फ़ैक्टरों के बीच एक संयोजन (श्रेणी सिद्धांत) के रूप में चित्रित किया जा सकता है। 1980 के दशक की शुरुआत में, कंप्यूटर विज्ञान समुदाय में मोनाड पैटर्न की एक अस्पष्ट धारणा सतह पर आने लगी। प्रोग्रामिंग भाषा शोधकर्ता फिलिप वाडलर के अनुसार, कंप्यूटर वैज्ञानिक जॉन सी। रेनॉल्ड्स ने 1970 और 1980 के दशक की शुरुआत में इसके कई पहलुओं का अनुमान लगाया था, जब उन्होंने निरंतरता-गुजरने वाली शैली के मूल्य पर चर्चा की, श्रेणी सिद्धांत औपचारिक शब्दार्थ के लिए एक समृद्ध स्रोत के रूप में, और प्रकार मूल्यों और संगणना के बीच अंतर।अनुसंधान भाषा ओपल प्रोग्रामिंग भाषा, जिसे 1990 तक सक्रिय रूप से डिजाइन किया गया था, प्रभावी रूप से I/O पर एक मोनडिक प्रकार पर आधारित थी, लेकिन उस समय कनेक्शन का एहसास नहीं हुआ था। कंप्यूटर वैज्ञानिक यूजीनियो मोगी 1989 में एक सम्मेलन पत्र में श्रेणी सिद्धांत के मोनाड को कार्यात्मक प्रोग्रामिंग से स्पष्ट रूप से जोड़ने वाले पहले व्यक्ति थे। इसके बाद 1991 में एक अधिक परिष्कृत जर्नल प्रस्तुत किया गया। पहले के काम में, कई कंप्यूटर वैज्ञानिकों ने लैम्ब्डा कैलकुलस के लिए शब्दार्थ प्रदान करने के लिए श्रेणी सिद्धांत का उपयोग करके उन्नत किया था। मोगी की प्रमुख अंतर्दृष्टि यह थी कि एक वास्तविक दुनिया का कार्यक्रम केवल मूल्यों से अन्य मूल्यों तक का कार्य नहीं है, बल्कि एक परिवर्तन है जो उन मूल्यों पर संगणना करता है। जब श्रेणी-सैद्धांतिक शर्तों में औपचारिक रूप दिया जाता है, तो यह निष्कर्ष निकलता है कि इन गणनाओं का प्रतिनिधित्व करने के लिए मोनैड संरचना हैं।

फिलिप वाडलर और साइमन पीटन जोन्स सहित कई अन्य लोगों ने इस विचार को लोकप्रिय बनाया और बनाया, दोनों ही हास्केल के विनिर्देशन में शामिल थे। विशेष रूप से, हास्केल ने अधिक लचीले मोनैडिक इंटरफ़ेस पर स्विच करने तक आलसी मूल्यांकन के साथ I/O को समेटने के लिए v1.2 के माध्यम से एक समस्याग्रस्त आलसी स्ट्रीम मॉडल का उपयोग किया। हास्केल समुदाय कार्यात्मक प्रोग्रामिंग में कई समस्याओं के लिए भिक्षुओं को लागू करने के लिए आगे बढ़ेगा, और 2010 के दशक में, हास्केल के साथ काम करने वाले शोधकर्ताओं ने अंततः यह माना कि मठाधीश अनुप्रयोगी कारक हैं; और यह कि मोनैड और एरो (कंप्यूटर साइंस) दोनों मोनोइड हैं। सबसे पहले, मोनाड्स के साथ प्रोग्रामिंग काफी हद तक हास्केल और उसके डेरिवेटिव तक ही सीमित थी, लेकिन जैसा कि कार्यात्मक प्रोग्रामिंग ने अन्य प्रतिमानों को प्रभावित किया है, कई भाषाओं ने एक मोनाड पैटर्न (यदि नाम में नहीं है) को शामिल किया है। फार्मूलेशन अब स्कीम (प्रोग्रामिंग लैंग्वेज), पर्ल, पायथन (प्रोग्रामिंग लैंग्वेज), रैकेट (प्रोग्रामिंग भाषा), क्लोजर, स्काला (प्रोग्रामिंग भाषा), एफ शार्प (प्रोग्रामिंग लैंग्वेज) में मौजूद हैं। (प्रोग्रामिंग भाषा) मानक।

विश्लेषण

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

सन्यासी कानूनों का सत्यापन

को लौट रहा है Maybe उदाहरण के लिए, इसके घटकों को एक सन्यासी घोषित किया गया था, लेकिन इस बात का कोई प्रमाण नहीं दिया गया था कि यह सन्यासी कानूनों को संतुष्ट करता है।

इसकी बारीकियों को प्लग करके इसे ठीक किया जा सकता है Maybe सामान्य कानूनों के एक पक्ष में, फिर बीजगणितीय रूप से समानता की एक श्रृंखला का निर्माण दूसरी तरफ तक पहुँचने के लिए:

नियम 1: eta(a) >>= f(x) ⇔ (सिर्फ a) >>= f(x) ⇔ f(a)

कानून 2:  मा >>= एटा (एक्स)           ⇔ और        

अगर मा है (सिर्फ एक) तो            
और              ⇔ बस ए        
और कुछ                     या            
कुछ नहीं             ⇔ कुछ नहीं        
अगर अंत

कानून 3:  (एमए >>= एफ (एक्स)) >>= जी (वाई)            ⇔ my >>= (f(x) >>= g(y))        

अगर (मा >>= एफ(एक्स)) है (सिर्फ बी) तो   अगर मा है (सिर्फ एक) तो            
जी (इन >> = एफ (एक्स))                           (एफ(एक्स) >>= जी(वाई)) ए        
और कुछ                                    और कुछ            
कुछ नहीं                                    कुछ नहीं        
अगर अंत                                  अगर अंत                

⇔ यदि मा (सिर्फ a) है और f(a) है (सिर्फ b) तो                    
      (जी ∘ एफ) ए                
अन्यथा यदि मा (सिर्फ a) है और f(a) कुछ भी नहीं है तो                    
कुछ नहीं                
और कुछ                    
कुछ नहीं                
अगर अंत

functors से व्युत्पत्ति >

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

map φ : (a → b) → (ma → mb)

यह हमेशा एक प्रमुख मुद्दा नहीं है, हालांकि, विशेष रूप से जब एक सन्यासी एक पूर्व-मौजूदा फ़ंक्टर से प्राप्त होता है, जहां सन्यासी विरासत में मिलता है map खुद ब खुद। (ऐतिहासिक कारणों से, यह map बल्कि कहा जाता है fmap हास्केल में।)

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

(unit ∘ φ) x ↔ ((map φ) ∘ unit) x

एप्लिकेटिव फंक्टर से मोनाड तक की अंतिम छलांग दूसरे परिवर्तन के साथ आती है, ज्वाइन फंक्शन (श्रेणी सिद्धांत में यह एक प्राकृतिक परिवर्तन है जिसे आमतौर पर कहा जाता है μ), जो मोनाड के नेस्टेड अनुप्रयोगों को समतल करता है:

join(mma) : M (M T) → M T

विशेषता समारोह के रूप में, join मोनाड कानूनों पर तीन भिन्नताओं को भी पूरा करना चाहिए:

(join ∘ (map join)) mmma ↔ (join ∘ join) mmma ↔ ma

(join ∘ (map unit)) ma ↔ (join ∘ unit) ma ↔ ma

(join ∘ (map map φ)) mma ↔ ((map φ) ∘ join) mma ↔ mb

भले ही कोई डेवलपर प्रत्यक्ष मोनाड या क्लेस्ली ट्रिपल को परिभाषित करता हो, अंतर्निहित संरचना समान होगी, और प्रपत्र एक दूसरे से आसानी से प्राप्त किए जा सकते हैं:

(map φ) ma ↔ ma >>= (unit ∘ φ)

join(mma) ↔ mma >>= id

ma >>= f ↔ (join ∘ (map f)) ma

एक अन्य उदाहरण: सूची <अवधि आईडी = सूची मोनाड>

सूची मोनड स्वाभाविक रूप से प्रदर्शित करता है कि एक सरल फ़ैक्टर से एक मोनड कैसे प्राप्त किया जा सकता है। कई भाषाओं में, एक सूची संरचना कुछ मूलभूत सुविधाओं के साथ पूर्व-निर्धारित होती है, इसलिए a List कंस्ट्रक्टर टाइप करें और append ऑपरेटर (के साथ प्रतिनिधित्व किया ++ इन्फिक्स नोटेशन के लिए) पहले से ही यहां दिए गए मान लिए गए हैं।

अधिकांश भाषाओं में सूची में सादा मान एम्बेड करना भी तुच्छ है:

इकाई (एक्स) = [एक्स]

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

हालाँकि, पूरी सूची में किसी भी सरल कार्य को लागू करने की प्रक्रिया, दूसरे शब्दों में map, सीधा है:

(मानचित्र φ) xlist = [φ(x1), φ(x2), ..., φ(xn)]

अब, ये दो प्रक्रियाएँ पहले से ही बढ़ावा दे रही हैं List एक एप्लिकेटिव फ़ैक्टर के लिए। एक सन्यासी के रूप में पूरी तरह से योग्य होने के लिए, केवल एक सही धारणा join बार-बार संरचना को समतल करने की आवश्यकता है, लेकिन सूचियों के लिए, इसका मतलब है कि आंतरिक सूची को जोड़ने के लिए बाहरी सूची को खोलना जिसमें मान शामिल हैं:

शामिल हों (xlistlist) = शामिल हों ([xlist1, xlist2, ..., xlistn])
                 = xlist1 ++ xlist2 ++ ... ++ xlistn

परिणामी मोनड न केवल एक सूची है, बल्कि एक ऐसा है जो स्वचालित रूप से आकार बदलता है और कार्यों को लागू करने के रूप में स्वयं को संघनित करता है। bind अब भी केवल एक सूत्र के साथ प्राप्त किया जा सकता है, फिर फ़ीड करने के लिए उपयोग किया जाता है List मोनाडिक कार्यों की एक पाइपलाइन के माध्यम से मूल्य:

List ई> मोनैड जटिल जड़ों जैसे बहुविकल्पीय कार्यों के उपयोग को बहुत आसान बना सकता है।

(xlist >>= f) = ∘ (मानचित्र f) xlist में शामिल हों

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

दूसरी स्थिति जहां List शाइन बहु-मूल्यवान कार्यों की रचना कर रहा है। उदाहरण के लिए, nकिसी संख्या का वां वां मूल#जटिल मूल यील्ड होना चाहिए n विशिष्ट जटिल संख्याएं, लेकिन यदि कोई अन्य mफिर उन परिणामों का वां मूल निकाल लिया जाता है, अंतिम m•n मान के आउटपुट के समान होना चाहिए m•nजड़। List प्रत्येक चरण के परिणामों को समतल, गणितीय रूप से सही सूची में संघनित करते हुए, इस समस्या को पूरी तरह से स्वचालित कर देता है।

तकनीक

मोनैड सिर्फ प्रोग्राम लॉजिक के आयोजन से परे दिलचस्प तकनीकों के अवसर पेश करते हैं। मोनैड उपयोगी सिंटैक्टिक सुविधाओं के लिए आधारभूत कार्य कर सकते हैं जबकि उनकी उच्च स्तरीय और गणितीय प्रकृति महत्वपूर्ण अमूर्तता को सक्षम करती है।

सिंथेटिक चीनी do-notation

हालांकि उपयोग कर रहा है bind खुले तौर पर अक्सर समझ में आता है, कई प्रोग्रामर एक सिंटैक्स पसंद करते हैं जो अनिवार्य बयानों की नकल करता है (हास्केल में डू-नोटेशन कहा जाता है, OCaml में प्रदर्शन-नोटेशन, एफ शार्प (प्रोग्रामिंग लैंग्वेज) में कंप्यूटेशन एक्सप्रेशंस|एफ#, और स्काला (प्रोग्रामिंग भाषा) में समझ के लिए)। यह केवल सिंटैक्टिक चीनी है जो एक कोड ब्लॉक के रूप में एक मोनाडिक पाइपलाइन को प्रच्छन्न करता है; संकलक तब चुपचाप इन भावों को अंतर्निहित कार्यात्मक कोड में अनुवादित करेगा।

अनुवाद कर रहा है add समारोह से Maybe इनटू हास्केल इस सुविधा को क्रिया में दिखा सकता है। का एक गैर-मोनैडिक संस्करण add हास्केल में ऐसा दिखता है: <वाक्यविन्यास लैंग = हैकेल> एमएक्स माय = जोड़ें

   केस एमएक्स ऑफ
       कुछ नहीं -> कुछ नहीं
       जस्ट एक्स -> केस माय ऑफ
                      कुछ नहीं -> कुछ नहीं
                      जस्ट वाई -> जस्ट (x + y)

</वाक्यविन्यास हाइलाइट>

मोनैडिक हास्केल में, return का मानक नाम है unit, प्लस लैम्ब्डा एक्सप्रेशंस को स्पष्ट रूप से हैंडल किया जाना चाहिए, लेकिन इन तकनीकीताओं के साथ भी, Maybe मोनाड एक क्लीनर परिभाषा के लिए बनाता है: <वाक्यविन्यास लैंग = हैकेल> एमएक्स माय = जोड़ें

   एमएक्स >>= (\x ->
       मेरा >>= (\y ->
           रिटर्न (एक्स + वाई)))

</वाक्यविन्यास हाइलाइट>

हालांकि डू-नोटेशन के साथ, इसे एक बहुत ही सहज अनुक्रम में और भी आसुत किया जा सकता है: <वाक्यविन्यास लैंग = हैकेल> एमएक्स माय = डू जोड़ें

   एक्स <- एमएक्स
   वाई <- मेरा
   वापसी (एक्स + वाई)

</वाक्यविन्यास हाइलाइट>

एक दूसरा उदाहरण दिखाता है कि कैसे Maybe पूरी तरह से अलग भाषा में इस्तेमाल किया जा सकता है: F#। अभिकलन व्यंजकों के साथ, एक सुरक्षित विभाजन फ़ंक्शन जो वापस आता है None एक अपरिभाषित ऑपरेंड या विभाजन के लिए शून्य के रूप में लिखा जा सकता है: <वाक्यविन्यास प्रकाश लैंग = ओकैमल> आइए पढ़ें संख्या () =

 चलो एस = कंसोल। रीडलाइन ()
 सफल होने दें, v = Int32.TryParse(s)
 अगर (सक्सेस) तो कुछ (v) और कोई नहीं

चलो Secure_div =

 शायद {
   होने देना! एक्स = रीडनम ()
   होने देना! वाई = रीडनम ()
   अगर (वाई = 0)
   फिर कोई नहीं
   और वापसी (एक्स / वाई)
 }

</वाक्यविन्यास हाइलाइट>

बिल्ड-टाइम पर, कंपाइलर आंतरिक रूप से इस फ़ंक्शन को एक सघन श्रृंखला में डी-शुगर करेगा bind कॉल: <वाक्यविन्यास प्रकाश लैंग = ओकैमल> हो सकता है। विलंब (मजेदार () ->

 हो सकता है। बाइंड (रीडनम (), फन एक्स ->
   हो सकता है। बाइंड (रीडनम (), फन वाई ->
     अगर (y=0) तो शायद और कोई नहीं। वापसी(x / y)))

</वाक्यविन्यास हाइलाइट>

आखिरी उदाहरण के लिए, यहां तक ​​​​कि सामान्य मोनड कानूनों को भी डू-नोटेशन में व्यक्त किया जा सकता है: <वाक्यविन्यास लैंग = हैकेल> करना {x <-वापसी v; f x } == do { f v } करना {एक्स <- एम; रिटर्न एक्स} == डू {एम} do {y <- do {x <- m; एफ एक्स}; g y } == do { x <- m; वाई <- एफ एक्स; जी वाई} </वाक्यविन्यास हाइलाइट>

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

सामान्य इंटरफ़ेस

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

ऑपरेटर्स >

संचालकों के विवेकपूर्ण उपयोग के माध्यम से मोनाडिक कोड को अक्सर और भी सरल बनाया जा सकता है। map }} कार्यात्मक विशेष रूप से सहायक हो सकता है क्योंकि यह केवल तदर्थ मोनाडिक कार्यों से अधिक पर काम करता है; जब तक एक मोनैडिक फ़ंक्शन को पूर्वनिर्धारित ऑपरेटर के अनुरूप काम करना चाहिए, map सरल ऑपरेटर को तुरंत (गणित) एक मोनडिक में उठाने के लिए इस्तेमाल किया जा सकता है। इस तकनीक के साथ, की परिभाषा add वहाँ से Maybe उदाहरण में आसवित किया जा सकता है:

जोड़ें (एमएक्स, मेरा) = मानचित्र (+)

परिभाषित करके प्रक्रिया को एक कदम आगे भी ले जाया जा सकता है add सिर्फ के लिए नहीं Maybe, लेकिन पूरे के लिए Monad इंटरफेस। ऐसा करने से, कोई भी नया मोनाड जो संरचना इंटरफ़ेस से मेल खाता है और स्वयं को लागू करता है map का एक उठा हुआ संस्करण तुरंत इनहेरिट करेगा add भी। आवश्यक फ़ंक्शन में केवल परिवर्तन ही प्रकार के हस्ताक्षर को सामान्य कर रहा है:

जोड़ें: (मोनाड नंबर, मोनाड नंबर) → मोनाड नंबर

एक अन्य मोनैडिक ऑपरेटर जो विश्लेषण के लिए भी उपयोगी है, मोनैडिक रचना है (इन्फिक्स के रूप में दर्शाया गया है >=> यहां), जो अधिक गणितीय शैली में मोनैडिक कार्यों को चेन करने की अनुमति देता है:

(एफ >=> जी) (एक्स) = एफ (एक्स) >>= जी

इस ऑपरेटर के साथ, मोनोड कानूनों को अकेले कार्यों के संदर्भ में लिखा जा सकता है, एक पहचान के समानता और अस्तित्व के पत्राचार पर प्रकाश डाला जा सकता है:

(इकाई >=> जी) ↔ जी
(f >=> इकाई) ↔ च
(एफ >=> जी) >=> एच ↔ एफ >=> (जी >=> एच)

बदले में, ऊपर हास्केल में do ब्लॉक का अर्थ दिखाता है:

करना
 _पी <- च (एक्स)
 _क्यू <- जी (_पी)
 h(_q) ↔ ( f >=> g >=> h )(x)

अधिक उदाहरण

पहचान मोनाद

सबसे सरल मोनाड आइडेंटिटी मोनाड है, जो केवल मोनाड कानूनों को पूरा करने के लिए सादे मूल्यों और कार्यों की व्याख्या करता है:

न्यूटाइप आईडी टी = टी

यूनिट (एक्स) = एक्स
(एक्स >>= एफ) = एफ (एक्स)

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

संग्रह

उचित के साथ कोई संग्रह append पहले से ही एक मुक्त मोनॉयड है, लेकिन यह पता चला है List केवल संग्रह (अमूर्त डेटा प्रकार) नहीं है जिसमें एक अच्छी तरह से परिभाषित भी है join और एक सन्यासी के रूप में अर्हता प्राप्त करता है। कोई म्यूटेट भी कर सकता है List केवल विशेष गुणों को लागू करके इन अन्य मठवासी संग्रहों में append:

Collection	Monoid properties
List	Free
Finite multiset	Commutative
Finite set	Commutative and idempotent
Finite permutations	Non-commutative and idempotent

आईओ मोनाड (हास्केल)

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

उदाहरण के लिए, हास्केल के पास व्यापक फाइल सिस्टम पर कार्य करने के लिए कई कार्य हैं, जिनमें एक यह जांचता है कि फ़ाइल मौजूद है या नहीं और दूसरा फ़ाइल को हटा देता है। उनके दो प्रकार के हस्ताक्षर हैं: <वाक्यविन्यास लैंग = हैकेल> doFileExist :: FilePath -> IO बूल रिमूवफाइल :: फाइलपाथ -> आईओ () </वाक्यविन्यास हाइलाइट>

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

IO हालांकि केवल फ़ाइल I/O तक ही सीमित नहीं है; यह उपयोगकर्ता I/O के लिए भी अनुमति देता है, और अनिवार्य सिंटैक्स चीनी के साथ, एक सामान्य हैलो, वर्ल्ड की नकल कर सकता है! कार्यक्रम: <वाक्यविन्यास लैंग = हैकेल> मुख्य :: आईओ () मुख्य = करना

 putStrLn हैलो, दुनिया!
 putStrLn आपका नाम क्या है, उपयोगकर्ता?
 नाम <- getLine
 putStrLn (आपसे मिलकर अच्छा लगा, ++ नाम ++!)

</वाक्यविन्यास हाइलाइट>

Desugared, यह निम्नलिखित मोनाडिक पाइपलाइन में अनुवाद करता है (>> हास्केल में सिर्फ एक प्रकार है bind जब केवल राक्षसी प्रभाव मायने रखता है और अंतर्निहित परिणाम को त्याग दिया जा सकता है): <वाक्यविन्यास लैंग = हैकेल> मुख्य :: आईओ () मुख्य =

 putStrLn हैलो, दुनिया! >>
 putStrLn आपका नाम क्या है, उपयोगकर्ता? >>
 getLine >>= (\name ->
   putStrLn (आपसे मिलकर अच्छा लगा, ++ नाम ++!))

</वाक्यविन्यास हाइलाइट>

राइटर मोनाड (जावास्क्रिप्ट)

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

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

परिभाषित unit भी बहुत आसान है:

const unit = value => [मान, [;

केवल unit आउटपुट के सरल कार्यों को परिभाषित करने की आवश्यकता है Writer डिबगिंग नोट्स वाली वस्तुएं: <वाक्यविन्यास लैंग = जावास्क्रिप्ट> const चुकता = x => [x * x, [`${x} चुकता किया गया था।`; const आधा = x => [x / 2, [`${x} आधा किया गया था।`; </वाक्यविन्यास हाइलाइट>

एक सच्चे सन्यासी को अभी भी आवश्यकता है bind, लेकिन के लिए Writer, यह केवल एक फ़ंक्शन के आउटपुट को मोनाड की लिंक की गई सूची में समाप्‍त करने के लिए है: <वाक्यविन्यास लैंग = जावास्क्रिप्ट> कॉन्स्ट बाइंड = (लेखक, रूपांतरण) => {

   const [मान, लॉग] = लेखक;
   const [परिणाम, अद्यतन] = परिवर्तन (मान);
   वापसी [परिणाम, log.concat (अपडेट)];

}; </वाक्यविन्यास हाइलाइट>

नमूना कार्यों को अब उपयोग करके एक साथ जोड़ा जा सकता है bind, लेकिन मठ रचना के एक संस्करण को परिभाषित करना (कहा जाता है pipelog यहां) इन कार्यों को और भी संक्षेप में लागू करने की अनुमति देता है: <वाक्यविन्यास लैंग = जावास्क्रिप्ट> const pipelog = (लेखक, ... रूपांतरित) =>

   ट्रांसफॉर्म.रिड्यूस (बाइंड, राइटर);

</वाक्यविन्यास हाइलाइट>

अंतिम परिणाम संगणनाओं के माध्यम से आगे बढ़ने और बाद में ऑडिट करने के लिए उन्हें लॉग करने के बीच चिंताओं का एक स्पष्ट पृथक्करण है: <वाक्यविन्यास लैंग = जावास्क्रिप्ट> पाइपलॉग (इकाई (4), चुकता, आधा); // परिणामी लेखक वस्तु = [8, ['4 चुकता था।', '16 आधा था।' </वाक्यविन्यास हाइलाइट>

पर्यावरण मठ

एक पर्यावरण मोनाड (जिसे एक पाठक मोनाड और एक फ़ंक्शन मोनाड भी कहा जाता है) एक संगणना को एक साझा वातावरण से मूल्यों पर निर्भर करने की अनुमति देता है। मोनाड टाइप कंस्ट्रक्टर एक प्रकार का नक्शा बनाता है T प्रकार के कार्यों के लिए E → T, कहां E साझा वातावरण का प्रकार है। मोनाड कार्य हैं:

$${\begin{array}{ll}{\text{return}}\colon &T\rightarrow E\rightarrow T=t\mapsto e\mapsto t\\{\text{bind}}\colon &(E\rightarrow T)\rightarrow (T\rightarrow E\rightarrow T')\rightarrow E\rightarrow T'=r\mapsto f\mapsto e\mapsto f\,(r\,e)\,e\end{array}}$$

निम्नलिखित मोनाडिक ऑपरेशन उपयोगी हैं:

$${\begin{array}{ll}{\text{ask}}\colon &E\rightarrow E={\text{id}}_{E}\\{\text{local}}\colon &(E\rightarrow E)\rightarrow (E\rightarrow T)\rightarrow E\rightarrow T=f\mapsto c\mapsto e\mapsto c\,(f\,e)\end{array}}$$

ask }} ऑपरेशन का उपयोग वर्तमान संदर्भ को पुनः प्राप्त करने के लिए किया जाता है, जबकि local संशोधित उपसंदर्भ में संगणना निष्पादित करता है। एक राज्य सन्यासी के रूप में, पर्यावरण सन्यास में संगणनाओं को केवल एक पर्यावरण मूल्य प्रदान करके और इसे सन्यासी के एक उदाहरण पर लागू करके लागू किया जा सकता है।

औपचारिक रूप से, पर्यावरण सन्यास में एक मान एक अतिरिक्त, अनाम तर्क के साथ एक फ़ंक्शन के बराबर है; return और bind के समकक्ष हैं K और S कॉम्बिनेटर, क्रमशः एसकेआई कॉम्बिनेटर कैलकुलस में।

राज्य मठ

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

<वाक्यविन्यास लैंग = हैकेल> टाइप स्टेट एस टी = एस -> (टी, एस) </वाक्यविन्यास हाइलाइट>

ध्यान दें कि यह मोनाड एक प्रकार का पैरामीटर लेता है, राज्य की जानकारी का प्रकार। मोनाड संचालन को निम्नानुसार परिभाषित किया गया है:

<वाक्यविन्यास लैंग = हैकेल> - वापसी राज्य को बदले बिना दिए गए मूल्य का उत्पादन करती है। रिटर्न x = \s -> (x, s) - बाइंड एम को संशोधित करता है ताकि यह इसके परिणाम पर एफ लागू हो। m >>= f = \r -> माना (x, s) = m r in (f x) s </वाक्यविन्यास हाइलाइट>

उपयोगी राज्य संचालन में शामिल हैं: <वाक्यविन्यास लैंग = हैकेल> get = \s -> (s, s) - गणना में इस बिंदु पर स्थिति की जांच करें। put s = \_ -> ((), s) - स्थिति बदलें। f = \s -> ((), f s) को संशोधित करें - स्थिति को अपडेट करें </वाक्यविन्यास हाइलाइट>

एक अन्य ऑपरेशन किसी दिए गए प्रारंभिक अवस्था में एक राज्य सन्यासी को लागू करता है: <वाक्यविन्यास लैंग = हैकेल> रनस्टेट :: स्टेट एस ए -> एस -> (ए, एस) रनस्टेट टी एस = टी एस </वाक्यविन्यास हाइलाइट>

स्टेट मोनैड में डू-ब्लॉक ऑपरेशन के अनुक्रम हैं जो राज्य डेटा की जांच और अद्यतन कर सकते हैं।

अनौपचारिक रूप से, राज्य प्रकार का एक राज्य सन्यासी S रिटर्न वैल्यू के प्रकार को मैप करता है T प्रकार के कार्यों में $S\rightarrow T\times S$, कहां S अंतर्निहित अवस्था है। return }} और bind समारोह हैं:

${\begin{array}{ll}{\text{return}}\colon &T\rightarrow S\rightarrow T\times S=t\mapsto s\mapsto (t,s)\\{\text{bind}}\colon &(S\rightarrow T\times S)\rightarrow (T\rightarrow S\rightarrow T'\times S)\rightarrow S\rightarrow T'\times S\ =m\mapsto k\mapsto s\mapsto (k\ t\ s')\quad {\text{where}}\;(t,s')=m\,s\end{array}}$.

श्रेणी सिद्धांत के दृष्टिकोण से, एक राज्य सन्यासी उत्पाद फ़ैक्टर और एक्सपोनेंशियल फ़ंक्टर के बीच संयोजन से प्राप्त होता है, जो परिभाषा के अनुसार किसी भी कार्टेशियन बंद श्रेणी में मौजूद है।

निरंतरता मोनाड

एक निरंतरता सन्यासी वापसी प्रकार के साथ R मानचित्र प्रकार T प्रकार के कार्यों में $\left(T\rightarrow R\right)\rightarrow R$. इसका उपयोग निरंतरता-गुजरने वाली शैली को मॉडल करने के लिए किया जाता है। रिटर्न और बाइंड फ़ंक्शन इस प्रकार हैं:

${\begin{array}{ll}{\text{return}}\colon &T\rightarrow \left(T\rightarrow R\right)\rightarrow R=t\mapsto f\mapsto f\,t\\{\text{bind}}\colon &\left(\left(T\rightarrow R\right)\rightarrow R\right)\rightarrow \left(T\rightarrow \left(T'\rightarrow R\right)\rightarrow R\right)\rightarrow \left(T'\rightarrow R\right)\rightarrow R=c\mapsto f\mapsto k\mapsto c\,\left(t\mapsto f\,t\,k\right)\end{array}}$

कॉल-विद-वर्तमान-निरंतरता फ़ंक्शन को निम्नानुसार परिभाषित किया गया है:

${\text{call/cc}}\colon \ \left(\left(T\rightarrow \left(T'\rightarrow R\right)\rightarrow R\right)\rightarrow \left(T\rightarrow R\right)\rightarrow R\right)\rightarrow \left(T\rightarrow R\right)\rightarrow R=f\mapsto k\mapsto \left(f\left(t\mapsto x\mapsto k\,t\right)\,k\right)$

प्रोग्राम लॉगिंग

निम्नलिखित कोड स्यूडोकोड है। मान लीजिए हमारे पास दो कार्य हैं foo और bar, प्रकार के साथ <वाक्यविन्यास लैंग = हैकेल> फू : इंट -> इंट बार: इंट -> इंट </वाक्यविन्यास हाइलाइट>

अर्थात्, दोनों कार्य एक पूर्णांक लेते हैं और दूसरा पूर्णांक लौटाते हैं। फिर हम कार्यों को उत्तराधिकार में लागू कर सकते हैं जैसे: <वाक्यविन्यास लैंग = हैकेल> फू (बार एक्स) </वाक्यविन्यास हाइलाइट>

जहां परिणाम का परिणाम है foo के परिणाम पर लागू होता है bar पर लागू किया गया x.

लेकिन मान लीजिए कि हम अपने प्रोग्राम को डिबग कर रहे हैं, और हम इसमें लॉगिंग संदेश जोड़ना चाहते हैं foo और bar. इसलिए हम प्रकारों को इस प्रकार बदलते हैं: <वाक्यविन्यास लैंग = हैकेल> फू : इंट -> इंट * स्ट्रिंग बार: इंट -> इंट * स्ट्रिंग </वाक्यविन्यास हाइलाइट>

ताकि दोनों कार्य पूर्णांक के रूप में आवेदन के परिणाम के साथ एक टपल लौटाएं, और एक लॉगिंग संदेश लागू किए गए फ़ंक्शन और स्ट्रिंग के रूप में पहले लागू किए गए सभी कार्यों के बारे में जानकारी के साथ।

दुर्भाग्य से, इसका मतलब है कि अब हम संरचना का कार्य नहीं कर सकते हैं foo और bar, उनके इनपुट प्रकार के रूप में int उनके आउटपुट प्रकार के साथ संगत नहीं है int * string. और यद्यपि हम फिर से होने वाले प्रत्येक फ़ंक्शन के प्रकारों को संशोधित करके रचनाशीलता प्राप्त कर सकते हैं int * string -> int * string, इसके लिए हमें टपल से पूर्णांक निकालने के लिए प्रत्येक फ़ंक्शन में बॉयलरप्लेट कोड जोड़ने की आवश्यकता होगी, जो इस तरह के कार्यों की संख्या बढ़ने पर थकाऊ हो जाएगा।

इसके बजाय, हमारे लिए इस बॉयलरप्लेट को अलग करने के लिए एक सहायक कार्य को परिभाषित करें: <वाक्यविन्यास लैंग = हैकेल> बाइंड: इंट * स्ट्रिंग -> (इंट -> इंट * स्ट्रिंग) -> इंट * स्ट्रिंग </वाक्यविन्यास हाइलाइट>

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

अब हमने कुछ रचनाशीलता वापस पा ली है। उदाहरण के लिए: <वाक्यविन्यास लैंग = हैकेल> बाइंड (बाइंड (एक्स, एस) बार) foo </वाक्यविन्यास हाइलाइट>

कहां (x,s) एक पूर्णांक और स्ट्रिंग टपल है। लाभों को और भी स्पष्ट करने के लिए, आइए हम एक इन्फिक्स ऑपरेटर को उपनाम के रूप में परिभाषित करें bind: <वाक्यविन्यास लैंग = हैकेल> (>>=) : int * string -> (int -> int * string) -> int * string </वाक्यविन्यास हाइलाइट>

ताकि t >>= f वैसा ही है जैसा कि bind t f.

तब उपरोक्त उदाहरण बन जाता है: <वाक्यविन्यास लैंग = हैकेल> ((एक्स, एस) >>= बार) >>= foo </वाक्यविन्यास हाइलाइट>

अंत में, लिखना न पड़े तो अच्छा होगा (x, "") हर बार हम एक खाली लॉगिंग संदेश बनाना चाहते हैं, जहाँ "" खाली स्ट्रिंग है। तो चलिए एक नया कार्य परिभाषित करते हैं: <वाक्यविन्यास लैंग = हैकेल> वापसी: इंट -> इंट * स्ट्रिंग </वाक्यविन्यास हाइलाइट>

जो लपेटता है x ऊपर वर्णित टपल में।

अब हमारे पास लॉगिंग संदेशों के लिए एक अच्छी पाइपलाइन है: <वाक्यविन्यास लैंग = हैकेल> ((रिटर्न x) >>= बार) >>= foo </वाक्यविन्यास हाइलाइट>

यह हमें और अधिक आसानी से के प्रभावों को लॉग इन करने की अनुमति देता है bar और foo पर x.

int * string एक छद्म कोडित मोनडिक मान को दर्शाता है। bind और return एक ही नाम के संबंधित कार्यों के अनुरूप हैं। असल में, int * string, bind, और return एक सन्यासी बनाओ।

विविधताएं

गणितीय स्तर पर, कुछ मठों में विशेष रूप से अच्छे गुण होते हैं और विशिष्ट समस्याओं के लिए विशिष्ट रूप से फिट होते हैं।

योज्य मठ

एक योज्य मोनाड एक अतिरिक्त बंद, साहचर्य, बाइनरी ऑपरेटर एमप्लस और एक पहचान तत्व के तहत संपन्न एक मोनाड है mplus, मजेरो कहा जाता है। Maybe ई> मोनाड को योगात्मक माना जा सकता है Nothing जैसा mzero और तार्किक विच्छेदन ऑपरेटर के रूप में भिन्नता mplus. List खाली सूची के साथ एक योगात्मक सन्यासी भी है [] के रूप में कार्य mzero और संयोजन ऑपरेटर ++ जैसा mplus.

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

श्रेणी-सैद्धांतिक शब्दों में, एक योगात्मक सन्यासी एक बार मोनैडिक कार्यों के साथ एक मोनोइड के रूप में अर्हता प्राप्त करता है bind (जैसा कि सभी मठवासी करते हैं), और फिर से मठवासी मूल्यों के माध्यम से mplus.

मुक्त सन्यासी

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

उदाहरण के लिए, पूरी तरह से काम करके Just और Nothing मार्कर, द Maybe सन्यासी वास्तव में एक मुक्त सन्यासी है। List e> मोनाड, दूसरी ओर, एक मुक्त मोनाड नहीं है क्योंकि यह सूचियों के बारे में अतिरिक्त, विशिष्ट तथ्य लाता है (जैसे append) इसकी परिभाषा में। एक अंतिम उदाहरण एक सार मुक्त सन्यासी है: <वाक्यविन्यास लैंग = हैकेल> डेटा फ्री एफ ए

 = शुद्ध ए
 | नि: शुल्क (एफ (मुक्त एफ ए))

इकाई :: ए -> फ्री एफ ए यूनिट एक्स = शुद्ध एक्स

बाइंड :: फंक्टर एफ => फ्री एफ ए -> (ए -> फ्री एफ बी) -> फ्री एफ बी बाइंड (शुद्ध एक्स) एफ = एफ एक्स बाइंड (फ्री x) f = फ्री (fmap (\y -> बाइंड y f) x) </वाक्यविन्यास हाइलाइट> हालाँकि, नि: शुल्क मोनाड्स इस उदाहरण की तरह एक लिंक्ड-लिस्ट तक ही सीमित नहीं हैं, और इसे ट्री (डेटा स्ट्रक्चर) जैसी अन्य संरचनाओं के आसपास बनाया जा सकता है।

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

कोमोनैड्स

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

तकनीकी रूप से, एक कॉमोनैड एक मोनाड का स्पष्ट दोहरी है, जिसका अर्थ यह है कि इसमें समान आवश्यक घटक होंगे, केवल प्रकार के हस्ताक्षर 'उलट' की दिशा के साथ। से शुरू bind-सेंट्रिक मोनाड परिभाषा, एक कॉमोनैड में निम्न शामिल हैं:

• एक प्रकार का कंस्ट्रक्टर W जो उच्च-क्रम प्रकार को चिन्हित करता है W T
• का द्वैत unit, जिसे यहां कॉउंट कहा जाता है, कोमोनैड से अंतर्निहित मान निकालता है:

(वा) : डब्ल्यू टी → टी

• का उलटा bind (के साथ भी प्रतिनिधित्व किया =>>) जो कार्यों को कम करने की एक श्रृंखला का विस्तार करता है:

(वा =>> एफ) : (डब्ल्यू यू, डब्ल्यू यू → टी) → डब्ल्यू टी

extend और counit मोनाड कानूनों के दोहरे को भी संतुष्ट करना चाहिए:

गिनती ∘ ( (वा =>> एफ) → डब्ल्यूबी ) ↔ एफ (वा) → बी
वा = >> काउंट ↔ वा
वा ((=>> f(wx = wa)) → wb (=>> g(wy = wb)) → wc ) ↔ ( wa (=>> f(wx = wa)) → wb ) (=>> g(wy = wb)) → wc

मोनैड के अनुरूप, कॉमोनैड भी दोहरे का उपयोग करके फ़ैक्टरों से प्राप्त किया जा सकता है join:

• डुप्लिकेट पहले से ही कॉमोनैडिक मान लेता है और इसे कॉमोनैडिक संरचना की एक और परत में लपेटता है:

डुप्लिकेट (वा): डब्ल्यू टी → डब्ल्यू (डब्ल्यू टी)

जबकि संचालन पसंद है extend उलटे हैं, हालांकि, एक कॉमोनैड उन कार्यों को उलटा नहीं करता है जिन पर यह काम करता है, और इसके परिणामस्वरूप, कॉमोनैड अभी भी फ़ैक्टर हैं map, सहायक नहीं। के साथ वैकल्पिक परिभाषा duplicate, counit, और map अपने कॉमोनैड कानूनों का भी सम्मान करना चाहिए:

((नक्शा डुप्लिकेट) ∘ डुप्लिकेट) वा ↔ (डुप्लिकेट ∘ डुप्लिकेट) वा ↔ wwwa
((नक्शा कुनिट) ∘ डुप्लीकेट) वा ↔ (काउंट ∘ डुप्लीकेट) वा ↔ वा
((मैप मैप φ) ∘ डुप्लीकेट) वा ↔ (डुप्लिकेट ∘ (मैप φ)) वा ↔ wwb

और सन्यासियों की तरह, दो रूपों को स्वचालित रूप से परिवर्तित किया जा सकता है:

(मानचित्र φ) वा ↔ वा =>> (φ ∘ देश) wx
डुप्लिकेट वा ↔ वा = >> wx

wa =>> f(wx) ↔ ((map f) ∘ डुप्लीकेट) wa

एक साधारण उदाहरण उत्पाद कॉमोनैड है, जो इनपुट मूल्य और साझा पर्यावरण डेटा के आधार पर मूल्यों को आउटपुट करता है। वास्तव में, Product कॉमोनैड सिर्फ दोहरा है Writer मोनाड और प्रभावी रूप से वही Reader मोनाड (दोनों नीचे चर्चा की गई)। Product और Reader केवल वे भिन्न होते हैं जिनमें वे फ़ंक्शन हस्ताक्षर स्वीकार करते हैं, और वे उन कार्यों को रैपिंग या अनरैपिंग मानों द्वारा कैसे पूरक करते हैं।

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

यह भी देखें

मॉडलिंग कम्प्यूटेशंस के लिए विकल्प:

• प्रभाव प्रणाली (विशेष रूप से बीजगणितीय प्रभाव हैंडलर) साइड इफेक्ट्स को प्रकार के रूप में वर्णित करने का एक अलग तरीका है
• कार्यात्मक भाषाओं में साइड-इफेक्ट्स को संभालने के लिए विशिष्टता प्रकार एक तीसरा तरीका है

संबंधित डिजाइन अवधारणाएं:

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

साधुओं का सामान्यीकरण:

• एप्लिकेटिव फ़ंक्टर केवल मानकर मोनैड से सामान्यीकरण करते हैं unit और इससे संबंधित कानून map
• एरो (कंप्यूटर साइंस) एक ही इंटरफेस के तहत सादे कार्यों और मोनाड्स को लाने के लिए अतिरिक्त संरचना का उपयोग करता है
• मोनाड ट्रांसफॉर्मर मॉड्यूलर रूप से संयोजित करने के लिए अलग-अलग मोनाड्स पर कार्य करते हैं

इस पेज में लापता आंतरिक लिंक की सूची

• टाइप सिस्टम
• दुष्प्रभाव (कंप्यूटर विज्ञान)
• बहाव को काबू करें
• समारोह (कंप्यूटर प्रोग्रामिंग)
• पुस्तकालय (कम्प्यूटिंग)
• कंस्ट्रक्टर टाइप करें
• शून्य से भाग दें
• समारोह रचना
• अनाम समारोह
• प्रकार रूपांतरण
• जोड़नेवाला
• एनकैप्सुलेशन (कंप्यूटर प्रोग्रामिंग)
• बयान (कंप्यूटर प्रोग्रामिंग)
• चिंताओ का विभाजन
• पहलू आधारित प्रोग्रामिंग
• राज्य (कंप्यूटर विज्ञान)
• पूछताछ भाषा
• जे (प्रोग्रामिंग भाषा)
• अनुप्रयोग समारोह
• तीर (कंप्यूटर विज्ञान)
• एमएल (प्रोग्रामिंग भाषा)
• पायथन (प्रोग्रामिंग भाषा)
• योजना (प्रोग्रामिंग भाषा)
• सबटाइपिंग
• नक्शा (उच्च क्रम समारोह)
• उच्च-क्रम समारोह
• गैर नियतात्मक एल्गोरिथम
• बहुविकल्पी समारोह
• लिफ्ट (गणित)
• संग्रह (सार डेटा प्रकार)
• रूपरेखा (कंप्यूटर प्रोग्रामिंग)
• विस्तार
• कॉल-साथ-वर्तमान-निरंतरता
• शोषक तत्व
• शून्य समारोह
• मुक्त मोनोइड
• पेड़ (डेटा संरचना)
• श्रेणीबद्ध दोहरी
• cofunctor
• विलक्षणता प्रकार
• नियंत्रण का उलटा

बाहरी कड़ियाँ

HaskellWiki references:

• "All About Monads" (originally by Jeff Newbern) — A comprehensive discussion of all the common monads and how they work in Haskell; includes the "mechanized assembly line" analogy.
• "Typeclassopedia" (originally by Brent Yorgey) — A detailed exposition of how the leading typeclasses in Haskell, including monads, interrelate.

Tutorials:

• "A Fistful of Monads" (from the online Haskell textbook Learn You a Haskell for Great Good! — A chapter introducing monads from the starting-point of functor and applicative functor typeclasses, including examples.
• "For a Few Monads More" — A second chapter explaining more details and examples, including a Probability monad for Markov chains.
• "Functors, Applicatives, And Monads In Pictures (by Aditya Bhargava) — A quick, humorous, and visual tutorial on monads.

Interesting cases:

• "UNIX pipes as IO monads" (by Oleg Kiselyov) — A short essay explaining how Unix pipes are effectively monadic.
• Pro Scala: Monadic Design Patterns for the Web (by Gregory Meredith) — An unpublished, full-length manuscript on how to improve many facets of web development in Scala with monads.