The Control.Monad module provides the Functor, Monad and MonadPlus classes, together with some useful operations on monads.
| class Functor f where | 
The instances of Functor for lists, Data.Maybe.Maybe and System.IO.IO satisfy these laws.
Methods
| fmap :: (a -> b) -> f a -> f b | 
| instance Functor [] | 
| instance Functor IO | 
| instance Functor Maybe | 
| instance Ix i => Functor (Array i) | 
| class Monad m where | 
Minimal complete definition: >>= and return.
Instances of Monad should satisfy the following laws:
Instances of both Monad and Functor should additionally satisfy the law:
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 | 
| (>>) :: m a -> m b -> m b | 
| return :: a -> m a | 
| fail :: String -> m a | 
| instance Monad [] | 
| instance Monad IO | 
| instance Monad Maybe | 
| class Monad m => MonadPlus m where | 
Methods
| mzero :: m a | 
| mplus :: m a -> m a -> m a | 
| instance MonadPlus [] | 
| instance MonadPlus Maybe | 
The functions in this library use the following naming conventions:
| 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 b | 
| void :: Functor f => f a -> f () | 
| 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 | 
==
If right-to-left evaluation is required, the input list should be reversed.
| 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 () | 
will output the string Debugging\n if the Boolean value debug is True, and otherwise do nothing.
| 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 | 
is equivalent to