Control.Monad.Parameterized

Implements a notion of parameterized monad by varying the monad itself, this lets us avoid having to carry a parameter around for monads that do not need it, and we can rederive the normal notion of a parameterized monad from this variation for those that do. The signature of >>= costs us type inference for the types of return and mzero, so we restore that by defining return as the unit of the Identity monad and mzero as the unit of the trivial bottom monad, and appealing to the monad laws to allow these to combine with all other monads satisfying the monad laws through >>=

Caveat: Do-notation works in a recent GHC, see also http:hackage.haskell.orgtracghcticket1537

This imports and defines the correct instances for a good portion of the MTL, primarily because it is so awkward to import them all otherwise due to the fact that most of them re-export the Control.Monad.Monad syntax. Does not export Control.Monad.ST or Control.Monad.Writer since it is unclear if you want strict or lazy versions in scope

Rebound Monad

class Return m where

The traditional return, note this probably has lost its type inference where you want to use it.

Methods

returnM :: a -> m a

Instances

Return []

Return IO

Return STM

Return Maybe

Return Identity

Return MZero

Return (ST s)

Return (ST s)

Return (Cont r)

Monad m => Return (ListT m)

Return (Reader e)

Return (State s)

Monoid w => Return (Writer w)

Monoid w => Return (Writer w)

Monad m => Return (ContT r m)

(Monad m, Error e) => Return (ErrorT e m)

Monad m => Return (ReaderT e m)

Monad m => Return (StateT s m)

(Monad m, Monoid w) => Return (WriterT w m)

(Monad m, Monoid w) => Return (WriterT w m)

class Fail m where

Restrict the cases where we allow pattern matching to fail. You have to explicitly supply this for your Monad

Methods

fail :: String -> m a

Instances

Fail []

Fail IO

Fail STM

Fail Maybe

Fail (ST s)

Fail (ST s)

Fail (Cont r)

Monad m => Fail (ListT m)

Fail (Reader e)

Fail (State s)

Monoid w => Fail (Writer w)

Monoid w => Fail (Writer w)

Monad m => Fail (ContT r m)

(Monad m, Error e) => Fail (ErrorT e m)

Monad m => Fail (ReaderT e m)

Monad m => Fail (StateT s m)

(Monad m, Monoid w) => Fail (WriterT w m)

(Monad m, Monoid w) => Fail (WriterT w m)

