stream-fusion-0.1.1: Faster Haskell lists using stream fusionContentsIndex
Control.Monad.Stream
Portabilityportable
Stabilityprovisional
Maintainerlibraries@haskell.org
Contents
Functor and monad classes
Functions
Naming conventions
Basic functions from the Prelude
Generalisations of list functions
Conditional execution of monadic expressions
Monadic lifting operators
Description
The Functor, Monad and MonadPlus classes, with some useful operations on monads.
Synopsis
Functor (fmap)
Monad (>>=, >>, return, fail)
class Monad m => MonadPlus m where
mzero :: m a
mplus :: m a -> m a -> m a
mapM :: Monad m => (a -> m b) -> [a] -> m [b]
mapM_ :: Monad m => (a -> m b) -> [a] -> m ()
forM :: Monad m => [a] -> (a -> m b) -> m [b]
forM_ :: Monad m => [a] -> (a -> m b) -> m ()
sequence :: Monad m => [m a] -> m [a]
sequence_ :: Monad m => [m a] -> m ()
(=<<) :: Monad m => (a -> m b) -> m a -> m b
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
forever :: Monad m => m a -> m ()
join :: Monad m => m (m a) -> m a
msum :: MonadPlus m => [m a] -> m a
filterM :: Monad m => (a -> m Bool) -> [a] -> m [a]
mapAndUnzipM :: Monad m => (a -> m (b, c)) -> [a] -> m ([b], [c])
zipWithM :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m [c]
zipWithM_ :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m ()
foldM :: Monad m => (a -> b -> m a) -> a -> [b] -> m a
foldM_ :: Monad m => (a -> b -> m a) -> a -> [b] -> m ()
replicateM :: Monad m => Int -> m a -> m [a]
replicateM_ :: Monad m => Int -> m a -> m ()
guard :: MonadPlus m => Bool -> m ()
when :: Monad m => Bool -> m () -> m ()
unless :: Monad m => Bool -> m () -> m ()
liftM :: Monad m => (a1 -> r) -> m a1 -> m r
liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
ap :: Monad m => m (a -> b) -> m a -> m b
Functor and monad classes
Functor (fmap)
Monad (>>=, >>, return, fail)
class Monad m => MonadPlus m where
Monads that also support choice and failure.
Methods
mzero :: m a

the identity of mplus. It should also satisfy the equations 

 mzero >>= f  =  mzero
 v >> mzero   =  mzero

(but the instance for IO defined in Control.Monad.Error does not satisfy the second one).

mplus :: m a -> m a -> m a
an associative operation
show/hide Instances
Functions
Naming conventions

The functions in this library use the following naming conventions:

  • A postfix 'M' always stands for a function in the Kleisli category: The monad type constructor m is added to function results (modulo currying) and nowhere else. So, for example, 
  filter  ::              (a ->   Bool) -> [a] ->   [a]
  filterM :: (Monad m) => (a -> m Bool) -> [a] -> m [a]
  • A postfix '_' changes the result type from (m a) to (m ()). Thus, for example: 
  sequence  :: Monad m => [m a] -> m [a] 
  sequence_ :: Monad m => [m a] -> m ()
  • A prefix 'm' generalizes an existing function to a monadic form. Thus, for example: 
  sum  :: Num a       => [a]   -> a
  msum :: MonadPlus m => [m a] -> m a
Basic functions from the Prelude
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.
(=<<) :: Monad m => (a -> m b) -> m a -> m b
Same as >>=, but with the arguments interchanged.
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
Left-to-right Kleisli composition of monads.
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
Right-to-left Kleisli composition of monads. '(>=>)', with the arguments flipped
forever :: Monad m => m a -> m ()
forever act repeats the action infinitely.
Generalisations of list functions
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.
Conditional execution of monadic expressions
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.
Monadic lifting operators
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
Produced by Haddock version 0.8