<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Control.Monad</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[ window.onload = function () {pageLoad();setSynopsis("mini_Control-Monad.html");}; //]]> </script></head><body><div id="package-header"><ul class="links" id="page-menu"><li><a href="index.html">Contents</a></li><li><a href="doc-index.html">Index</a></li></ul><p class="caption">base-4.3.1.0: Basic libraries</p></div><div id="content"><div id="module-header"><table class="info"><tr><th>Portability</th><td>portable</td></tr><tr><th>Stability</th><td>provisional</td></tr><tr><th>Maintainer</th><td>libraries@haskell.org</td></tr></table><p class="caption">Control.Monad</p></div><div id="table-of-contents"><p class="caption">Contents</p><ul><li><a href="#g:1">Functor and monad classes </a></li><li><a href="#g:2">Functions </a><ul><li><a href="#g:3">Naming conventions </a></li><li><a href="#g:4">Basic <code>Monad</code> functions </a></li><li><a href="#g:5">Generalisations of list functions </a></li><li><a href="#g:6">Conditional execution of monadic expressions </a></li><li><a href="#g:7">Monadic lifting operators </a></li></ul></li></ul></div><div id="description"><p class="caption">Description</p><div class="doc"><p>The <code><a href="Control-Monad.html#t:Functor">Functor</a></code>, <code><a href="Control-Monad.html#t:Monad">Monad</a></code> and <code><a href="Control-Monad.html#t:MonadPlus">MonadPlus</a></code> classes, with some useful operations on monads. </p></div></div><div id="synopsis"><p id="control.syn" class="caption expander" onclick="toggleSection('syn')">Synopsis</p><ul id="section.syn" class="hide" onclick="toggleSection('syn')"><li class="src short"><span class="keyword">class</span> <a href="#t:Functor">Functor</a> f <span class="keyword">where</span><ul class="subs"><li><a href="#v:fmap">fmap</a> :: (a -> b) -> f a -> f b</li></ul></li><li class="src short"><span class="keyword">class</span> <a href="#t:Monad">Monad</a> m <span class="keyword">where</span><ul class="subs"><li><a href="#v:-62--62--61-">(>>=)</a> :: <span class="keyword">forall</span> a b. m a -> (a -> m b) -> m b</li><li><a href="#v:-62--62-">(>>)</a> :: <span class="keyword">forall</span> a b. m a -> m b -> m b</li><li><a href="#v:return">return</a> :: a -> m a</li><li><a href="#v:fail">fail</a> :: <a href="Data-Char.html#t:String">String</a> -> m a</li></ul></li><li class="src short"><span class="keyword">class</span> <a href="Control-Monad.html#t:Monad">Monad</a> m => <a href="#t:MonadPlus">MonadPlus</a> m <span class="keyword">where</span><ul class="subs"><li><a href="#v:mzero">mzero</a> :: m a</li><li><a href="#v:mplus">mplus</a> :: m a -> m a -> m a</li></ul></li><li class="src short"><a href="#v:mapM">mapM</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a -> m b) -> [a] -> m [b]</li><li class="src short"><a href="#v:mapM_">mapM_</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a -> m b) -> [a] -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a></li><li class="src short"><a href="#v:forM">forM</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => [a] -> (a -> m b) -> m [b]</li><li class="src short"><a href="#v:forM_">forM_</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => [a] -> (a -> m b) -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a></li><li class="src short"><a href="#v:sequence">sequence</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => [m a] -> m [a]</li><li class="src short"><a href="#v:sequence_">sequence_</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => [m a] -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a></li><li class="src short"><a href="#v:-61--60--60-">(=<<)</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a -> m b) -> m a -> m b</li><li class="src short"><a href="#v:-62--61--62-">(>=>)</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a -> m b) -> (b -> m c) -> a -> m c</li><li class="src short"><a href="#v:-60--61--60-">(<=<)</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (b -> m c) -> (a -> m b) -> a -> m c</li><li class="src short"><a href="#v:forever">forever</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => m a -> m b</li><li class="src short"><a href="#v:void">void</a> :: <a href="Control-Monad.html#t:Functor">Functor</a> f => f a -> f <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a></li><li class="src short"><a href="#v:join">join</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => m (m a) -> m a</li><li class="src short"><a href="#v:msum">msum</a> :: <a href="Control-Monad.html#t:MonadPlus">MonadPlus</a> m => [m a] -> m a</li><li class="src short"><a href="#v:mfilter">mfilter</a> :: <a href="Control-Monad.html#t:MonadPlus">MonadPlus</a> m => (a -> <a href="Data-Bool.html#t:Bool">Bool</a>) -> m a -> m a</li><li class="src short"><a href="#v:filterM">filterM</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a -> m <a href="Data-Bool.html#t:Bool">Bool</a>) -> [a] -> m [a]</li><li class="src short"><a href="#v:mapAndUnzipM">mapAndUnzipM</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a -> m (b, c)) -> [a] -> m ([b], [c])</li><li class="src short"><a href="#v:zipWithM">zipWithM</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a -> b -> m c) -> [a] -> [b] -> m [c]</li><li class="src short"><a href="#v:zipWithM_">zipWithM_</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a -> b -> m c) -> [a] -> [b] -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a></li><li class="src short"><a href="#v:foldM">foldM</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a -> b -> m a) -> a -> [b] -> m a</li><li class="src short"><a href="#v:foldM_">foldM_</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a -> b -> m a) -> a -> [b] -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a></li><li class="src short"><a href="#v:replicateM">replicateM</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => <a href="Data-Int.html#t:Int">Int</a> -> m a -> m [a]</li><li class="src short"><a href="#v:replicateM_">replicateM_</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => <a href="Data-Int.html#t:Int">Int</a> -> m a -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a></li><li class="src short"><a href="#v:guard">guard</a> :: <a href="Control-Monad.html#t:MonadPlus">MonadPlus</a> m => <a href="Data-Bool.html#t:Bool">Bool</a> -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a></li><li class="src short"><a href="#v:when">when</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => <a href="Data-Bool.html#t:Bool">Bool</a> -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a> -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a></li><li class="src short"><a href="#v:unless">unless</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => <a href="Data-Bool.html#t:Bool">Bool</a> -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a> -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a></li><li class="src short"><a href="#v:liftM">liftM</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a1 -> r) -> m a1 -> m r</li><li class="src short"><a href="#v:liftM2">liftM2</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r</li><li class="src short"><a href="#v:liftM3">liftM3</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r</li><li class="src short"><a href="#v:liftM4">liftM4</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r</li><li class="src short"><a href="#v:liftM5">liftM5</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r</li><li class="src short"><a href="#v:ap">ap</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => m (a -> b) -> m a -> m b</li></ul></div><div id="interface"><h1 id="g:1">Functor and monad classes </h1><div class="top"><p class="src"><span class="keyword">class</span> <a name="t:Functor" class="def">Functor</a> f <span class="keyword">where</span></p><div class="doc"><p>The <code><a href="Control-Monad.html#t:Functor">Functor</a></code> class is used for types that can be mapped over. Instances of <code><a href="Control-Monad.html#t:Functor">Functor</a></code> should satisfy the following laws: </p><pre> fmap id == id fmap (f . g) == fmap f . fmap g </pre><p>The instances of <code><a href="Control-Monad.html#t:Functor">Functor</a></code> for lists, <code>Data.Maybe.Maybe</code> and <code>System.IO.IO</code> satisfy these laws. </p></div><div class="subs methods"><p class="caption">Methods</p><p class="src"><a name="v:fmap" class="def">fmap</a> :: (a -> b) -> f a -> f b</p></div><div class="subs instances"><p id="control.i:Functor" class="caption collapser" onclick="toggleSection('i:Functor')">Instances</p><div id="section.i:Functor" class="show"><table><tr><td class="src"><a href="Control-Monad.html#t:Functor">Functor</a> []</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Functor">Functor</a> <a href="System-IO.html#t:IO">IO</a></td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Functor">Functor</a> [::]</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Functor">Functor</a> <a href="Data-Maybe.html#t:Maybe">Maybe</a></td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Functor">Functor</a> <a href="Text-ParserCombinators-ReadP.html#t:ReadP">ReadP</a></td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Functor">Functor</a> <a href="Text-ParserCombinators-ReadPrec.html#t:ReadPrec">ReadPrec</a></td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Functor">Functor</a> <a href="GHC-Conc.html#t:STM">STM</a></td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Functor">Functor</a> <a href="Control-Applicative.html#t:ZipList">ZipList</a></td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Functor">Functor</a> Id</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Functor">Functor</a> ((->) r)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Functor">Functor</a> (<a href="Data-Either.html#t:Either">Either</a> a)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Functor">Functor</a> (<a href="../ghc-prim-0.2.0.0/GHC-Tuple.html#t:-40--44--41-">(,)</a> a)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Functor">Functor</a> (<a href="Control-Monad-ST.html#t:ST">ST</a> s)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Data-Ix.html#t:Ix">Ix</a> i => <a href="Control-Monad.html#t:Functor">Functor</a> (Array i)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Monad">Monad</a> m => <a href="Control-Monad.html#t:Functor">Functor</a> (<a href="Control-Applicative.html#t:WrappedMonad">WrappedMonad</a> m)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Functor">Functor</a> (<a href="Control-Applicative.html#t:Const">Const</a> m)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Functor">Functor</a> (StateR s)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Functor">Functor</a> (StateL s)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Functor">Functor</a> (<a href="Control-Monad-ST-Lazy.html#t:ST">ST</a> s)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Arrow.html#t:Arrow">Arrow</a> a => <a href="Control-Monad.html#t:Functor">Functor</a> (<a href="Control-Applicative.html#t:WrappedArrow">WrappedArrow</a> a b)</td><td class="doc empty"> </td></tr></table></div></div></div><div class="top"><p class="src"><span class="keyword">class</span> <a name="t:Monad" class="def">Monad</a> m <span class="keyword">where</span></p><div class="doc"><p>The <code><a href="Control-Monad.html#t:Monad">Monad</a></code> class defines the basic operations over a <em>monad</em>, a concept from a branch of mathematics known as <em>category theory</em>. From the perspective of a Haskell programmer, however, it is best to think of a monad as an <em>abstract datatype</em> of actions. Haskell's <code>do</code> expressions provide a convenient syntax for writing monadic expressions. </p><p>Minimal complete definition: <code><a href="Control-Monad.html#v:-62--62--61-">>>=</a></code> and <code><a href="Control-Monad.html#v:return">return</a></code>. </p><p>Instances of <code><a href="Control-Monad.html#t:Monad">Monad</a></code> should satisfy the following laws: </p><pre> return a >>= k == k a m >>= return == m m >>= (\x -> k x >>= h) == (m >>= k) >>= h </pre><p>Instances of both <code><a href="Control-Monad.html#t:Monad">Monad</a></code> and <code><a href="Control-Monad.html#t:Functor">Functor</a></code> should additionally satisfy the law: </p><pre> fmap f xs == xs >>= return . f </pre><p>The instances of <code><a href="Control-Monad.html#t:Monad">Monad</a></code> for lists, <code>Data.Maybe.Maybe</code> and <code>System.IO.IO</code> defined in the <a href="Prelude.html">Prelude</a> satisfy these laws. </p></div><div class="subs methods"><p class="caption">Methods</p><p class="src"><a name="v:-62--62--61-" class="def">(>>=)</a> :: <span class="keyword">forall</span> a b. m a -> (a -> m b) -> m b</p><div class="doc"><p>Sequentially compose two actions, passing any value produced by the first as an argument to the second. </p></div><p class="src"><a name="v:-62--62-" class="def">(>>)</a> :: <span class="keyword">forall</span> a b. m a -> m b -> m b</p><div class="doc"><p>Sequentially compose two actions, discarding any value produced by the first, like sequencing operators (such as the semicolon) in imperative languages. </p></div><p class="src"><a name="v:return" class="def">return</a> :: a -> m a</p><div class="doc"><p>Inject a value into the monadic type. </p></div><p class="src"><a name="v:fail" class="def">fail</a> :: <a href="Data-Char.html#t:String">String</a> -> m a</p><div class="doc"><p>Fail with a message. This operation is not part of the mathematical definition of a monad, but is invoked on pattern-match failure in a <code>do</code> expression. </p></div></div><div class="subs instances"><p id="control.i:Monad" class="caption collapser" onclick="toggleSection('i:Monad')">Instances</p><div id="section.i:Monad" class="show"><table><tr><td class="src"><a href="Control-Monad.html#t:Monad">Monad</a> []</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Monad">Monad</a> <a href="System-IO.html#t:IO">IO</a></td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Monad">Monad</a> [::]</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Monad">Monad</a> <a href="Data-Maybe.html#t:Maybe">Maybe</a></td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Monad">Monad</a> <a href="Text-ParserCombinators-ReadP.html#t:ReadP">ReadP</a></td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Monad">Monad</a> P</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Monad">Monad</a> <a href="Text-ParserCombinators-ReadPrec.html#t:ReadPrec">ReadPrec</a></td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Monad">Monad</a> <a href="GHC-Conc.html#t:STM">STM</a></td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Monad">Monad</a> ((->) r)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Monad">Monad</a> (<a href="Data-Either.html#t:Either">Either</a> e)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Monad">Monad</a> (<a href="Control-Monad-ST.html#t:ST">ST</a> s)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Arrow.html#t:ArrowApply">ArrowApply</a> a => <a href="Control-Monad.html#t:Monad">Monad</a> (<a href="Control-Arrow.html#t:ArrowMonad">ArrowMonad</a> a)</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:Monad">Monad</a> (<a href="Control-Monad-ST-Lazy.html#t:ST">ST</a> s)</td><td class="doc empty"> </td></tr></table></div></div></div><div class="top"><p class="src"><span class="keyword">class</span> <a href="Control-Monad.html#t:Monad">Monad</a> m => <a name="t:MonadPlus" class="def">MonadPlus</a> m <span class="keyword">where</span></p><div class="doc"><p>Monads that also support choice and failure. </p></div><div class="subs methods"><p class="caption">Methods</p><p class="src"><a name="v:mzero" class="def">mzero</a> :: m a</p><div class="doc"><p>the identity of <code><a href="Control-Monad.html#v:mplus">mplus</a></code>. It should also satisfy the equations </p><pre> mzero >>= f = mzero v >> mzero = mzero </pre></div><p class="src"><a name="v:mplus" class="def">mplus</a> :: m a -> m a -> m a</p><div class="doc"><p>an associative operation </p></div></div><div class="subs instances"><p id="control.i:MonadPlus" class="caption collapser" onclick="toggleSection('i:MonadPlus')">Instances</p><div id="section.i:MonadPlus" class="show"><table><tr><td class="src"><a href="Control-Monad.html#t:MonadPlus">MonadPlus</a> []</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:MonadPlus">MonadPlus</a> <a href="Data-Maybe.html#t:Maybe">Maybe</a></td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:MonadPlus">MonadPlus</a> <a href="Text-ParserCombinators-ReadP.html#t:ReadP">ReadP</a></td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:MonadPlus">MonadPlus</a> P</td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:MonadPlus">MonadPlus</a> <a href="Text-ParserCombinators-ReadPrec.html#t:ReadPrec">ReadPrec</a></td><td class="doc empty"> </td></tr><tr><td class="src"><a href="Control-Monad.html#t:MonadPlus">MonadPlus</a> <a href="GHC-Conc.html#t:STM">STM</a></td><td class="doc empty"> </td></tr></table></div></div></div><h1 id="g:2">Functions </h1><h2 id="g:3">Naming conventions </h2><div class="doc"><p>The functions in this library use the following naming conventions: </p><ul><li> A postfix '<code>M</code>' always stands for a function in the Kleisli category: The monad type constructor <code>m</code> is added to function results (modulo currying) and nowhere else. So, for example, </li></ul><pre> filter :: (a -> Bool) -> [a] -> [a] filterM :: (Monad m) => (a -> m Bool) -> [a] -> m [a] </pre><ul><li> A postfix '<code>_</code>' changes the result type from <code>(m a)</code> to <code>(m ())</code>. Thus, for example: </li></ul><pre> sequence :: Monad m => [m a] -> m [a] sequence_ :: Monad m => [m a] -> m () </pre><ul><li> A prefix '<code>m</code>' generalizes an existing function to a monadic form. Thus, for example: </li></ul><pre> sum :: Num a => [a] -> a msum :: MonadPlus m => [m a] -> m a </pre></div><h2 id="g:4">Basic <code>Monad</code> functions </h2><div class="top"><p class="src"><a name="v:mapM" class="def">mapM</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a -> m b) -> [a] -> m [b]</p><div class="doc"><p><code><code><a href="Control-Monad.html#v:mapM">mapM</a></code> f</code> is equivalent to <code><code><a href="Control-Monad.html#v:sequence">sequence</a></code> . <code><a href="Data-List.html#v:map">map</a></code> f</code>. </p></div></div><div class="top"><p class="src"><a name="v:mapM_" class="def">mapM_</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a -> m b) -> [a] -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a></p><div class="doc"><p><code><code><a href="Control-Monad.html#v:mapM_">mapM_</a></code> f</code> is equivalent to <code><code><a href="Control-Monad.html#v:sequence_">sequence_</a></code> . <code><a href="Data-List.html#v:map">map</a></code> f</code>. </p></div></div><div class="top"><p class="src"><a name="v:forM" class="def">forM</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => [a] -> (a -> m b) -> m [b]</p><div class="doc"><p><code><a href="Control-Monad.html#v:forM">forM</a></code> is <code><a href="Control-Monad.html#v:mapM">mapM</a></code> with its arguments flipped </p></div></div><div class="top"><p class="src"><a name="v:forM_" class="def">forM_</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => [a] -> (a -> m b) -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a></p><div class="doc"><p><code><a href="Control-Monad.html#v:forM_">forM_</a></code> is <code><a href="Control-Monad.html#v:mapM_">mapM_</a></code> with its arguments flipped </p></div></div><div class="top"><p class="src"><a name="v:sequence" class="def">sequence</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => [m a] -> m [a]</p><div class="doc"><p>Evaluate each action in the sequence from left to right, and collect the results. </p></div></div><div class="top"><p class="src"><a name="v:sequence_" class="def">sequence_</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => [m a] -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a></p><div class="doc"><p>Evaluate each action in the sequence from left to right, and ignore the results. </p></div></div><div class="top"><p class="src"><a name="v:-61--60--60-" class="def">(=<<)</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a -> m b) -> m a -> m b</p><div class="doc"><p>Same as <code><a href="Control-Monad.html#v:-62--62--61-">>>=</a></code>, but with the arguments interchanged. </p></div></div><div class="top"><p class="src"><a name="v:-62--61--62-" class="def">(>=>)</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a -> m b) -> (b -> m c) -> a -> m c</p><div class="doc"><p>Left-to-right Kleisli composition of monads. </p></div></div><div class="top"><p class="src"><a name="v:-60--61--60-" class="def">(<=<)</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (b -> m c) -> (a -> m b) -> a -> m c</p><div class="doc"><p>Right-to-left Kleisli composition of monads. <code>(<code><a href="Control-Monad.html#v:-62--61--62-">>=></a></code>)</code>, with the arguments flipped </p></div></div><div class="top"><p class="src"><a name="v:forever" class="def">forever</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => m a -> m b</p><div class="doc"><p><code><code><a href="Control-Monad.html#v:forever">forever</a></code> act</code> repeats the action infinitely. </p></div></div><div class="top"><p class="src"><a name="v:void" class="def">void</a> :: <a href="Control-Monad.html#t:Functor">Functor</a> f => f a -> f <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a></p><div class="doc"><p><code><code><a href="Control-Monad.html#v:void">void</a></code> value</code> discards or ignores the result of evaluation, such as the return value of an <code><a href="System-IO.html#t:IO">IO</a></code> action. </p></div></div><h2 id="g:5">Generalisations of list functions </h2><div class="top"><p class="src"><a name="v:join" class="def">join</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => m (m a) -> m a</p><div class="doc"><p>The <code><a href="Control-Monad.html#v:join">join</a></code> 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. </p></div></div><div class="top"><p class="src"><a name="v:msum" class="def">msum</a> :: <a href="Control-Monad.html#t:MonadPlus">MonadPlus</a> m => [m a] -> m a</p><div class="doc"><p>This generalizes the list-based <code><a href="Data-List.html#v:concat">concat</a></code> function. </p></div></div><div class="top"><p class="src"><a name="v:mfilter" class="def">mfilter</a> :: <a href="Control-Monad.html#t:MonadPlus">MonadPlus</a> m => (a -> <a href="Data-Bool.html#t:Bool">Bool</a>) -> m a -> m a</p><div class="doc"><p>Direct <code><a href="Control-Monad.html#t:MonadPlus">MonadPlus</a></code> equivalent of <code><a href="Data-List.html#v:filter">filter</a></code> <code><code><a href="Data-List.html#v:filter">filter</a></code></code> = <code>(mfilter:: (a -> Bool) -> [a] -> [a]</code> applicable to any <code><a href="Control-Monad.html#t:MonadPlus">MonadPlus</a></code>, for example <code>mfilter odd (Just 1) == Just 1</code> <code>mfilter odd (Just 2) == Nothing</code> </p></div></div><div class="top"><p class="src"><a name="v:filterM" class="def">filterM</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a -> m <a href="Data-Bool.html#t:Bool">Bool</a>) -> [a] -> m [a]</p><div class="doc"><p>This generalizes the list-based <code><a href="Data-List.html#v:filter">filter</a></code> function. </p></div></div><div class="top"><p class="src"><a name="v:mapAndUnzipM" class="def">mapAndUnzipM</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a -> m (b, c)) -> [a] -> m ([b], [c])</p><div class="doc"><p>The <code><a href="Control-Monad.html#v:mapAndUnzipM">mapAndUnzipM</a></code> 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. </p></div></div><div class="top"><p class="src"><a name="v:zipWithM" class="def">zipWithM</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a -> b -> m c) -> [a] -> [b] -> m [c]</p><div class="doc"><p>The <code><a href="Control-Monad.html#v:zipWithM">zipWithM</a></code> function generalizes <code><a href="Data-List.html#v:zipWith">zipWith</a></code> to arbitrary monads. </p></div></div><div class="top"><p class="src"><a name="v:zipWithM_" class="def">zipWithM_</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a -> b -> m c) -> [a] -> [b] -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a></p><div class="doc"><p><code><a href="Control-Monad.html#v:zipWithM_">zipWithM_</a></code> is the extension of <code><a href="Control-Monad.html#v:zipWithM">zipWithM</a></code> which ignores the final result. </p></div></div><div class="top"><p class="src"><a name="v:foldM" class="def">foldM</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a -> b -> m a) -> a -> [b] -> m a</p><div class="doc"><p>The <code><a href="Control-Monad.html#v:foldM">foldM</a></code> function is analogous to <code><a href="Data-List.html#v:foldl">foldl</a></code>, except that its result is encapsulated in a monad. Note that <code><a href="Control-Monad.html#v:foldM">foldM</a></code> works from left-to-right over the list arguments. This could be an issue where <code>(<code><a href="Control-Monad.html#v:-62--62-">>></a></code>)</code> and the `folded function' are not commutative. </p><pre> foldM f a1 [x1, x2, ..., xm] </pre><p>== </p><pre> do a2 <- f a1 x1 a3 <- f a2 x2 ... f am xm </pre><p>If right-to-left evaluation is required, the input list should be reversed. </p></div></div><div class="top"><p class="src"><a name="v:foldM_" class="def">foldM_</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a -> b -> m a) -> a -> [b] -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a></p><div class="doc"><p>Like <code><a href="Control-Monad.html#v:foldM">foldM</a></code>, but discards the result. </p></div></div><div class="top"><p class="src"><a name="v:replicateM" class="def">replicateM</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => <a href="Data-Int.html#t:Int">Int</a> -> m a -> m [a]</p><div class="doc"><p><code><code><a href="Control-Monad.html#v:replicateM">replicateM</a></code> n act</code> performs the action <code>n</code> times, gathering the results. </p></div></div><div class="top"><p class="src"><a name="v:replicateM_" class="def">replicateM_</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => <a href="Data-Int.html#t:Int">Int</a> -> m a -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a></p><div class="doc"><p>Like <code><a href="Control-Monad.html#v:replicateM">replicateM</a></code>, but discards the result. </p></div></div><h2 id="g:6">Conditional execution of monadic expressions </h2><div class="top"><p class="src"><a name="v:guard" class="def">guard</a> :: <a href="Control-Monad.html#t:MonadPlus">MonadPlus</a> m => <a href="Data-Bool.html#t:Bool">Bool</a> -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a></p><div class="doc"><p><code><code><a href="Control-Monad.html#v:guard">guard</a></code> b</code> is <code><code><a href="Control-Monad.html#v:return">return</a></code> ()</code> if <code>b</code> is <code><a href="Data-Bool.html#v:True">True</a></code>, and <code><a href="Control-Monad.html#v:mzero">mzero</a></code> if <code>b</code> is <code><a href="Data-Bool.html#v:False">False</a></code>. </p></div></div><div class="top"><p class="src"><a name="v:when" class="def">when</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => <a href="Data-Bool.html#t:Bool">Bool</a> -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a> -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a></p><div class="doc"><p>Conditional execution of monadic expressions. For example, </p><pre> when debug (putStr "Debugging\n") </pre><p>will output the string <code>Debugging\n</code> if the Boolean value <code>debug</code> is <code><a href="Data-Bool.html#v:True">True</a></code>, and otherwise do nothing. </p></div></div><div class="top"><p class="src"><a name="v:unless" class="def">unless</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => <a href="Data-Bool.html#t:Bool">Bool</a> -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a> -> m <a href="../ghc-prim-0.2.0.0/GHC-Unit.html#t:-40--41-">()</a></p><div class="doc"><p>The reverse of <code><a href="Control-Monad.html#v:when">when</a></code>. </p></div></div><h2 id="g:7">Monadic lifting operators </h2><div class="top"><p class="src"><a name="v:liftM" class="def">liftM</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a1 -> r) -> m a1 -> m r</p><div class="doc"><p>Promote a function to a monad. </p></div></div><div class="top"><p class="src"><a name="v:liftM2" class="def">liftM2</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r</p><div class="doc"><p>Promote a function to a monad, scanning the monadic arguments from left to right. For example, </p><pre> liftM2 (+) [0,1] [0,2] = [0,2,1,3] liftM2 (+) (Just 1) Nothing = Nothing </pre></div></div><div class="top"><p class="src"><a name="v:liftM3" class="def">liftM3</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r</p><div class="doc"><p>Promote a function to a monad, scanning the monadic arguments from left to right (cf. <code><a href="Control-Monad.html#v:liftM2">liftM2</a></code>). </p></div></div><div class="top"><p class="src"><a name="v:liftM4" class="def">liftM4</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r</p><div class="doc"><p>Promote a function to a monad, scanning the monadic arguments from left to right (cf. <code><a href="Control-Monad.html#v:liftM2">liftM2</a></code>). </p></div></div><div class="top"><p class="src"><a name="v:liftM5" class="def">liftM5</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r</p><div class="doc"><p>Promote a function to a monad, scanning the monadic arguments from left to right (cf. <code><a href="Control-Monad.html#v:liftM2">liftM2</a></code>). </p></div></div><div class="top"><p class="src"><a name="v:ap" class="def">ap</a> :: <a href="Control-Monad.html#t:Monad">Monad</a> m => m (a -> b) -> m a -> m b</p><div class="doc"><p>In many situations, the <code><a href="Control-Monad.html#v:liftM">liftM</a></code> operations can be replaced by uses of <code><a href="Control-Monad.html#v:ap">ap</a></code>, which promotes function application. </p><pre> return f `ap` x1 `ap` ... `ap` xn </pre><p>is equivalent to </p><pre> liftMn f x1 x2 ... xn </pre></div></div></div></div><div id="footer"><p>Produced by <a href="http://www.haskell.org/haddock/">Haddock</a> version 2.9.2</p></div></body></html>