तीन उपयोगी साधु

ध्यान दें: नीचे दिए गए पाठ को पढ़ने से पहले, आपको पहले से ही इस बात का अंदाजा होना चाहिए कि सन्यासी क्या हैं। अगर ऐसा नहीं है, तो पहले इस पोस्ट को पढ़ें!

हमसे पहले half कार्य है:


और हम इसे कई बार लागू कर सकते हैं:

 half . half $ 8 => 2 

सब कुछ उम्मीद के मुताबिक काम करता है। लेकिन अब आपने फैसला किया कि इस समारोह के साथ क्या हो रहा है, इसका लॉग इन करना अच्छा होगा:

 half x = (x `div` 2, "    " ++ (show x) ++ "!") 

अच्छा, बहुत अच्छा। लेकिन क्या होगा यदि आप अब कई बार half आवेदन करना चाहते हैं?

 half . half $ 8 

यहाँ है कि हम क्या होता देखना चाहते हैं:


Spoiler : यह स्वचालित रूप से नहीं होगा। हमें पेन से सब कुछ पेंट करना होगा:

 finalValue = (val2, log1 ++ log2) where (val1, log1) = half 8 (val2, log2) = half val1 

ओह! यह एक लैकोनिक जैसा नहीं है

 half . half $ 8 

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

मोनाड लेखक

लेखक मोनाद एक सफेद घोड़े पर दिखाई देता है
मोनाड राइटर एक शांत व्यक्तित्व है। वह कहती है, '' चिंता मत करो, आदमी, मैं तुम्हारे लॉग की प्रक्रिया करता हूँ। "अपने साफ कोड पर वापस जाएं और ज़ेपेलिन से सबसे अधिक निचोड़ें!"

लेखक के प्रत्येक उदाहरण में एक लॉग और रिटर्न वैल्यू है:

 data Writer wa = Writer { runWriter :: (a, w) } 

लेखक हमें जैसे कोड लिखने की अनुमति देता है

 half 8 >>= half 

ठीक है, या आप <=< फ़ंक्शन का उपयोग कर सकते हैं, जो प्राप्त करने के लिए भिक्षुओं के कार्यों की संरचना है:

 half <=< half $ 8 

जो half . half $ 8 करीब है half . half $ 8 half . half $ 8 । कूल!

आप लॉग को कुछ लिखने के लिए tell सकते हैं। और return राइटर को यह मान देगा। यहां हमारा अपडेट किया गया half कार्य है:

 half :: Int -> Writer String Int half x = do tell ("I just halved " ++ (show x) ++ "!") return (x `div` 2) 

वह Writer लौटाती है:


और हम इससे मूल्य निकालने के लिए runWriter का उपयोग कर सकते हैं:

 runWriter $ half 8 => (4, "I just halved 8!") 

लेकिन सबसे अच्छी बात यह है कि अब हम half कॉल का उपयोग करके श्रृंखला बना सकते हैं >>= :

 runWriter $ half 8 >>= half => (2, "I just halved 8!I just halved 4!") 

यहाँ क्या होता है:


जादुई >>= जानता है कि दो लेखकों को कैसे संयोजित किया जाए, इसलिए हमें अपने दम पर कोई थकाऊ कोड लिखने की आवश्यकता नहीं है! यहाँ पूरी परिभाषा है >>= :


हमने पहले स्वयं उसी टेम्पलेट कोड को लिखा था, और अब >>= इस जिम्मेदारी को लिया। कूल! हम return फ़ंक्शन का भी उपयोग करते return , जो एक मूल्य लेता है और इसे एक सनक में डालता है:

 return val = Writer (val, "") 

( ध्यान दें : यह परिभाषा लगभग सही है। दरअसल, Writer Monoid हमें किसी भी Monoid को लॉग के रूप में उपयोग करने की अनुमति देता है, और यह सिर्फ एक लाइन है। मैंने इसे यहां थोड़ा सरल किया है।)

शुक्रिया मोनर राइटर!

मोनाद पाठक

मान लीजिए कि आप कुछ सेटिंग्स को कई कार्यों में पास करना चाहते हैं। बस मोनाड रीडर का उपयोग करें:


यह आपको पर्दे के पीछे ट्रांसमिशन तंत्र को छिपाते हुए, सभी कार्यों के लिए अपने अर्थ को व्यक्त करने की अनुमति देगा। उदाहरण के लिए:

 greeter :: Reader String String greeter = do name <- ask return ("hello, " ++ name ++ "!") 

greeter करने वाला मोनाद पाठक लौटाता है:


यहाँ उसकी परिभाषा है:

 data Reader ra = Reader { runReader :: r -> a } 

पाठक हमेशा एक रक्षक रहा है। गहरा घोड़ा। रीडर अलग है क्योंकि यह हमें एक फ़ंक्शन को संसाधित करने की अनुमति देता है, जो विचार करते समय भ्रमित होता है। लेकिन हम सभी समझते हैं कि हम इस फ़ंक्शन को निकालने के लिए runReader का उपयोग कर सकते हैं:


और हम इस फंक्शन में कुछ फंक्शन पास कर सकते हैं, जो तब greeter में उपयोग किया जाता है:

 runReader greeter $ "adit" => "hello, adit!" 

इस तरह, जब आप >>= उपयोग करते हैं, तो आपको एक रीडर वापस मिलना चाहिए। जब आप इसे राज्य पास करते हैं, तो इसे इस मोनाड में निहित सभी कार्यों में स्थानांतरित कर दिया जाएगा।

 m >>= k = Reader $ \r -> runReader (k (runReader mr)) r 

पाठक हमेशा कुछ जटिल रहा है। यह आम तौर पर इसकी सबसे अच्छी गुणवत्ता है।
return Reader में मूल्य डालता है:

 return a = Reader $ \_ -> a 

और अंत में, उस राज्य से ask जो आपने वापस किया था:

 ask = Reader $ \x -> x 

पाठक के साथ अधिक समय बिताना चाहते हैं? पंक रॉक को काटें और एक लंबे उदाहरण पर एक नज़र डालें।

मोनाड राज्य

स्टेट मोनाड रीडर के अधिक प्रभावशाली सबसे अच्छे दोस्त हैं:


यह बिल्कुल पाठक मोनाड के समान है, लेकिन इसकी मदद से आप न केवल पढ़ सकते हैं, बल्कि लिख भी सकते हैं!
यहाँ State की परिभाषा है:

 State sa = State { runState :: s -> (a, s) } 

आप put साथ राज्य प्राप्त कर सकते हैं या इसे बदल सकते हैं। यहाँ एक उदाहरण है:

 greeter :: State String String greeter = do name <- get put "tintin" return ("hello, " ++ name ++ "!") runState greeter $ "adit" => ("hello, adit!", "tintin") 

प्यारा! यदि पाठक "आप-मैं-नहीं-परिवर्तन" चरित्र के साथ था, तो राज्य, इसके विपरीत, रिश्तों की तलाश करता है और खुद को बदलने के लिए तैयार है।
State monad की परिभाषा monad Reader की परिभाषा के समान है:
return :

 return a = State $ \s -> (a, s) 

>>= :

 m >>= k = State $ \s -> let (a, s') = runState ms in runState (ka) s' 

निष्कर्ष

लेखक। रीडर। राज्य। आज आपने अपने हास्केल शस्त्रागार में तीन शक्तिशाली हथियार जोड़े। इनका बुद्धिमानी से उपयोग करें।

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