Control.Monad.PlusMonad

A construction combining two monads, based on the work of Luth and Ghani, "Composing Monads Using Coproducts."

Documentation

data Composition m n t

Instances

Monad m => MonadTrans (Composition m)

(Dist m, Dist n, Monad m, Monad n) => Monad (Composition m n)

(Functor m, Functor n) => Functor (Composition m n)

(Dist m, Dist n, Monad m, Monad n) => Applicative (Composition m n)

(Dist m, Dist n, Monad m, MonadPlus n) => Alternative (Composition m n)

(Dist m, Dist n, Monad m, MonadPlus n) => MonadPlus (Composition m n)

(Dist m, Dist n, Monad m, Monad n, MonadIO n) => MonadIO (Composition m n)

(Dist m, Dist n, Monad m, Monad n) => Dist (Composition m n)

type (::+) m n = Yoneda (Composition m n)

The following construction on two monads is a monad provided the two monads have extended distributive laws, defined below.

class Dist n where

An extended distributive law allows one to permute two layers.

Laws are:

>>> join . T dist = dist . join :: TTS -> TST
>>> TS join . dist . dist = dist :: TS -> TST

Methods

dist :: Applicative m => n (m t) -> n (m (n t))

Instances

Dist []

Dist IO

Dist Identity

Dist Maybe

Dist File

Dist (Either t)

(Dist m, Functor m) => Dist (Yoneda m)

Dist (StateT s Identity)

Error e => Dist (ErrorT e Identity)

Monoid s => Dist (WriterT s Identity)

(Dist m, Dist n, Monad m, Monad n) => Dist (Composition m n)

leftMap :: (Monad m, Functor n, Functor x) => (forall u. m u -> n u) -> (m ::+ x) t -> (n ::+ x) t

Left and right maps...

rightMap :: (Monad x, Monad m, Functor n) => (forall u. m u -> n u) -> (x ::+ m) t -> (x ::+ n) t

inl :: (Dist m, Dist n, Monad m, Monad n) => m t -> (m ::+ n) t

Injections into the ::+ type.

inr :: (Dist m, Dist n, Monad m, Monad n) => n t -> (m ::+ n) t

sym :: Monad m => (m ::+ m) t -> m t

If you have a ::+ over a monad, you can extract the underlying action.

commute :: (Monad m, Monad n) => (m ::+ n) t -> (n ::+ m) t

::+ is commutative.

mapPlus :: (Monad m, Monad n, Functor m1, Functor n1) => (forall u. m u -> m1 u) -> (forall u. n u -> n1 u) -> (m ::+ n) t -> (m1 ::+ n1) t

refl :: MonadPlus m => (m ::+ m) t -> m t

Example

data File t

Example of an IO-performing ADT.

Instances

Monad File

Functor File

Applicative File

Dist File

runFile :: File b -> FilePath -> IO b

readLine :: File String