



Synopsis 



Documentation 


Monads that also support choice and failure.
  Methods   the identity of mplus. It should also satisfy the equations
mzero >>= f = mzero
v >> mzero = mzero
(but the instance for System.IO.IO defined in Control.Monad.Error
in the mtl package does not satisfy the second one).
  mplus :: m a > m a > m a  Source 
 an associative operation

  Instances  



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.



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



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.



The reverse of when.



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



This generalizes the listbased concat function.



This generalizes the listbased filter function.


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

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 statetransforming monad.


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

The zipWithM function generalizes zipWith to arbitrary monads.


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

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


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

The foldM function is analogous to foldl, except that its result is
encapsulated in a monad. Note that foldM works from lefttoright 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 righttoleft evaluation is required, the input list should be reversed.



Promote a function to a monad.


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

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  Source 

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  Source 

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  Source 

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



The Monad class defines the basic operations over a monad,
a concept from a branch of mathematics known as category theory.
From the perspective of a Haskell programmer, however, it is best to
think of a monad as an abstract datatype of actions.
Haskell's do expressions provide a convenient syntax for writing
monadic expressions.
Minimal complete definition: >>= and return.
Instances of Monad should satisfy the following laws:
return a >>= k == k a
m >>= return == m
m >>= (\x > k x >>= h) == (m >>= k) >>= h
Instances of both Monad and Functor should additionally satisfy the law:
fmap f xs == xs >>= return . f
The instances of Monad for lists, Data.Maybe.Maybe and System.IO.IO
defined in the Prelude satisfy these laws.
  Methods  (>>=) :: m a > (a > m b) > m b  Source 
 Sequentially compose two actions, passing any value produced
by the first as an argument to the second.
  (>>) :: m a > m b > m b  Source 
 Sequentially compose two actions, discarding any value produced
by the first, like sequencing operators (such as the semicolon)
in imperative languages.
   Inject a value into the monadic type.
   Fail with a message. This operation is not part of the
mathematical definition of a monad, but is invoked on patternmatch
failure in a do expression.

  Instances  



The Functor class is used for types that can be mapped over.
Instances of Functor should satisfy the following laws:
fmap id == id
fmap (f . g) == fmap f . fmap g
The instances of Functor for lists, Data.Maybe.Maybe and System.IO.IO
defined in the Prelude satisfy these laws.
  Methods  fmap :: (a > b) > f a > f b  Source 

  Instances  



mapM f is equivalent to sequence . map f.



mapM_ f is equivalent to sequence_ . map f.



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



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



Same as >>=, but with the arguments interchanged.


Produced by Haddock version 2.6.0 