अतुल्यकालिक मोनाड उदाहरण

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

हमारा लक्ष्य संदेशों को प्राप्त करने और भेजने के अनुक्रम का वर्णन करना है, जब कुछ वार्ताकार के साथ संवाद करना, और संदेश प्राप्त करने और भेजने के बीच I / O (उदाहरण के लिए, डेटाबेस तक पहुंच) का उपयोग करने में सक्षम होना।

उदाहरण के लिए, आपकी पसंदीदा भाषा में कोड में इस तरह का एक संवाद, इस तथ्य को ध्यान में रखते हुए कि किसी भी समय (इनमें से किसी भी आइटम के बीच) कुछ अन्य अनुरोध आ सकते हैं, जिन्हें संसाधित करने की भी आवश्यकता हो सकती है, लेकिन गलती से इस संवाद में शामिल नहीं होना चाहिए :
1. नंबर भेजें
2. जवाब में नंबर आता है
3. हम संख्या 2 खंड से भेजते हैं
4. उत्तर फिर से संख्या है
5. हम कंसोल में संख्या 2 और खंड 4 में संख्याओं का योग प्रदर्शित करते हैं

यह इस तरह हास्केल पर दिखेगा ( example फ़ंक्शन, निश्चित रूप से, गैर-अवरुद्ध है):
example :: Int -> AIO () <br>
example v = do <br>
x <- request v<br>
y <- request ( x * x ) <br>
io $ print ( x + y ) <br>

एक अवरुद्ध समान फ़ंक्शन के साथ इसकी तुलना करें, जो उदाहरण के लिए, उपयोगकर्ता से प्रतिक्रिया का अनुरोध करता है:
example :: Int -> IO () <br>
example v = do <br>
x <- request v<br>
y <- request ( x * x ) <br>
print ( x + y ) <br>


अनावश्यक विवरणों से विचलित नहीं होने के लिए और कई कार्यक्रमों को चलाने की आवश्यकता नहीं है, मैं लेख के लिए कार्य को सरल कर दूंगा। हम चैनल ( Chan a ) को पढ़ेंगे और लिखेंगे, और संदेश टाइप (Int, String) , अर्थात संदेश संख्या और क्रमबद्ध मूल्य।

सभी आवश्यक मॉड्यूल कनेक्ट करें:

> module Test ( <br>
> ) where <br>
> <br>
> import Control . Arrow <br>
> import Control . Monad <br>
> import Control . Concurrent . MVar <br>
> import Control . Concurrent . Chan <br>
> import Control . Concurrent <br>
> import Data . List <br>
> import Data . Maybe <br>

सन्यासी लिखने से पहले, कॉलबैक पर सब कुछ करने का प्रयास करें।
संदेश भेजते समय, हमें किसी प्रकार का नंबर जेनरेट करना होगा, साथ ही सूची में कॉलबैक भी जोड़ना होगा। यानी हमें एक चर संख्या और जोड़े संख्या -> कॉलबैक की सूची की आवश्यकता होगी। हमें भी, वास्तव में, स्वयं चैनलों की आवश्यकता है। सॉकेट के विपरीत, उन्हें दो की आवश्यकता होती है, क्योंकि हम एक को लिखेंगे, और दूसरे से पढ़ेंगे। हम यह सब एक अलग प्रकार के रूप में व्यवस्थित करेंगे:

> data AState = AState { <br>
> aCurrent :: MVar Int , <br>
> aWait :: MVar [ ( Int , String -> IO () ) ] , <br>
> aChanOut :: Chan ( Int , String ) , <br>
> aChanIn :: Chan ( Int , String ) } <br>
> <br>
> newA = liftM4 AState ( newMVar 0 ) ( newMVar [] ) newChan newChan<br>

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

> listener ( AState _ w _ chIn ) = forever $ do <br>
> ( i , s ) <- readChan chIn<br>
> -- modifyMVar a -> IO (a, b) <br>
> -- .. , . <br>
> -- callback. <br>
> callback <- modifyMVar w $ \ callbacks -> do <br>
> -- callback' . <br>
> let ( past , ok ) = partition ( ( /= i ) . fst ) callbacks<br>
> -- ( ). <br>
> case ok of <br>
> ( ( _ , f ) : _ ) -> return ( past , f ) -- callback ( ). <br>
> _ -> return ( past , \ s -> return () ) -- , <br>
> callback s -- callback. <br>

