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