क्या दो मोनैड ट्रांसफार्मर लिखने के लिए एक सिद्धांत है यदि वे अलग-अलग प्रकार के हैं, लेकिन उनका अंतर्निहित मोनड एक ही प्रकार का है?

Question

प्रश्न का विस्तार करने के लिए मैं इतना कुछ नहीं कर सकता। लेकिन यहाँ एक उपयोग मामला है: मान लीजिए कि आप दो इकाई ट्रांसफॉर्मर, t और s है, एक ही इकाई m से अधिक बदलने करते हैं:

master :: (MonadTrans t, Monad m) => t m a b 
slave :: (MonadTrans t, Monad m) => s m a b 

और मैं master रचना करना चाहते हैं और slave ऐसी है कि वे एक दूसरे के साथ संवाद कर सकते हैं जब m प्राइमेटिव को t और s में हटाया गया है। हस्ताक्षर हो सकता है:

bound :: (MonadTrans t, MonadTrans s, Monad m, Monoid a) => t m a b -> s m a b -> (...) 
But what is the type of (...) ? 

एक उपयोग के मामले, sugared अंकन में:

master :: Monoid a => a -> t m a b 
master a = do 
    a <- lift . send $ (a,False)  -- * here master is passing function param to slave 
    ...        -- * do some logic with a 
    b <- lift . send $ (mempty,True) -- * master terminates slave, and get back result 

slave :: Monoid a => (a -> b) -> s m a b 
slave g = do 
    (a,end) <- lift receive 
    case end of 
     True -> get >>= \b -> exit b 
     _ -> (modify (++[g a])) >> slave g 

अद्यतन: send और receive प्रकार m की पुरातन हैं।

मैं क्षमा चाहता हूं कि यह उदाहरण दूषित दिखता है, या कोरआउट के समान दिखता है, प्रश्न की भावना के साथ वास्तव में इसके साथ कुछ लेना देना नहीं है, इसलिए कृपया सभी समानताओं को अनदेखा करें। लेकिन मुख्य बिंदु यह है कि मोनैड t और s को एक-दूसरे के साथ समझदारी से तैयार नहीं किया जा सका, लेकिन दोनों अंतर्निहित मोनाड m को लपेटने के बाद, अब उन्हें एक ही समारोह के रूप में बनाया और चलाया जा सकता है। रचनात्मक कार्य के प्रकार के लिए, मुझे वास्तव में यकीन नहीं है कि कुछ दिशा की सराहना की जाती है। अब अगर यह अमूर्तता पहले से मौजूद है और मुझे इसके बारे में पता नहीं है, तो यह सबसे अच्छा होगा।

Answer 1

हां। lift साथ mmorph पैकेज से hoist कम्बाइन यह करने के लिए:

bound 
    :: (MonadTrans t, MonadTrans s, MFunctor t, Monad m) 
    => t m() -> s m() -> t (s m)() 
bound master slave = do 
    hoist lift master 
    lift slave 

को समझने के लिए क्यों यह काम करता है, hoist के प्रकार का अध्ययन:

hoist :: (MFunctor t) => (forall x . m x -> n x) -> t m r -> t n r 

hoist आप किसी भी इकाई के ट्रांसफार्मर के आधार इकाई को संशोधित करने देता है MFunctor लागू करता है (जो उनमें से अधिकतर है)।

bound के लिए कोड क्या है दो मोनाड ट्रांसफार्मर अंतिम लक्ष्य मोनैड पर सहमत हैं, जो इस मामले में t (s m) है। ऑर्डर जिसमें आप t और s घोंसला करते हैं, इसलिए मैंने अभी माना है कि आप बाहर t चाहते थे।

तो अंतिम मोनैड स्टैक पर सहमत होने के लिए दो सब-कंप्यूटेशंस प्राप्त करने के लिए hoist और lift के विभिन्न संयोजनों का उपयोग करना सिर्फ एक मामला है। पहले एक इस तरह काम करता है:

master :: t m r 
hoist lift master :: t (s m) r 

दूसरा एक इस तरह काम करता है:

slave :: s m r 
lift slave :: t (s m) r 

अब वे दोनों इस बात से सहमत हैं तो हम उन्हें एक ही do ब्लॉक के भीतर क्रम सकते हैं और यह "बस काम" होगा।

के बारे में कैसे hoist काम करता है, मैं सुझाव है कि आप जो तल पर a nice tutorial है mmorph पैकेज के लिए the documentation जाँच अधिक जानने के लिए।