ताकि "सर्वर" पर पहुंचने वाले संदेशों को पहली बार देखा जा सके, हम एक हैंडलर लिखते हैं जो आने वाले सभी संदेशों को हमारे वार्ताकार ( aChanOut चैनल में) को आउटपुट करेगा।
हम aChanOut चैनल और डिस्प्ले से पढ़ते हैं:

> tracer ( AState _ _ chOut _ ) = forever $ readChan chOut >>= print<br>


प्रोमोनाडिक तरीका

शुरू करने के लिए, हम बिना किसी मोनाड के करेंगे। एक संदेश भेजने का कार्य करते हैं।
यह एक संदेश संख्या उत्पन्न करना चाहिए, संदेश को एक स्ट्रिंग में क्रमबद्ध करें, और कॉलबैक पंजीकृत करें।
sendAndReceive1 :: AState -> String -> ( String -> IO () ) -> IO () <br>
sendAndReceive1 ( AState cur w chOut _ ) msg onMsg = do <br>
i <- modifyMVar cur ( return . ( succ &&& id ) ) -- 1 . <br>
modifyMVar_ w ( return . ( ( i , onMsg ) : ) ) -- callback. <br>
writeChan chOut ( i , msg ) -- . <br>

सिद्धांत रूप में उपयोग स्वीकार्य है, लेकिन कुछ खामियां हैं:
sendAndReceive1 a ( show 123 ) $ \ ans -> do <br>
let x = read ans -- . <br>
print x<br>
sendAndReceive1 a ( show x ) $ \ ans2 -> do <br>
-- ... <br>

सबसे पहले, आप क्रमांकन और sendAndReceive2 के फ़ंक्शन को पारित कर सकते हैं, ताकि उन्हें कॉलबैक में न लिखें और sendAndReceive2 का उपयोग करके sendAndReceive2 , उदाहरण के लिए, मानक read और डिफ़ॉल्ट रूप से show ।
sendAndReceive1 :: AState -> a -> ( a -> String ) -> ( String -> b ) -> ( b -> IO () ) -> IO () <br>
sendAndReceive1 ( AState cur w chOut _ ) msg show_ read_ onMsg = do <br>
i <- modifyMVar cur ( return . ( succ &&& id ) ) <br>
modifyMVar_ w ( return . ( ( i , onMsg . read_ ) : ) ) <br>
writeChan chOut ( i , show_ msg ) <br>
<br>
sendAndReceive2 :: ( Show a , Read b ) => AState -> a -> ( b -> IO () ) -> IO () <br>
sendAndReceive2 a msg onMsg = sendAndReceive1 a msg show read onMsg<br>
<br>
-- . <br>
sendAndReceive2 a 23 $ \ x -> do <br>
print x<br>
sendAndReceive2 a ( x + 10 ) $ \ z -> ... <br>

इस पर निवास करना संभव होगा, लेकिन तब असेंबलर को पूरी तरह से लेना संभव था, इसलिए वहां एक अधिक शक्तिशाली अमूर्त का उपयोग क्यों नहीं किया गया?

Eumonadic तरीका

यदि हम याद करते हैं कि मोनाड का मुख्य कार्य (टीसी में नहीं, बल्कि हास्केल में) टाइप ma -> (a -> mb) -> mb , तो हमारा कॉलबैक दूसरे तर्क के रूप में भीख माँगता है। लेकिन आपको वहां टाइप print की नियमित गणना करने में भी सक्षम होना चाहिए।
उन्हें किसी तरह अलग करने के लिए, दो विकल्पों के साथ एक नया प्रकार बनाएं:
1. संदेश + कॉलबैक
2. शुद्ध मूल्य

> data AS a = Send String ( String -> AIO a ) | Pure a<br>

और इसे IO सनद में लपेटें।

> data AIO a = AIO { aio :: IO ( AS a ) } <br>

इस प्रकार, हमारी गणना को दो शिविरों में विभाजित किया जाएगा: एक संदेश भेजना और बाकी सभी।

हम एक फ़ंक्शन लिखेंगे जो हमारे मठ में सामान्य IO को "उठाता है"। इसे IO के समान ही वापस करना चाहिए, लेकिन इसे Pure कंस्ट्रक्टर में लपेटना चाहिए

> io :: IO a -> AIO a<br>
<br>
io act = AIO $ do <br>
v <- act<br>
return ( Pure v ) <br>

या आसान:

> io = AIO . liftM Pure <br>

संदेश भेजने का कार्य दूसरे कंस्ट्रक्टर का उपयोग करेगा - Send , अनिवार्य रूप से कंस्ट्रक्टर में तर्कों को पैक करना:

