एक सी # डेवलपर को समझने में सहायता करें: एक मोनड क्या है?

Question

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

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

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

धन्यवाद!

(संपादित करें: वैसे, मुझे पता है कि कम से कम 3 "मोनैड क्या है" प्रश्न पहले से ही हैं। हालांकि, मुझे उनके साथ एक ही समस्या का सामना करना पड़ता है ... इसलिए इस प्रश्न की आवश्यकता आईएमओ है सी #-डेवलपर फोकस। धन्यवाद।)

Answer 1

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

यह धोखाधड़ी का प्रकार है।

अब, यह स्पष्टीकरण आपको मोनैड के बड़े चित्र के इरादे को समझने में मदद करेगा, लेकिन शैतान विवरण में है। वास्तव में क्या आप परिणामों की गणना करते हैं? कभी-कभी, यह सुंदर नहीं है।

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

Answer 2

मुझे यकीन है कि अन्य उपयोगकर्ता गहराई से पोस्ट करेंगे, लेकिन मुझे this video कुछ हद तक सहायक पाया गया, लेकिन मैं कहूंगा कि मैं अभी भी इस अवधारणा के साथ प्रवाह की स्थिति नहीं हूं जैसे कि मैं कर सकता हूं (या) मोनाड्स के साथ सहजता से समस्याओं को हल करना शुरू करें।

Answer 3

आप a C# interface that classes have to implement के रूप में एक मोनैड के बारे में सोच सकते हैं। यह एक व्यावहारिक उत्तर है जो सभी श्रेणियों के सैद्धांतिक गणित को अनदेखा करता है कि आप अपने इंटरफ़ेस में इन घोषणाओं को क्यों चुनना चाहते हैं और उन सभी कारणों को अनदेखा करते हैं जिन्हें आप एक ऐसी भाषा में मोनैड करना चाहते हैं जो साइड इफेक्ट्स से बचने की कोशिश करता है, लेकिन मैंने इसे अच्छी शुरुआत के रूप में पाया जो किसी को समझता है (सी #) इंटरफेस।

Answer 4

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

एक मोनैड "कंप्यूटेशंस के संयोजन" करने का कोई तरीका है।

आमतौर पर अपने सबसे बुनियादी "ऑपरेटर" दो संगणना एक साथ गठबंधन करने के लिए ; है:

a; b 

जब आप कहते हैं कि यह क्या आपका मतलब है "पहले a करते हैं, तो b करते हैं"। परिणाम a; b मूल रूप से एक गणना है जिसे अधिक सामान के साथ जोड़ा जा सकता है। यह एक साधारण मोनड है, यह छोटे कंप्यूटेशंस को बड़े से जोड़ने का एक तरीका है। ; कहता है "बाईं ओर की बात करें, फिर दाईं ओर की बात करें"।

ऑब्जेक्ट उन्मुख भाषाओं में एक मोनाड के रूप में देखा जा सकता है एक और चीज . है। अक्सर आप इस तरह चीजों को खोजने:

a.b().c().d() 

. मूल रूप से मतलब है "बाईं तरफ गणना का मूल्यांकन, और फिर उस के परिणाम पर सही पर विधि कहते हैं"। यह ; से थोड़ा अधिक जटिल, कार्यों/संगणकों को एक साथ जोड़ना एक और तरीका है। और . के साथ चीजों को चेन करने की अवधारणा एक मोनैड है, क्योंकि यह एक नई गणना के साथ दो कंप्यूटेशंस को एक साथ जोड़ने का एक तरीका है।

एक और बहुत ही आम इकाई, कोई विशेष सिंटेक्स है, इस पद्धति है:

rv = socket.bind(address, port); 
if (rv == -1) 
    return -1; 

rv = socket.connect(...); 
if (rv == -1) 
    return -1; 

rv = socket.send(...); 
if (rv == -1) 
    return -1; 

की -1 ए वापसी मान विफलता को इंगित करता है, लेकिन वहाँ बाहर सार यह त्रुटि जाँच करने के लिए कोई असली तरीका है, भले ही आपके पास बहुत सारे एपीआई-कॉल हैं जिन्हें आपको इस फैशन में गठबंधन करने की आवश्यकता है। यह मूल रूप से सिर्फ एक और मोनैड है जो नियम द्वारा फ़ंक्शन कॉल को जोड़ता है "यदि बाईं ओर का फ़ंक्शन -1 लौटाया गया है, तो खुद को वापस करें, अन्यथा दाईं ओर फ़ंक्शन को कॉल करें"। हम बस लिख सकता है अगर हम एक ऑपरेटर >>= है कि इस काम किया था:

socket.bind(...) >>= socket.connect(...) >>= socket.send(...) 

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

और सामान्य पैटर्न के रूप में उपयोगी कार्यों/गणनाओं को गठबंधन करने के कई और तरीके हैं और एक मोनैड में सारणित किया जा सकता है, जिससे मोनड के उपयोगकर्ता को अधिक संक्षिप्त और स्पष्ट कोड लिखने में सक्षम बनाया जाता है, क्योंकि सभी पुस्तक- प्रयुक्त कार्यों का पालन और प्रबंधन मोनड में किया जाता है।

उपरोक्त उदाहरण >>= ताकि हम स्पष्ट रूप से समय की socket बहुत सारे निर्दिष्ट करने की आवश्यकता नहीं है "त्रुटि जाँच और फिर सॉकेट कि हम इनपुट के रूप में मिल गया है पर सही पक्ष कॉल" के लिए, बढ़ाया जा सकता है के लिए:

जब से तुम कैसे अगले एक करने के लिए एक इनपुट के रूप में एक समारोह के परिणाम प्राप्त करने के बारे में चिंता करने, अगर है कि समारोह है कि इनपुट की जरूरत है और

new socket() >>= bind(...) >>= connect(...) >>= send(...); 

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

Answer 5

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

और कल रात, मैं आया और इन प्रतिक्रियाओं को फिर से पढ़ा। सबसे महत्वपूर्ण, मैं the Brian Beckman video किसी mentions above की टेक्स्ट टिप्पणियों में the specific C# example दोबारा पढ़ता हूं। यह इतना स्पष्ट और रोशनी था कि मैंने इसे सीधे यहां पोस्ट करने का निर्णय लिया है।

इस टिप्पणी की वजह से

, न केवल मुझे लगता है कि मैं ठीक से समझ क्या monads रहे हैं ... मुझे लगता है मैं वास्तव में सी # में कुछ बातें लिखा है कि monads ... या कम से कम बहुत करीब है, और करने के लिए प्रयास एक ही समस्या को हल करें।

तो, यहाँ टिप्पणी है - इस sylvan द्वारा the comment here से सभी एक सीधा उद्धरण है:

यह बहुत अच्छा है। हालांकि यह थोड़ा सा सार है। मैं उन लोगों की कल्पना कर सकता हूं जो असली उदाहरणों की कमी के कारण पहले से ही मोनैड उलझन में नहीं आते हैं।

तो मुझे अनुपालन करने की कोशिश करें, और वास्तव में स्पष्ट होने के लिए मैं सी # में एक उदाहरण करूंगा, भले ही यह बदसूरत लगेगा। मैं अंत में समकक्ष हास्केल जोड़ूंगा और आपको ठंडा हास्केल सिंटैक्टिक चीनी दिखाऊंगा, जहां आईएमओ, मोनैड वास्तव में उपयोगी हो जाना शुरू कर देते हैं।

ठीक है, तो सबसे आसान मोनाड्स में से एक को हास्केल में "शायद मोनैड" कहा जाता है। सी # में शायद Nullable<T> कहा जाता है। यह मूल रूप से एक छोटी कक्षा है जो केवल उस मान की अवधारणा को समाहित करती है जो वैध है और उसके पास मूल्य है, या "शून्य" है और इसका कोई मूल्य नहीं है।

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

यहां वह प्रोग्राम है जो पूरी चीज को प्रेरित करता है (मैं Bind बाद में परिभाषित करूंगा, यह सिर्फ आपको यह दिखाने के लिए है कि यह अच्छा क्यों है)।

class Program 
    { 
     static Nullable<int> f(){ return 4; }   
     static Nullable<int> g(){ return 7; } 
     static Nullable<int> h(){ return 9; } 


     static void Main(string[] args) 
     { 


      Nullable<int> z = 
           f().Bind(fval => 
           g().Bind(gval => 
           h().Bind(hval => 
           new Nullable<int>(fval + gval + hval)))); 

      Console.WriteLine(
        "z = {0}", z.HasValue ? z.Value.ToString() : "null"); 
      Console.WriteLine("Press any key to continue..."); 
      Console.ReadKey(); 
     } 
    } 

अब, एक पल है कि वहाँ पहले से ही सी # में Nullable के लिए यह कर (आप नल ints एक साथ जोड़ सकते हैं और आप अशक्त प्राप्त करता है, तो या तो शून्य है) के लिए समर्थन है के लिए ध्यान न दें। आइए दिखाएं कि ऐसी कोई सुविधा नहीं है, और यह केवल एक उपयोगकर्ता द्वारा परिभाषित कक्षा है जिसमें कोई विशेष जादू नहीं है। मुद्दा यह है कि हम Bind फ़ंक्शन का उपयोग हमारे Nullable मान की सामग्री में एक चर को बाध्य करने के लिए कर सकते हैं और फिर दिखा सकते हैं कि कुछ भी अजीब नहीं चल रहा है, और सामान्य इनट्स की तरह उनका उपयोग करें और उन्हें एक साथ जोड़ें। हम परिणाम को अंत में एक नाली में लपेटते हैं, और यह शून्य या तो शून्य हो जाएगा (f, g या h शून्य लौटाता है) या यह f, g, और h को एक साथ जोड़ने का परिणाम होगा। (यह समान है कि हम LINQ में एक चर के लिए डेटाबेस में एक पंक्ति को कैसे बांध सकते हैं, और इसके साथ सामान करते हैं, इस ज्ञान में सुरक्षित है कि Bind ऑपरेटर यह सुनिश्चित करेगा कि चर केवल वैध पंक्ति मानों को पारित किया जाएगा)।

आप इसके साथ खेल सकते हैं और f, g, और h में से कोई भी वापस लौटने के लिए बदल सकते हैं और आप देखेंगे कि पूरी चीज शून्य हो जाएगी।

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

यहाँ Bind ऑपरेटर है:

public static Nullable<B> Bind<A,B>(this Nullable<A> a, Func<A,Nullable<B>> f) 
    where B : struct 
    where A : struct 
{ 
    return a.HasValue ? f(a.Value) : null; 
} 

यहाँ प्रकार सिर्फ वीडियो में की तरह हैं। यह एक M a (इस मामले के लिए Nullable<A> सी में # वाक्य रचना), और (सी # वाक्य रचना में Func<A, Nullable<B>>) M b को a से एक समारोह लेता है, और यह देता है एक M b (Nullable<B>)।

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

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

अंत में, यहां हास्केल (--) में एक ही कोड का कार्यान्वयन एक टिप्पणी पंक्ति शुरू होता है)।

-- Here's the data type, it's either nothing, or "Just" a value 
-- this is in the standard library 
data Maybe a = Nothing | Just a 

-- The bind operator for Nothing 
Nothing >>= f = Nothing 
-- The bind operator for Just x 
Just x >>= f = f x 

-- the "unit", called "return" 
return = Just 

-- The sample code using the lambda syntax 
-- that Brian showed 
z = f >>= (\fval -> 
    g >>= (\gval -> 
    h >>= (\hval -> return (fval+gval+hval)))) 

-- The following is exactly the same as the three lines above 
z2 = do 
    fval <- f 
    gval <- g 
    hval <- h 
    return (fval+gval+hval) 

आप देख सकते हैं अंत में अच्छा do अंकन यह सीधे जरूरी कोड की तरह लग रहे बनाता है। और वास्तव में यह डिजाइन द्वारा है। मोनैड का उपयोग अनिवार्य प्रोग्रामिंग (म्यूटेबल स्टेटस, आईओ इत्यादि) में सभी उपयोगी चीजों को समाहित करने के लिए किया जा सकता है और इस अच्छे अनिवार्य सिंटैक्स का उपयोग करके किया जाता है, लेकिन पर्दे के पीछे, यह सिर्फ मोनैड और बाइंड ऑपरेटर का चालाक कार्यान्वयन है! अच्छी बात यह है कि आप >>= और return को लागू करके अपने स्वयं के मोनैड को कार्यान्वित कर सकते हैं। और यदि आप ऐसा करते हैं तो वे monads भी do नोटेशन का उपयोग करने में सक्षम होंगे, जिसका अर्थ है कि आप मूल रूप से दो कार्यों को परिभाषित करके अपनी छोटी भाषाएं लिख सकते हैं!

Answer 6

मेरा answer देखें "एक मोनड क्या है?"

यह एक प्रेरित उदाहरण के साथ शुरू होता उदाहरण के माध्यम से काम करता है, एक इकाई का एक उदाहरण लिया गया है और औपचारिक रूप से परिभाषित करता है" इकाई "।

यह कार्यात्मक प्रोग्रामिंग की जानकारी हो जाती है और इसके साथ function(argument) := expression वाक्य रचना के साथ स्यूडोकोड का उपयोग करता है सरल संभव भाव

यह सी # कार्यक्रम स्यूडोकोड इकाई के एक कार्यान्वयन है।। (संदर्भ के लिए:।, M प्रकार निर्माता है feed "बाँध" ऑपरेशन है, और wrap "वापसी" ऑपरेशन है)

using System.IO; 
using System; 

class Program 
{ 
    public class M<A> 
    { 
     public A val; 
     public string messages; 
    } 

    public static M<B> feed<A, B>(Func<A, M<B>> f, M<A> x) 
    { 
     M<B> m = f(x.val); 
     m.messages = x.messages + m.messages; 
     return m; 
    } 

    public static M<A> wrap<A>(A x) 
    { 
     M<A> m = new M<A>(); 
     m.val = x; 
     m.messages = ""; 
     return m; 
    } 

    public class T {}; 
    public class U {}; 
    public class V {}; 

    public static M<U> g(V x) 
    { 
     M<U> m = new M<U>(); 
     m.messages = "called g.\n"; 
     return m; 
    } 

    public static M<T> f(U x) 
    { 
     M<T> m = new M<T>(); 
     m.messages = "called f.\n"; 
     return m; 
    } 

    static void Main() 
    { 
     V x = new V(); 
     M<T> m = feed<U, T>(f, feed(g, wrap<V>(x))); 
     Console.Write(m.messages); 
    } 
}