Aplikatory komponują, monady nie

Aplikatory komponują, monady nie.

Monady komponują , ale wynik może nie być monadą. Natomiast skład dwóch aplikantów jest koniecznie aplikatorem. Podejrzewam, że intencją oryginalnego stwierdzenia było to, że "Applicativeness composes, while monadness doesn' t. "przeredagowane," Applicative jest zamknięty pod kompozycją, a Monad nie jest."

Jeśli masz applicatives A1 i A2, wtedy typ data A3 a = A3 (A1 (A2 a)) jest również applicative (możesz napisać taką instancję w sposób ogólny).

Z drugiej strony, jeśli masz monady M1 i M2, to typ data M3 a = M3 (M1 (M2 a)) niekoniecznie jest monadą (nie ma sensownej implementacji generycznej dla >>= lub join dla kompozycji).

Przykładem może być Typ [Int -> a] (tutaj tworzymy konstruktor typu [] z (->) Int, z których oba są monadami). Możesz łatwo napisz

app :: [Int -> (a -> b)] -> [Int -> a] -> [Int -> b]
app f x = (<*>) <$> f <*> x

I to uogólnia się na dowolne zastosowanie:

app :: (Applicative f, Applicative f1) => f (f1 (a -> b)) -> f (f1 a) -> f (f1 b)

Ale nie ma sensownej definicji

join :: [Int -> [Int -> a]] -> [Int -> a]

Jeśli nie jesteś przekonany do tego, rozważ to wyrażenie:

join [\x -> replicate x (const ())]

Długość zwracanej listy musi być ustawiona w kamieniu przed podaniem liczby całkowitej, ale prawidłowa jej długość zależy od liczby całkowitej, która została podana. Tak więc dla tego typu nie może istnieć żadna poprawna funkcja join.

[1]} niestety, naszym prawdziwym celem, składem monad, jest raczej trudne. .. W rzeczywistości, my może faktycznie udowodnić, że w pewnym sensie nie ma sposobu na zbuduj funkcję join z typem powyżej używając tylko działania dwóch monad (zob. w załączniku zarys dowód). Wynika z tego, że jedynym sposobem, w jaki możemy mieć nadzieję stworzyć skład jest jeśli istnieją jakieś dodatkowe konstrukcje łączące dwa składniki.

Komponowanie monady, http://web.cecs.pdx.edu/ ~ mpj/RR-1004.pdf

Rozwiązanie prawa dystrybucyjnego l: mn - > NM wystarczy

Aby zagwarantować monadyjność NM. Aby to zobaczyć, potrzebujesz jednostki i wielomianu. skupię się na mult (Jednostka to unit_N unitM)

NMNM - l -> NNMM - mult_N mult_M -> NM

To nie gwarantuje, że MN jest monadą.

l1 : ML -> LM
l2 : NL -> LN
l3 : NM -> MN

(MN)L - >L (MN) lub przez N (LM) - > (LM) N

Mamy wystarczającą strukturę, aby stworzyć te mapy. Jednak, jak zauważa Eugenia Cheng, potrzebujemy sześciokątnego warunku (który odpowiada prezentacji równania Yang-Baxtera), aby zagwarantować monadyczność obu konstrukcji. W rzeczywistości, przy stanie sześciokątnym, dwie różne monady pokrywają się.

Oto kod tworzący monadę poprzez pracę prawa dystrybucyjnego. Zauważ, że istnieją prawa dystrybucyjne od każdej monady do monady Maybe, Either, Writer i []. Z drugiej strony, nie znajdziesz takich (ogólnych) praw dystrybucyjnych w Reader i State. Do tego potrzebne będą transformatory monad.

 {-# LANGUAGE FlexibleInstances #-}
 
 module ComposeMonads where
 import Control.Monad
 import Control.Monad.Writer.Lazy
 
 newtype Compose m1 m2 a = Compose { run :: m1 (m2 a) }
 
 instance (Functor f1, Functor f2) => Functor (Compose f1 f2) where
   fmap f = Compose . fmap (fmap f) . run
 
 class (Monad m1, Monad m2) => DistributiveLaw m1 m2 where
   dist :: m2 (m1 a) -> m1 (m2 a)
 
 instance (Monad m1,Monad m2, DistributiveLaw m1 m2)
           => Applicative (Compose m1 m2) where
     pure = return
     (<*>) = ap
 
 instance (Monad m1, Monad m2, DistributiveLaw m1 m2)
           => Monad (Compose m1 m2) where
   return = Compose . return . return
   Compose m1m2a >>= g =
     Compose $ do m2a <- m1m2a -- in monad m1
                  m2m2b <- dist $ do a <- m2a  -- in monad m2
                                     let Compose m1m2b = g a
                                     return m1m2b
                                  -- do ... ::  m2 (m1 (m2 b))
                           -- dist ... :: m1 (m2 (m2 b))          
                  return $ join m2m2b -- in monad m2
 
 instance Monad m => DistributiveLaw m Maybe where
   dist Nothing = return Nothing
   dist (Just m) = fmap Just m
 
 instance Monad m => DistributiveLaw m (Either s) where
   dist (Left s) = return $ Left s
   dist (Right m) = fmap Right m
 
 instance Monad m => DistributiveLaw m [] where
   dist = sequence
 
 instance (Monad m, Monoid w) => DistributiveLaw m (Writer w) where
   dist m = let (m1,w) = runWriter m
            in do a <- m1
                  return $ writer (a,w)
 
 liftOuter :: (Monad m1, Monad m2, DistributiveLaw m1 m2) =>
                    m1 a -> Compose m1 m2 a
 liftOuter = Compose . fmap return
 
 liftInner :: (Monad m1, Monad m2, DistributiveLaw m1 m2) =>
                    m2 a -> Compose m1 m2 a
 liftInner = Compose . return