> sendAndReceive :: a -> ( a -> String ) -> ( String -> b ) -> AIO b<br>
> sendAndReceive msg to from = AIO $ return $ Send ( to msg ) ( return . from ) <br>

और इसके लिए एक request , show का उपयोग करके, क्रमांकन के लिए read :

> request :: ( Show a , Read b ) => a -> AIO b<br>
> request msg = sendAndReceive msg show read<br>

कुछ तरकीब यह है कि हम अपने मठ में किसी चीज की गणना नहीं करते हैं, लेकिन केवल एक गणना वृक्ष की तरह कुछ का निर्माण करते हैं। अपने आप से, ये फ़ंक्शन केवल AIO प्रकार बनाते हैं।
यह एक ऐसा फंक्शन लेने का समय है जो इस सारे कचरे की गणना कर सकता है। यानी हमारे द्वारा वर्णित संवाद को निष्पादित करने के लिए (उदाहरण के लिए, example )। बनाया गया संवाद दो विकल्पों में आता है:
1. Pure - आपको केवल मूल्य निकालने और इसे वापस करने की आवश्यकता है।
2. Send - यहां मुख्य काम किया जाता है - हम एक नंबर उत्पन्न करते हैं, कॉलबैक रजिस्टर करते हैं और एक संदेश भेजते हैं।

> run :: AState -> AIO () -> IO () <br>
> run a @ ( AState cur w chOut chIn ) act = run' act where <br>
> run' ( AIO actIO ) = do <br>
> as <- actIO<br>
> case as of <br>
> Pure value -> return value<br>
> Send msg onMsg -> do <br>
> i <- modifyMVar cur ( return . ( succ &&& id ) ) -- <br>
> modifyMVar_ w ( return . ( ( i , run' . onMsg ) : ) ) -- callback. <br>
> writeChan chOut ( i , msg ) -- . <br>

अब सब कुछ instance के लिए तैयार है:

> instance Monad AIO where <br>
> return = AIO . return . Pure -- <br>
> AIO v >>= f = AIO $ do <br>
> x <- v -- AS, Send Pure? <br>
> case x of <br>
> -- Pure, callback . <br>
> Pure value -> aio $ f value<br>
> -- "" callback . <br>
> Send msg onMsg -> return $ Send msg ( \ s -> onMsg s >>= f ) <br>

आखिरी चीज जो हमें चाहिए वह है ऑपरैटिबिलिटी चेक करने के लिए एक फंक्शन, जो क्लाइंट के लिए इनकमिंग मैसेज को प्रोसेस करने के लिए listener थ्रेड शुरू करेगा और सर्वर पर आने वाले मैसेज को आउटपुट करने के लिए tracer करेगा और सर्वर से मैसेज को हमारे क्लाइंट को वापस भेजने के लिए एक फंक्शन लौटाएगा। यानी इस मामले में, हम स्वयं एक वार्ताकार के रूप में कार्य करेंगे, जिसे हम अपने ग्राहक को भेजना चाहते हैं:

> start :: IO ( AState , ( Int , String ) -> IO () ) <br>
> start = newA >>= forks where <br>
> forks a = mapM_ forkIO [ listener a , tracer a ] >> return ( a , writeChan ( aChanIn a ) ) <br>


Tydysch!

अब आप मूल उदाहरण का उपयोग करके दुभाषिया में इसे सत्यापित कर सकते हैं।
-- , - <br>
-- , <br>
ghci > ( a , f ) <- start<br>
-- <br>
ghci > run a ( example 10 ) <br>
-- <br>
( 0 , "10" ) <br>
-- <br>
ghci > run a ( example 20 ) <br>
-- , <br>
( 1 , "20" ) <br>
-- "" <br>
ghci > f ( 0 , "11" ) <br>
-- <br>
( 2 , "121" ) <br>
-- "" <br>
ghci > f ( 1 , "21" ) <br>
-- <br>
( 3 , "441" ) <br>
-- "", , "" <br>
ghci > f ( 3 , "444" ) <br>
-- <br>
465 <br>
-- "" <br>
ghci > f ( 2 , "122" ) <br>
133 <br>
ghci > <br>

जैसा कि आप देख सकते हैं, एक ही बार में दो example के लॉन्च के बावजूद, उनके साथ संवाद एक दूसरे को नहीं काटता है।

वैसे, यह सब संदेश test.lhs हास्केल में एक कार्यक्रम है, आप इसे टेस्ट करने के लिए कॉपी कर सकते हैं।

PS इस लेख को बेहतर बनाने में मेरी मदद करने के लिए pechlambda का बहुत धन्यवाद।