वैकल्पिक, मोनाडप्लस (लेडकैच) और मोनाडप्लस (लेफ्टडिस्टिवेटिव) के बीच क्या संबंध हैं?

Question

इसके बाद क्या एक मोनड का उदाहरण है जो एक वैकल्पिक है लेकिन एक मोनडप्लस नहीं है? :

मान लें एक इकाई है। संबंधों betweem क्या हैं मीटर एक जा रहा है वैकल्पिक , एक MonadPlusCatch और एक MonadPlusDistr ? $m$$m$छह संभव जोड़े में से प्रत्येक के लिए, मैं या तो एक सबूत है कि एक दूसरे का मतलब है, या एक काउंटर उदाहरण है कि यह नहीं है करना चाहते हैं।

(मैं उपयोग कर रहा हूँ

• MonadPlusCatch एक अलग करने के लिए MonadPlus कि संतुष्ट वाम पकड़ने नियम:

  mplus (return a) b = return a
  

• MonadPlusDistr एक MonadPlus भेद करने के लिए जो वाम-वितरण नियम को पूरा करता है:

  mplus a b >>= k = mplus (a >>= k) (b >>= k)
  

HaskellWiki पर मोनाडप्लस देखें ।)

---

मेरा वर्तमान ज्ञान + अंतर्ज्ञान यह है:

1. मोनाडप्लसडिस्ट वैकल्पिक - संभावित सच - यह सीधा लगता है, मेरा मानना ​​है कि मेरे पास एक सबूत का स्केच है, मैं इसकी जांच करूंगा और अगर यह सही है, तो मैं इसे पोस्ट करूंगा एंड्रयूके ने इस हिस्से का जवाब दिया।$\rightarrow$
2. $\rightarrow$ Maybe

3. $\rightarrow$ MaybeT (Either e)MaybeT m'

   ((pure x) <|> g) <*> a =    -- LeftCatch
       (pure x) <*> a
   -- which in general cannot be equal to
   ((pure x) <*> a) <|> (g <*> a)
   

   फिर से जाँच करूँगा और पोस्ट करूँगा। (दिलचस्प बात Maybeयह है कि सिर्फ यह साबित करने के लिए है, क्योंकि हम विश्लेषण कर सकते हैं कि क्या aहै Just somethingया Nothing- उपरोक्त एंड्रयूज का जवाब देखें।)

4. $\rightarrow$ $\rightarrow$ [][]
5. $\rightarrow$ []
6. $\rightarrow$ Maybe

Answer 1

$\rightarrow$

$\rightarrow$

(क्योंकि के रूप में पेट्र Pudlák ने कहा, []प्रति एक है - यह संतुष्ट नहीं करता MonadPlusCatch लेकिन संतुष्ट करता है MonadPlusDist , इसलिए अनुप्रयोगी )

मान लिया गया: मोनाडप्लसडिस्ट कानून