class (Functor m, Functor m', Functor m'') => Bind m m' m'' | m m' -> m'' where

Implement parameterized monads like Oleg's restricted monads, but vary the monad itself rather than restrict its parameters

Methods

(>>=) :: m a -> (a -> m' b) -> m'' b

(>>) :: m a -> m' b -> m'' b

Instances

Bind [] [] []

Bind [] Maybe []

Bind IO IO IO

Bind IO STM IO

Functor a => Bind a MZero MZero

Functor a => Bind a Identity a

Bind STM IO IO

Bind STM STM STM

Bind Maybe [] []

Bind Maybe Maybe Maybe

Functor a => Bind Identity a a

Bind Identity Identity Identity

Bind Identity MZero MZero

Functor a => Bind MZero a MZero

Bind MZero Identity MZero

Bind MZero MZero MZero

Bind [] IO (ListT IO)

Bind (ST s) (ST s) (ST s)

Bind (ST s) (ST s) (ST s)

Bind (Cont r) (Cont r) (Cont r)

(Functor m, Monad m) => Bind (ListT m) (ListT m) (ListT m)

Bind (Reader e) (Reader e) (Reader e)

Bind (State s) (State s) (State s)

Monoid w => Bind (Writer w) (Writer w) (Writer w)

Monoid w => Bind (Writer w) (Writer w) (Writer w)

Monad m => Bind (ContT r m) (ContT r m) (ContT r m)

(Functor m, Monad m, Error e) => Bind (ErrorT e m) (ErrorT e m) (ErrorT e m)

(Functor m, Monad m) => Bind (ReaderT e m) (ReaderT e m) (ReaderT e m)

(Functor m, Monad m) => Bind (StateT s m) (StateT s m) (StateT s m)

(Functor m, Monad m, Monoid w) => Bind (WriterT w m) (WriterT w m) (WriterT w m)

(Functor m, Monad m, Monoid w) => Bind (WriterT w m) (WriterT w m) (WriterT w m)

(=<<) :: Bind m m' m'' => (a -> m' b) -> m a -> m'' b

Rebound MonadPlus

class MPlus m m' m'' | m m' -> m'' where

Break out mplus

Methods

mplus :: m a -> m' a -> m'' a

Instances

MPlus [] [] []

MPlus a MZero a

MPlus Maybe Maybe Maybe

MPlus MZero a a

We we losing type inference for MonadZero anyways, plumb around the special cases

MPlus MZero MZero MZero

Monad m => MPlus (ListT m) (ListT m) (ListT m)

(Monad m, Error e) => MPlus (ErrorT e m) (ErrorT e m) (ErrorT e m)

class MonadZero m where

Traditional Control.Monad.mzero, note this probably has lost its type inference. You probably want mzero.

Methods

mzeroM :: m a

Instances

MonadZero []

MonadZero Maybe

Monad m => MonadZero (ListT m)

(Monad m, Error e) => MonadZero (ErrorT e m)

A bottom monad

data MZero a

Same trick using with Identity to build a canonical return, here we exploit the MonadPlus laws to make a canonical mzero. Has no members except bottom.

Instances

Functor MZero

it's trivial to map a function over nothing

Return MZero

MonadZero a => Go MZero a

MPlus a MZero a

MPlus MZero a a

We we losing type inference for MonadZero anyways, plumb around the special cases

MPlus MZero MZero MZero

Functor a => Bind a MZero MZero

Bind Identity MZero MZero

Functor a => Bind MZero a MZero

Bind MZero Identity MZero

Bind MZero MZero MZero

Convenient class aliases

class (Fail m, Return m, Bind m m m) => Monad m

When a parameterized monad can be used without varying its parameter, we can get the ease of use of the original Monad class.

Instances

(Fail m, Return m, Bind m m m) => Monad m

class (MPlus m m m, MonadZero m) => MonadPlus m

Class alias to get back an approximation of the original, easy-to-specify MonadPlus class where available

Instances

(MPlus m m m, MonadZero m) => MonadPlus m

Traditional interfaces

class Go n m where

Now of course we can have MZeros and Identitys float to the top of a do expression, so we need a way to convert them to any Monad or MonadPlus instance respectively

Methods

go :: n a -> m a

Usage: go (do something)

Instances

Go a a

Return a => Go Identity a

MonadZero a => Go MZero a

return :: a -> Identity a

An inferable version of Prelude.return

mzero :: MZero a

An inferable version of Control.Monad.mzero

Export common monads in this sugar

module Control.Concurrent.STM

module Control.Monad.Cont

module Control.Monad.Cont.Class

module Control.Monad.Error

module Control.Monad.Error.Class

module Control.Monad.Fix

module Control.Monad.Identity

module Control.Monad.List

module Control.Monad.Reader

module Control.Monad.State

module Control.Monad.Writer.Class

mapM :: Monad m => (a -> m b) -> [a] -> m [b]

mapM f is equivalent to sequence . map f.

mapM_ :: Monad m => (a -> m b) -> [a] -> m ()

mapM_ f is equivalent to sequence_ . map f.

forM :: Monad m => [a] -> (a -> m b) -> m [b]

forM is mapM with its arguments flipped

forM_ :: Monad m => [a] -> (a -> m b) -> m ()

forM_ is mapM_ with its arguments flipped

sequence :: Monad m => [m a] -> m [a]

Evaluate each action in the sequence from left to right, and collect the results.

sequence_ :: Monad m => [m a] -> m ()

Evaluate each action in the sequence from left to right, and ignore the results.

join :: Monad m => m (m a) -> m a

The join function is the conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.

msum :: MonadPlus m => [m a] -> m a

This generalizes the list-based concat function.

filterM :: Monad m => (a -> m Bool) -> [a] -> m [a]

This generalizes the list-based filter function.

mapAndUnzipM :: Monad m => (a -> m (b, c)) -> [a] -> m ([b], [c])

The mapAndUnzipM function maps its first argument over a list, returning the result as a pair of lists. This function is mainly used with complicated data structures or a state-transforming monad.

zipWithM :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m [c]

The zipWithM function generalizes zipWith to arbitrary monads.

zipWithM_ :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m ()

zipWithM_ is the extension of zipWithM which ignores the final result.

foldM :: Monad m => (a -> b -> m a) -> a -> [b] -> m a

The foldM function is analogous to foldl, except that its result is encapsulated in a monad. Note that foldM works from left-to-right over the list arguments. This could be an issue where (>>) and the `folded function' are not commutative.

       foldM f a1 [x1, x2, ..., xm]

==

       do
         a2 <- f a1 x1
         a3 <- f a2 x2
         ...
         f am xm

If right-to-left evaluation is required, the input list should be reversed.

foldM_ :: Monad m => (a -> b -> m a) -> a -> [b] -> m ()

Like foldM, but discards the result.

replicateM :: Monad m => Int -> m a -> m [a]

replicateM n act performs the action n times, gathering the results.

replicateM_ :: Monad m => Int -> m a -> m ()

Like replicateM, but discards the result.

guard :: MonadPlus m => Bool -> m ()

guard b is return () if b is True, and mzero if b is False.

when :: Monad m => Bool -> m () -> m ()

Conditional execution of monadic expressions. For example,

       when debug (putStr "Debugging\n")

will output the string Debugging\n if the Boolean value debug is True, and otherwise do nothing.

unless :: Monad m => Bool -> m () -> m ()

The reverse of when.

liftM :: Monad m => (a1 -> r) -> m a1 -> m r

Promote a function to a monad.

liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r

Promote a function to a monad, scanning the monadic arguments from left to right. For example,

    liftM2 (+) [0,1] [0,2] = [0,2,1,3]
    liftM2 (+) (Just 1) Nothing = Nothing

liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r

Promote a function to a monad, scanning the monadic arguments from left to right (cf. liftM2).

liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r

Promote a function to a monad, scanning the monadic arguments from left to right (cf. liftM2).

liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r

Promote a function to a monad, scanning the monadic arguments from left to right (cf. liftM2).

ap :: Monad m => m (a -> b) -> m a -> m b

In many situations, the liftM operations can be replaced by uses of ap, which promotes function application.

       return f `ap` x1 `ap` ... `ap` xn

is equivalent to

       liftMn f x1 x2 ... xn