मोनाद कंट्ट इन पिक्चर्स (हास्केल)

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

अंदर ContT

सबसे पहले, ContT की परिभाषा पर एक नज़र डालें ।

newtype ContT rma = ContT {runContT :: ((a -> mr) -> mr)} 

प्रकार को देखते हुए, किसी तरह यह तुरंत असहज हो जाता है। और कॉलसीसी के प्रकार से यह और भी असहज हो जाता है।

 callCC :: ((a -> mb) -> ma) -> ma 

चलो ठीक है।
इसके साथ शुरू करने के लिए, यह ध्यान देने योग्य है कि यदि आपके पास "(a-> mr) -> m r" का चर है, तो यह लगभग वैसा ही है जैसे कि आपके पास "a" प्रकार का चर है। यहाँ देखो। मान लीजिए कि आपके पास “a” और “a-> mr” का फंक्शन है। आप एक दूसरे के लिए आवेदन कर सकते हैं और परिणाम प्राप्त कर सकते हैं "श्री":

 a -> mr $ a = mr 

अब कल्पना करें कि आपके पास "(a-> mr) -> m r" और फ़ंक्शन "a -> mr" का एक चर है। आप एक से दूसरे तरीके से आवेदन कर सकते हैं और अपना परिणाम प्राप्त कर सकते हैं:

 (a -> mr) -> mr $ (a -> mr) = mr 

चलिए तस्वीरों को आगे बढ़ाते हैं।
एक तीर के साथ इस तरह के एक सर्कल के साथ हम टाइप "ए" के कुछ ऑब्जेक्ट को सूचित करेंगे।


"A-> b" जैसा एक फ़ंक्शन एक सर्कल की तरह दिखेगा जिसमें एक इनपुट और एक आउटपुट है:


तब हमारा ContT रिंग की तरह दिखेगा:


यदि हम फ़ंक्शन "a-> b" को ऑब्जेक्ट पर लागू करते हैं तो (a-> mr) -> m r ", हम इसे बनाए रखते हैं:


और अब सबसे महत्वपूर्ण बात। हमें याद है कि ContT एक सन्यासी है, जिसका अर्थ है कि रिटर्न और बाइंड फ़ंक्शन इसके लिए परिभाषित हैं। देखते हैं कि वे क्या करते हैं।

वापसी के साथ , सब कुछ बहुत सरल है। यह पारित किए गए फ़ंक्शन में ऑब्जेक्ट को प्रतिस्थापित करता है, और परिणाम सीधे बाहर की ओर लौटता है।
यह कैसे काम करता है।

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

उदाहरण

फाइलों के साथ काम करें

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

 withFileContent :: FilePath -> (String -> IO a) -> IO a withFileContent file fun = withFile file ReadMode $ \h -> hGetContents h >>= fun main = do withFileContent "1.txt" $ \file1_content -> do withFileContent file1_content $ \file2_content -> do withFileContent file2_content $ \file3_content -> do print file3_content 

यहां आप देख सकते हैं कि प्रत्येक नई खुली फ़ाइल के साथ इंडेंटेशन कैसे बढ़ता है। इस टुकड़े को फिर से लिखना बहुत अच्छा होगा ताकि सभी फाइलें एक ही मोनाड के अंदर खुलें। आइए withFileContent फ़ंक्शन को देखें। हम देखते हैं कि इसका प्रकार ContT प्रकार के समान है। चलिए ContT monad का उपयोग करके हमारे उदाहरण को फिर से लिखते हैं ।

 doContT cont = runContT cont (const $ return ()) main = doContT $ do file1_content <- ContT $ withFileContent "1.txt" file2_content <- ContT $ withFileContent file1_content file3_content <- ContT $ withFileContent file2_content liftIO $ print file3_content 

इतना अधिक सुंदर। लगता है कि यह कार्यक्रम कैसे काम करेगा? फाइलें पहले दिए गए अनुक्रम में खोली जाएंगी, फिर परिणाम स्क्रीन पर प्रदर्शित किया जाएगा, और फिर फाइलों को रिवर्स ऑर्डर में बंद कर दिया जाएगा। यह बहुत अच्छा नहीं है!

कंस्ट्रक्टर, विध्वंसक

मान लीजिए, किसी वस्तु के साथ काम करने के लिए, हमें पहले इसके लिए कंस्ट्रक्टर को कॉल करने की आवश्यकता है, और काम के बाद - विध्वंसक। ऐसी वस्तुओं के लिए एक प्रकार की कक्षा बनाएँ।

 class Constructed a where constructor :: a -> IO () destructor :: a -> IO () 

चलो कुछ परीक्षण वस्तु बनाते हैं।

 newtype Obj a = Obj a instance (Show a) => Constructed (Obj a) where constructor (Obj a) = putStr $ "constructor for " ++ (show a) ++ "\n" destructor (Obj a) = putStr $ "destructor for " ++ (show a) ++ "\n" 