-- (mplus,mzero) is a monoid
mzero >>= k = mzero`                             -- left identity >>=
(a `mplus` b) >>= k  =  (a >>=k) `mplus` (b>>=k) -- left dist mplus

साबित करने के लिए: वैकल्पिक कानून

-- ((<|>),empty) is a monoid
(f <|> g) <*> a = (f <*> a) <|> (g <*> a) -- right dist <*>
empty <*> a = empty                       -- left identity <*>
f <$> (a <|> b) = (f <$> a) <|> (f <$> b) -- left dist <$>
f <$> empty = empty                       -- empty fmap

<*>विस्तार लेम्मा
मान लें कि हम एक सनद से एक आवेदक के मानक व्युत्पत्ति का उपयोग करते हैं, अर्थात् (<*>) = apऔर pure = return। फिर

mf <*> mx = mf >>= \f -> mx >>= \x -> return (f x)

चूंकि

mf <*> mx = ap mf mx                                  -- premise
          = liftM2 id mf mx                           -- def(ap)
          = do { f <- mf; x <- mx; return (id f x) }  -- def(liftM2)
          = mf >>= \f -> mx >>= \x -> return (id f x) -- desugaring
          = mf >>= \f -> mx >>= \x -> return (f x)    -- def(id)

<$>विस्तार लेम्मा
मान लें कि हम एक संन्यासी से एक फ़नकार के मानक व्युत्पत्ति का उपयोग करते हैं, अर्थात् (<$>) = liftM। फिर

f <$> mx = mx >>= return . f

चूंकि

f <$> mx = liftM f mx                    -- premise
         = do { x <- mx; return (f x) }  -- def(liftM)
         = mx >>= \x -> return (f x)     -- desugaring
         = mx >>= \x -> (return.f) x     -- def((.))
         = mx >>= return.f               -- eta-reduction 

सबूत

मान लें ( <+>, m0) MonadPlus कानूनों को संतुष्ट। तुच्छ रूप से यह एक मोनॉयड है।

राइट डिस्ट <*>

मैं साबित कर दूंगा

(mf <+> mg) <*> ma = (mf <*> ma) <+> (mg <*> ma) -- right dist <*>

क्योंकि यह अंकन पर आसान है।

(mf <+> mg) <*> ma = (mf <+> mg) >>= \forg -> mx >>= \x -> return (forg x) -- <*> expansion
                   =     (mf >>= \f_g -> mx >>= \x -> return (f_g x))
                     <+> (mg >>= \f_g -> mx >>= \x -> return (f_g x))      -- left dist mplus
                   = (mf <*> mx) <+> (mg <*> mx)                           -- <*> expansion

लेफ्ट आइडेंटिटी <*>

mzero <*> mx = mzero >>= \f -> mx >>= \x -> return (f x) -- <*> expansion
             = mzero                                     -- left identity >>=

जैसी ज़रूरत।

परेशान छोड़ दिया <$>

f <$> (a <|> b) = (f <$> a) <|> (f <$> b) -- left dist <$>

f <$> (a <+> b) = (a <+> b) >>= return . f              -- <$> expansion
                = (a >>= return.f) <+> (b >>= return.f) -- left dist mplus
                = (f <$> a) <+> (f <$> b)               -- <$> expansion

empty fmap

f <$> mzero = mzero >>= return.f   -- <$> expansion
            = mzero                -- left identity >>=

जैसी ज़रूरत

Comments

महान। मुझे यह भी संदेह है कि वामपंथी कानून किसी भी आवेदन के लिए सही कानूनों द्वारा निहित हैं , लेकिन मेरे पास अब तक कोई सबूत नहीं है। अंतर्ज्ञान यह है कि f <$>कोई मुहावरेदार कार्रवाई नहीं करता है, यह शुद्ध है, इसलिए किसी भी तरह "पक्षों को स्विच करना" संभव हो सकता है।

— पेट्र पुडलक

@ PetrPudlák अपडेट किया गया - समाप्त साक्ष्य और के बारे में अपना कोरोलरी जोड़ा []।

— एंड्रयूज

@ PetrPudlák क्या आपको लगता है कि हमें एक सबूत जोड़ना चाहिए जो MonadPlusCatch को[] संतुष्ट करता है? फिलहाल यह हास्केलविक पर एक जोर है। >>= kस्पष्ट रूप से परिभाषित किया गया हैfoldr ((++).k)

— एंड्रयूज

मुझे लगता है आप MonadPlusDist मतलब है , है ना? मुझे लगता है कि हम कर सकते हैं, यह कोरोलरी के प्रमाण को पूरा करेगा।

— पेट्र पुडलक

@ PetrPudlák ओह हाँ मुझे खेद है। करूँगा।

— एंड्रयूज

Answer 2

मोनाडप्लसकैच लिए एक काउंटर-उदाहरण$\rightarrow$

वास्तव में यह है MaybeT Either:

{-# LANGUAGE FlexibleInstances #-}
import Control.Applicative
import Control.Monad
import Control.Monad.Trans.Maybe

instance (Show a, Show b) => Show (MaybeT (Either b) a) where
    showsPrec _ (MaybeT x) = shows x

main = print $
    let
        x = id :: Int -> Int
        g = MaybeT (Left "something")
        a = MaybeT (Right Nothing)
    -- print the left/right side of the left distribution law of Applicative:
    in ( ((return x) `mplus` g) `ap` a
       , ((return x) `ap` a) `mplus` (g `ap` a)
       )

आउटपुट है

(Right Nothing, Left "something")

जिसका अर्थ है कि MaybeT Eitherबाएं वितरण कानून विफल हो जाता है Applicative।

---

कारण यह है कि

(return x `mplus` g) `ap` a

अनदेखा g( वाममार्गी के कारण ) और सिर्फ करने के लिए मूल्यांकन करता है

return x `ap` a

लेकिन यह दूसरे पक्ष के मूल्यांकन से अलग है:

g `ap` a