हम ContT में ऐसी वस्तुओं के साथ काम करने के लिए एक फ़ंक्शन लिखेंगे । अब वे स्वचालित रूप से निर्माता और विध्वंसक (रिवर्स ऑर्डर में) कॉल करेंगे।

 withConstructed :: (Constructed a) => a -> ContT r IO a withConstructed obj = ContT $ \fun -> do constructor obj rez <- fun obj destructor obj return rez main = doContT $ do a <- withConstructed $ Obj "ObjectA" b <- withConstructed $ Obj "ObjectB" c <- withConstructed $ Obj "ObjectC" liftIO $ putStr "do something\n" {- : constructor for "ObjectA" constructor for "ObjectB" constructor for "ObjectC" do something destructor for "ObjectC" destructor for "ObjectB" destructor for "ObjectA" -} 

इंटरप्ट कम्प्यूटिंग

पिछले उदाहरण बहुत सरल और अनिवार्य रूप से समान थे। और हम गणना के अंत की प्रतीक्षा किए बिना कुछ परिणाम वापस करने के लिए ContT का उपयोग कैसे करते हैं? एक उदाहरण पर विचार करें। मान लीजिए कि ContT में कुछ गणना है।

 calc :: ContT rm Int calc = do x <- return 10 y <- return $ x*2 z <- return $ x + y return z main = runContT calc print -- : 30 

निम्नानुसार कैल्क करें

 calc = ContT $ \k -> runContT (do -- <- /  x <- return 10 y <- return $ x*2 z <- return $ x + y return z) k main = runContT calc print -- : 30 

हमने कुछ भी नहीं बदला, बस कंस्ट्रक्टर को हटा दिया, और फिर इसे कंस्ट्रक्टर में लपेट दिया।
अब एक पंक्ति जोड़ें।

 calc = ContT $ \k -> runContT (do x <- return 10 y <- return $ x*2 ContT $ \c -> c 5 -- <-   ( "return 5") z <- return $ x + y return z) k main = runContT calc print -- : 30 

परिणाम अभी भी अपरिवर्तित है। आश्चर्य की बात नहीं है, लाइन "ContT $ \ c -> c 5" लाइन "रिटर्न 5" के बराबर है।
और अब सबसे कठिन हिस्सा है। आइए “c” को “k” से बदलें।

 calc = ContT $ \k -> runContT (do x <- return 10 y <- return $ x*2 ContT $ \c -> k 5 -- <-    "c"  "k" z <- return $ x + y return z) k main = runContT calc print -- <-  "print"   ContT -- : 5 -- <-   

हम देखते हैं कि परिणाम अब 5 के बराबर है। यहां क्या हुआ यह स्पष्ट करना मुश्किल है, लेकिन मैं कोशिश करूंगा। आकृति पर विचार करें।

नारंगी वलय हमारा स्थानीय वैरिएबल c है। ये गणनाएं हैं जो लाइन के बाद जाती हैं "ContT $ \ c -> k 5"। हरे रंग का सर्कल हमारा k वेरिएबल है। यदि हम कोड में आगे देखते हैं, तो हम देखेंगे कि "k" एक प्रिंट फ़ंक्शन से अधिक कुछ नहीं है।
इस प्रकार, हम चर "c" के लिए अपना मान "5" पास करते हैं, जो परिणाम प्रदर्शित करने के लिए प्रिंट फ़ंक्शन का उपयोग करता है। यदि हम “c” को “k” से बदलते हैं, तो हमें निम्न चित्र मिलते हैं।

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

 calc = ContT $ \k -> runContT (do x <- return 10 y <- return $ x*2 (\a -> ContT $ \c -> ka) 5 -- <-    "a" z <- return $ x + y return z) k 

कोष्ठक लैंबडा "(\ a -> ContT $ \ c -> ka)"।

 calc = ContT $ \k -> runContT ((\exit -> do -- <-    "exit" x <- return 10 y <- return $ x*2 exit 5 z <- return $ x + y return z) (\a -> ContT $ \c -> ka)) k 

अब हम पूरे एक्सप्रेशन "\ exit -> do ... return z" को निकालेंगे।

 calc = (\f -> ContT $ \k -> runContT (f (\a -> ContT $ \c -> ka)) k) $ \exit -> do -- ^    "f" x <- return 10 y <- return $ x*2 exit 5 z <- return $ x + y return z 

शरीर के साथ एक अलग फ़ंक्शन बनाना आवश्यक होगा "(\ f -> ContT ... ka)) k)"। वैसे, बधाई! हमने सिर्फ बाइक कॉलसीसी फ़ंक्शन का आविष्कार किया।

 callCC f = ContT $ \k -> runContT (f (\a -> ContT $ \_ -> ka)) k calc = callCC $ \exit -> do -- <-     "callCC" x <- return 10 y <- return $ x*2 exit 5 z <- return $ x + y return z 

बेशक, कार्यक्रम बिल्कुल बेवकूफ निकला, जिसके लिए हमने गणना को बाधित करना सीखा।

पुनश्च

मैंने उसी तरह से getCC फ़ंक्शन बॉडी को निकालने की कोशिश की और महसूस किया कि इसके लिए पर्याप्त दिमाग नहीं था। शायद आप कर सकते हैं।