-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Monad classes, using functional dependencies
gr
grMonad classes using functional dependencies, with instances for
grvarious monad transformers, inspired by the paper <i>Functional
grProgramming with Overloading and Higher-Order Polymorphism</i>, by
grMark P Jones, in <i>Advanced School of Functional Programming</i>,
gr1995 (<a>http://web.cecs.pdx.edu/~mpj/pubs/springschool.html</a>).
@package mtl
@version 2.2.2


-- | <ul>
gr<li><i>Computation type:</i> Computations which can be interrupted and
grresumed.</li>
gr<li><i>Binding strategy:</i> Binding a function to a monadic value
grcreates a new continuation which uses the function as the continuation
grof the monadic computation.</li>
gr<li><i>Useful for:</i> Complex control structures, error handling, and
grcreating co-routines.</li>
gr<li><i>Zero and plus:</i> None.</li>
gr<li><i>Example type:</i> <tt><tt>Cont</tt> r a</tt></li>
gr</ul>
gr
grThe Continuation monad represents computations in continuation-passing
grstyle (CPS). In continuation-passing style function result is not
grreturned, but instead is passed to another function, received as a
grparameter (continuation). Computations are built up from sequences of
grnested continuations, terminated by a final continuation (often
gr<tt>id</tt>) which produces the final result. Since continuations are
grfunctions which represent the future of a computation, manipulation of
grthe continuation functions can achieve complex manipulations of the
grfuture of the computation, such as interrupting a computation in the
grmiddle, aborting a portion of a computation, restarting a computation,
grand interleaving execution of computations. The Continuation monad
gradapts CPS to the structure of a monad.
gr
grBefore using the Continuation monad, be sure that you have a firm
grunderstanding of continuation-passing style and that continuations
grrepresent the best solution to your particular design problem. Many
gralgorithms which require continuations in other languages do not
grrequire them in Haskell, due to Haskell's lazy semantics. Abuse of the
grContinuation monad can produce code that is impossible to understand
grand maintain.
module Control.Monad.Cont.Class
class Monad m => MonadCont m

-- | <tt>callCC</tt> (call-with-current-continuation) calls a function with
grthe current continuation as its argument. Provides an escape
grcontinuation mechanism for use with Continuation monads. Escape
grcontinuations allow to abort the current computation and return a
grvalue immediately. They achieve a similar effect to <a>throwError</a>
grand <a>catchError</a> within an <a>Error</a> monad. Advantage of this
grfunction over calling <tt>return</tt> is that it makes the
grcontinuation explicit, allowing more flexibility and better control
gr(see examples in <a>Control.Monad.Cont</a>).
gr
grThe standard idiom used with <tt>callCC</tt> is to provide a
grlambda-expression to name the continuation. Then calling the named
grcontinuation anywhere within its scope will escape from the
grcomputation, even if it is many layers deep within nested
grcomputations.
callCC :: MonadCont m => ((a -> m b) -> m a) -> m a
instance Control.Monad.Cont.Class.MonadCont (Control.Monad.Trans.Cont.ContT r m)
instance (Control.Monad.Trans.Error.Error e, Control.Monad.Cont.Class.MonadCont m) => Control.Monad.Cont.Class.MonadCont (Control.Monad.Trans.Error.ErrorT e m)
instance Control.Monad.Cont.Class.MonadCont m => Control.Monad.Cont.Class.MonadCont (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.Cont.Class.MonadCont m => Control.Monad.Cont.Class.MonadCont (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.Cont.Class.MonadCont m => Control.Monad.Cont.Class.MonadCont (Control.Monad.Trans.List.ListT m)
instance Control.Monad.Cont.Class.MonadCont m => Control.Monad.Cont.Class.MonadCont (Control.Monad.Trans.Maybe.MaybeT m)
instance Control.Monad.Cont.Class.MonadCont m => Control.Monad.Cont.Class.MonadCont (Control.Monad.Trans.Reader.ReaderT r m)
instance (GHC.Base.Monoid w, Control.Monad.Cont.Class.MonadCont m) => Control.Monad.Cont.Class.MonadCont (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (GHC.Base.Monoid w, Control.Monad.Cont.Class.MonadCont m) => Control.Monad.Cont.Class.MonadCont (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance Control.Monad.Cont.Class.MonadCont m => Control.Monad.Cont.Class.MonadCont (Control.Monad.Trans.State.Lazy.StateT s m)
instance Control.Monad.Cont.Class.MonadCont m => Control.Monad.Cont.Class.MonadCont (Control.Monad.Trans.State.Strict.StateT s m)
instance (GHC.Base.Monoid w, Control.Monad.Cont.Class.MonadCont m) => Control.Monad.Cont.Class.MonadCont (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (GHC.Base.Monoid w, Control.Monad.Cont.Class.MonadCont m) => Control.Monad.Cont.Class.MonadCont (Control.Monad.Trans.Writer.Strict.WriterT w m)


-- | <ul>
gr<li><i>Computation type:</i> Computations which may fail or throw
grexceptions.</li>
gr<li><i>Binding strategy:</i> Failure records information about the
grcause/location of the failure. Failure values bypass the bound
grfunction, other values are used as inputs to the bound function.</li>
gr<li><i>Useful for:</i> Building computations from sequences of
grfunctions that may fail or using exception handling to structure error
grhandling.</li>
gr<li><i>Zero and plus:</i> Zero is represented by an empty error and
grthe plus operation executes its second argument if the first
grfails.</li>
gr<li><i>Example type:</i> <tt><a>Either</a> <tt>String</tt> a</tt></li>
gr</ul>
gr
grThe Error monad (also called the Exception monad).
module Control.Monad.Error.Class

-- | An exception to be thrown.
gr
grMinimal complete definition: <a>noMsg</a> or <a>strMsg</a>.
class Error a

-- | Creates an exception without a message. The default implementation is
gr<tt><a>strMsg</a> ""</tt>.
noMsg :: Error a => a

-- | Creates an exception with a message. The default implementation of
gr<tt><a>strMsg</a> s</tt> is <a>noMsg</a>.
strMsg :: Error a => String -> a

-- | The strategy of combining computations that can throw exceptions by
grbypassing bound functions from the point an exception is thrown to the
grpoint that it is handled.
gr
grIs parameterized over the type of error information and the monad type
grconstructor. It is common to use <tt><a>Either</a> String</tt> as the
grmonad type constructor for an error monad in which error descriptions
grtake the form of strings. In that case and many other common cases the
grresulting monad is already defined as an instance of the
gr<a>MonadError</a> class. You can also define your own error type
grand/or use a monad type constructor other than <tt><a>Either</a>
gr<tt>String</tt></tt> or <tt><a>Either</a> <tt>IOError</tt></tt>. In
grthese cases you will have to explicitly define instances of the
gr<a>MonadError</a> class. (If you are using the deprecated
gr<a>Control.Monad.Error</a> or <a>Control.Monad.Trans.Error</a>, you
grmay also have to define an <a>Error</a> instance.)
class (Monad m) => MonadError e m | m -> e

-- | Is used within a monadic computation to begin exception processing.
throwError :: MonadError e m => e -> m a

-- | A handler function to handle previous errors and return to normal
grexecution. A common idiom is:
gr
gr<pre>
grdo { action1; action2; action3 } `catchError` handler
gr</pre>
gr
grwhere the <tt>action</tt> functions can call <a>throwError</a>. Note
grthat <tt>handler</tt> and the do-block must have the same return type.
catchError :: MonadError e m => m a -> (e -> m a) -> m a
instance Control.Monad.Error.Class.MonadError GHC.IO.Exception.IOException GHC.Types.IO
instance Control.Monad.Error.Class.MonadError e (Data.Either.Either e)
instance (GHC.Base.Monad m, Control.Monad.Trans.Error.Error e) => Control.Monad.Error.Class.MonadError e (Control.Monad.Trans.Error.ErrorT e m)
instance GHC.Base.Monad m => Control.Monad.Error.Class.MonadError e (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.Error.Class.MonadError e m => Control.Monad.Error.Class.MonadError e (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.Error.Class.MonadError e m => Control.Monad.Error.Class.MonadError e (Control.Monad.Trans.List.ListT m)
instance Control.Monad.Error.Class.MonadError e m => Control.Monad.Error.Class.MonadError e (Control.Monad.Trans.Maybe.MaybeT m)
instance Control.Monad.Error.Class.MonadError e m => Control.Monad.Error.Class.MonadError e (Control.Monad.Trans.Reader.ReaderT r m)
instance (GHC.Base.Monoid w, Control.Monad.Error.Class.MonadError e m) => Control.Monad.Error.Class.MonadError e (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (GHC.Base.Monoid w, Control.Monad.Error.Class.MonadError e m) => Control.Monad.Error.Class.MonadError e (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance Control.Monad.Error.Class.MonadError e m => Control.Monad.Error.Class.MonadError e (Control.Monad.Trans.State.Lazy.StateT s m)
instance Control.Monad.Error.Class.MonadError e m => Control.Monad.Error.Class.MonadError e (Control.Monad.Trans.State.Strict.StateT s m)
instance (GHC.Base.Monoid w, Control.Monad.Error.Class.MonadError e m) => Control.Monad.Error.Class.MonadError e (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (GHC.Base.Monoid w, Control.Monad.Error.Class.MonadError e m) => Control.Monad.Error.Class.MonadError e (Control.Monad.Trans.Writer.Strict.WriterT w m)


-- | <ul>
gr<li><i>Computation type:</i> Simple function application.</li>
gr<li><i>Binding strategy:</i> The bound function is applied to the
grinput value. <tt><a>Identity</a> x &gt;&gt;= f == f x</tt></li>
gr<li><i>Useful for:</i> Monads can be derived from monad transformers
grapplied to the <a>Identity</a> monad.</li>
gr<li><i>Zero and plus:</i> None.</li>
gr<li><i>Example type:</i> <tt><a>Identity</a> a</tt></li>
gr</ul>
gr
grThe <tt>Identity</tt> monad is a monad that does not embody any
grcomputational strategy. It simply applies the bound function to its
grinput without any modification. Computationally, there is no reason to
gruse the <tt>Identity</tt> monad instead of the much simpler act of
grsimply applying functions to their arguments. The purpose of the
gr<tt>Identity</tt> monad is its fundamental role in the theory of monad
grtransformers. Any monad transformer applied to the <tt>Identity</tt>
grmonad yields a non-transformer version of that monad.
module Control.Monad.Identity


-- | <ul>
gr<li><i>Computation type:</i> Computations which read values from a
grshared environment.</li>
gr<li><i>Binding strategy:</i> Monad values are functions from the
grenvironment to a value. The bound function is applied to the bound
grvalue, and both have access to the shared environment.</li>
gr<li><i>Useful for:</i> Maintaining variable bindings, or other shared
grenvironment.</li>
gr<li><i>Zero and plus:</i> None.</li>
gr<li><i>Example type:</i> <tt><tt>Reader</tt> [(String,Value)]
gra</tt></li>
gr</ul>
gr
grThe <tt>Reader</tt> monad (also called the Environment monad).
grRepresents a computation, which can read values from a shared
grenvironment, pass values from function to function, and execute
grsub-computations in a modified environment. Using <tt>Reader</tt>
grmonad for such computations is often clearer and easier than using the
gr<a>State</a> monad.
gr
grInspired by the paper <i>Functional Programming with Overloading and
grHigher-Order Polymorphism</i>, Mark P Jones
gr(<a>http://web.cecs.pdx.edu/~mpj/</a>) Advanced School of Functional
grProgramming, 1995.
module Control.Monad.Reader.Class

-- | See examples in <a>Control.Monad.Reader</a>. Note, the partially
grapplied function type <tt>(-&gt;) r</tt> is a simple reader monad. See
grthe <tt>instance</tt> declaration below.
class Monad m => MonadReader r m | m -> r

-- | Retrieves the monad environment.
ask :: MonadReader r m => m r

-- | Executes a computation in a modified environment.
local :: MonadReader r m => (r -> r) -> m a -> m a

-- | Retrieves a function of the current environment.
reader :: MonadReader r m => (r -> a) -> m a

-- | Retrieves a function of the current environment.
asks :: MonadReader r m => (r -> a) -> m a
instance Control.Monad.Reader.Class.MonadReader r ((->) r)
instance GHC.Base.Monad m => Control.Monad.Reader.Class.MonadReader r (Control.Monad.Trans.Reader.ReaderT r m)
instance (GHC.Base.Monad m, GHC.Base.Monoid w) => Control.Monad.Reader.Class.MonadReader r (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (GHC.Base.Monad m, GHC.Base.Monoid w) => Control.Monad.Reader.Class.MonadReader r (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance Control.Monad.Reader.Class.MonadReader r' m => Control.Monad.Reader.Class.MonadReader r' (Control.Monad.Trans.Cont.ContT r m)
instance (Control.Monad.Trans.Error.Error e, Control.Monad.Reader.Class.MonadReader r m) => Control.Monad.Reader.Class.MonadReader r (Control.Monad.Trans.Error.ErrorT e m)
instance Control.Monad.Reader.Class.MonadReader r m => Control.Monad.Reader.Class.MonadReader r (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.Reader.Class.MonadReader r m => Control.Monad.Reader.Class.MonadReader r (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.Reader.Class.MonadReader r m => Control.Monad.Reader.Class.MonadReader r (Control.Monad.Trans.List.ListT m)
instance Control.Monad.Reader.Class.MonadReader r m => Control.Monad.Reader.Class.MonadReader r (Control.Monad.Trans.Maybe.MaybeT m)
instance Control.Monad.Reader.Class.MonadReader r m => Control.Monad.Reader.Class.MonadReader r (Control.Monad.Trans.State.Lazy.StateT s m)
instance Control.Monad.Reader.Class.MonadReader r m => Control.Monad.Reader.Class.MonadReader r (Control.Monad.Trans.State.Strict.StateT s m)
instance (GHC.Base.Monoid w, Control.Monad.Reader.Class.MonadReader r m) => Control.Monad.Reader.Class.MonadReader r (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (GHC.Base.Monoid w, Control.Monad.Reader.Class.MonadReader r m) => Control.Monad.Reader.Class.MonadReader r (Control.Monad.Trans.Writer.Strict.WriterT w m)


-- | MonadState class.
gr
grThis module is inspired by the paper <i>Functional Programming with
grOverloading and Higher-Order Polymorphism</i>, Mark P Jones
gr(<a>http://web.cecs.pdx.edu/~mpj/</a>) Advanced School of Functional
grProgramming, 1995.
module Control.Monad.State.Class

-- | Minimal definition is either both of <tt>get</tt> and <tt>put</tt> or
grjust <tt>state</tt>
class Monad m => MonadState s m | m -> s

-- | Return the state from the internals of the monad.
get :: MonadState s m => m s

-- | Replace the state inside the monad.
put :: MonadState s m => s -> m ()

-- | Embed a simple state action into the monad.
state :: MonadState s m => (s -> (a, s)) -> m a

-- | Monadic state transformer.
gr
grMaps an old state to a new state inside a state monad. The old state
gris thrown away.
gr
gr<pre>
grMain&gt; :t modify ((+1) :: Int -&gt; Int)
grmodify (...) :: (MonadState Int a) =&gt; a ()
gr</pre>
gr
grThis says that <tt>modify (+1)</tt> acts over any Monad that is a
grmember of the <tt>MonadState</tt> class, with an <tt>Int</tt> state.
modify :: MonadState s m => (s -> s) -> m ()

-- | A variant of <a>modify</a> in which the computation is strict in the
grnew state.
modify' :: MonadState s m => (s -> s) -> m ()

-- | Gets specific component of the state, using a projection function
grsupplied.
gets :: MonadState s m => (s -> a) -> m a
instance GHC.Base.Monad m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.State.Lazy.StateT s m)
instance GHC.Base.Monad m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.State.Strict.StateT s m)
instance (GHC.Base.Monad m, GHC.Base.Monoid w) => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (GHC.Base.Monad m, GHC.Base.Monoid w) => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.Cont.ContT r m)
instance (Control.Monad.Trans.Error.Error e, Control.Monad.State.Class.MonadState s m) => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.Error.ErrorT e m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.List.ListT m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.Maybe.MaybeT m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.Reader.ReaderT r m)
instance (GHC.Base.Monoid w, Control.Monad.State.Class.MonadState s m) => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (GHC.Base.Monoid w, Control.Monad.State.Class.MonadState s m) => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.Writer.Strict.WriterT w m)


-- | Classes for monad transformers.
gr
grA monad transformer makes new monad out of an existing monad, such
grthat computations of the old monad may be embedded in the new one. To
grconstruct a monad with a desired set of features, one typically starts
grwith a base monad, such as <tt>Identity</tt>, <tt>[]</tt> or
gr<a>IO</a>, and applies a sequence of monad transformers.
gr
grMost monad transformer modules include the special case of applying
grthe transformer to <tt>Identity</tt>. For example, <tt>State s</tt> is
gran abbreviation for <tt>StateT s Identity</tt>.
gr
grEach monad transformer also comes with an operation
gr<tt>run</tt><i>XXX</i> to unwrap the transformer, exposing a
grcomputation of the inner monad.
module Control.Monad.Trans


-- | Strict state monads.
gr
grThis module is inspired by the paper <i>Functional Programming with
grOverloading and Higher-Order Polymorphism</i>, Mark P Jones
gr(<a>http://web.cecs.pdx.edu/~mpj/</a>) Advanced School of Functional
grProgramming, 1995.
module Control.Monad.State.Strict

-- | Minimal definition is either both of <tt>get</tt> and <tt>put</tt> or
grjust <tt>state</tt>
class Monad m => MonadState s m | m -> s

-- | Return the state from the internals of the monad.
get :: MonadState s m => m s

-- | Replace the state inside the monad.
put :: MonadState s m => s -> m ()

-- | Embed a simple state action into the monad.
state :: MonadState s m => (s -> (a, s)) -> m a

-- | Monadic state transformer.
gr
grMaps an old state to a new state inside a state monad. The old state
gris thrown away.
gr
gr<pre>
grMain&gt; :t modify ((+1) :: Int -&gt; Int)
grmodify (...) :: (MonadState Int a) =&gt; a ()
gr</pre>
gr
grThis says that <tt>modify (+1)</tt> acts over any Monad that is a
grmember of the <tt>MonadState</tt> class, with an <tt>Int</tt> state.
modify :: MonadState s m => (s -> s) -> m ()

-- | A variant of <a>modify</a> in which the computation is strict in the
grnew state.
modify' :: MonadState s m => (s -> s) -> m ()

-- | Gets specific component of the state, using a projection function
grsupplied.
gets :: MonadState s m => (s -> a) -> m a

-- | A state monad parameterized by the type <tt>s</tt> of the state to
grcarry.
gr
grThe <a>return</a> function leaves the state unchanged, while
gr<tt>&gt;&gt;=</tt> uses the final state of the first computation as
grthe initial state of the second.
type State s = StateT s Identity

-- | Unwrap a state monad computation as a function. (The inverse of
gr<a>state</a>.)
runState :: () => State s a -> s -> (a, s)

-- | Evaluate a state computation with the given initial state and return
grthe final value, discarding the final state.
gr
gr<ul>
gr<li><pre><a>evalState</a> m s = <a>fst</a> (<a>runState</a> m
grs)</pre></li>
gr</ul>
evalState :: () => State s a -> s -> a

-- | Evaluate a state computation with the given initial state and return
grthe final state, discarding the final value.
gr
gr<ul>
gr<li><pre><a>execState</a> m s = <a>snd</a> (<a>runState</a> m
grs)</pre></li>
gr</ul>
execState :: () => State s a -> s -> s

-- | Map both the return value and final state of a computation using the
grgiven function.
gr
gr<ul>
gr<li><pre><a>runState</a> (<a>mapState</a> f m) = f . <a>runState</a>
grm</pre></li>
gr</ul>
mapState :: () => (a, s) -> (b, s) -> State s a -> State s b

-- | <tt><a>withState</a> f m</tt> executes action <tt>m</tt> on a state
grmodified by applying <tt>f</tt>.
gr
gr<ul>
gr<li><pre><a>withState</a> f m = <a>modify</a> f &gt;&gt; m</pre></li>
gr</ul>
withState :: () => s -> s -> State s a -> State s a

-- | A state transformer monad parameterized by:
gr
gr<ul>
gr<li><tt>s</tt> - The state.</li>
gr<li><tt>m</tt> - The inner monad.</li>
gr</ul>
gr
grThe <a>return</a> function leaves the state unchanged, while
gr<tt>&gt;&gt;=</tt> uses the final state of the first computation as
grthe initial state of the second.
newtype StateT s (m :: * -> *) a
StateT :: s -> m (a, s) -> StateT s a
runStateT :: StateT s m a -> s -> m (a, s)

-- | Evaluate a state computation with the given initial state and return
grthe final value, discarding the final state.
gr
gr<ul>
gr<li><pre><a>evalStateT</a> m s = <a>liftM</a> <a>fst</a>
gr(<a>runStateT</a> m s)</pre></li>
gr</ul>
evalStateT :: Monad m => StateT s m a -> s -> m a

-- | Evaluate a state computation with the given initial state and return
grthe final state, discarding the final value.
gr
gr<ul>
gr<li><pre><a>execStateT</a> m s = <a>liftM</a> <a>snd</a>
gr(<a>runStateT</a> m s)</pre></li>
gr</ul>
execStateT :: Monad m => StateT s m a -> s -> m s

-- | Map both the return value and final state of a computation using the
grgiven function.
gr
gr<ul>
gr<li><pre><a>runStateT</a> (<a>mapStateT</a> f m) = f .
gr<a>runStateT</a> m</pre></li>
gr</ul>
mapStateT :: () => m (a, s) -> n (b, s) -> StateT s m a -> StateT s n b

-- | <tt><a>withStateT</a> f m</tt> executes action <tt>m</tt> on a state
grmodified by applying <tt>f</tt>.
gr
gr<ul>
gr<li><pre><a>withStateT</a> f m = <a>modify</a> f &gt;&gt; m</pre></li>
gr</ul>
withStateT :: () => s -> s -> StateT s m a -> StateT s m a


-- | Lazy state monads.
gr
grThis module is inspired by the paper <i>Functional Programming with
grOverloading and Higher-Order Polymorphism</i>, Mark P Jones
gr(<a>http://web.cecs.pdx.edu/~mpj/</a>) Advanced School of Functional
grProgramming, 1995.
module Control.Monad.State.Lazy

-- | Minimal definition is either both of <tt>get</tt> and <tt>put</tt> or
grjust <tt>state</tt>
class Monad m => MonadState s m | m -> s

-- | Return the state from the internals of the monad.
get :: MonadState s m => m s

-- | Replace the state inside the monad.
put :: MonadState s m => s -> m ()

-- | Embed a simple state action into the monad.
state :: MonadState s m => (s -> (a, s)) -> m a

-- | Monadic state transformer.
gr
grMaps an old state to a new state inside a state monad. The old state
gris thrown away.
gr
gr<pre>
grMain&gt; :t modify ((+1) :: Int -&gt; Int)
grmodify (...) :: (MonadState Int a) =&gt; a ()
gr</pre>
gr
grThis says that <tt>modify (+1)</tt> acts over any Monad that is a
grmember of the <tt>MonadState</tt> class, with an <tt>Int</tt> state.
modify :: MonadState s m => (s -> s) -> m ()

-- | A variant of <a>modify</a> in which the computation is strict in the
grnew state.
modify' :: MonadState s m => (s -> s) -> m ()

-- | Gets specific component of the state, using a projection function
grsupplied.
gets :: MonadState s m => (s -> a) -> m a

-- | A state monad parameterized by the type <tt>s</tt> of the state to
grcarry.
gr
grThe <a>return</a> function leaves the state unchanged, while
gr<tt>&gt;&gt;=</tt> uses the final state of the first computation as
grthe initial state of the second.
type State s = StateT s Identity

-- | Unwrap a state monad computation as a function. (The inverse of
gr<a>state</a>.)
runState :: () => State s a -> s -> (a, s)

-- | Evaluate a state computation with the given initial state and return
grthe final value, discarding the final state.
gr
gr<ul>
gr<li><pre><a>evalState</a> m s = <a>fst</a> (<a>runState</a> m
grs)</pre></li>
gr</ul>
evalState :: () => State s a -> s -> a

-- | Evaluate a state computation with the given initial state and return
grthe final state, discarding the final value.
gr
gr<ul>
gr<li><pre><a>execState</a> m s = <a>snd</a> (<a>runState</a> m
grs)</pre></li>
gr</ul>
execState :: () => State s a -> s -> s

-- | Map both the return value and final state of a computation using the
grgiven function.
gr
gr<ul>
gr<li><pre><a>runState</a> (<a>mapState</a> f m) = f . <a>runState</a>
grm</pre></li>
gr</ul>
mapState :: () => (a, s) -> (b, s) -> State s a -> State s b

-- | <tt><a>withState</a> f m</tt> executes action <tt>m</tt> on a state
grmodified by applying <tt>f</tt>.
gr
gr<ul>
gr<li><pre><a>withState</a> f m = <a>modify</a> f &gt;&gt; m</pre></li>
gr</ul>
withState :: () => s -> s -> State s a -> State s a

-- | A state transformer monad parameterized by:
gr
gr<ul>
gr<li><tt>s</tt> - The state.</li>
gr<li><tt>m</tt> - The inner monad.</li>
gr</ul>
gr
grThe <a>return</a> function leaves the state unchanged, while
gr<tt>&gt;&gt;=</tt> uses the final state of the first computation as
grthe initial state of the second.
newtype StateT s (m :: * -> *) a
StateT :: s -> m (a, s) -> StateT s a
runStateT :: StateT s m a -> s -> m (a, s)

-- | Evaluate a state computation with the given initial state and return
grthe final value, discarding the final state.
gr
gr<ul>
gr<li><pre><a>evalStateT</a> m s = <a>liftM</a> <a>fst</a>
gr(<a>runStateT</a> m s)</pre></li>
gr</ul>
evalStateT :: Monad m => StateT s m a -> s -> m a

-- | Evaluate a state computation with the given initial state and return
grthe final state, discarding the final value.
gr
gr<ul>
gr<li><pre><a>execStateT</a> m s = <a>liftM</a> <a>snd</a>
gr(<a>runStateT</a> m s)</pre></li>
gr</ul>
execStateT :: Monad m => StateT s m a -> s -> m s

-- | Map both the return value and final state of a computation using the
grgiven function.
gr
gr<ul>
gr<li><pre><a>runStateT</a> (<a>mapStateT</a> f m) = f .
gr<a>runStateT</a> m</pre></li>
gr</ul>
mapStateT :: () => m (a, s) -> n (b, s) -> StateT s m a -> StateT s n b

-- | <tt><a>withStateT</a> f m</tt> executes action <tt>m</tt> on a state
grmodified by applying <tt>f</tt>.
gr
gr<ul>
gr<li><pre><a>withStateT</a> f m = <a>modify</a> f &gt;&gt; m</pre></li>
gr</ul>
withStateT :: () => s -> s -> StateT s m a -> StateT s m a


-- | State monads.
gr
grThis module is inspired by the paper <i>Functional Programming with
grOverloading and Higher-Order Polymorphism</i>, Mark P Jones
gr(<a>http://web.cecs.pdx.edu/~mpj/</a>) Advanced School of Functional
grProgramming, 1995.
module Control.Monad.State


-- | <ul>
gr<li><i>Computation type:</i> Computations which read values from a
grshared environment.</li>
gr<li><i>Binding strategy:</i> Monad values are functions from the
grenvironment to a value. The bound function is applied to the bound
grvalue, and both have access to the shared environment.</li>
gr<li><i>Useful for:</i> Maintaining variable bindings, or other shared
grenvironment.</li>
gr<li><i>Zero and plus:</i> None.</li>
gr<li><i>Example type:</i> <tt><a>Reader</a> [(String,Value)]
gra</tt></li>
gr</ul>
gr
grThe <a>Reader</a> monad (also called the Environment monad).
grRepresents a computation, which can read values from a shared
grenvironment, pass values from function to function, and execute
grsub-computations in a modified environment. Using <a>Reader</a> monad
grfor such computations is often clearer and easier than using the
gr<a>State</a> monad.
gr
grInspired by the paper <i>Functional Programming with Overloading and
grHigher-Order Polymorphism</i>, Mark P Jones
gr(<a>http://web.cecs.pdx.edu/~mpj/</a>) Advanced School of Functional
grProgramming, 1995.
module Control.Monad.Reader

-- | See examples in <a>Control.Monad.Reader</a>. Note, the partially
grapplied function type <tt>(-&gt;) r</tt> is a simple reader monad. See
grthe <tt>instance</tt> declaration below.
class Monad m => MonadReader r m | m -> r

-- | Retrieves the monad environment.
ask :: MonadReader r m => m r

-- | Executes a computation in a modified environment.
local :: MonadReader r m => (r -> r) -> m a -> m a

-- | Retrieves a function of the current environment.
reader :: MonadReader r m => (r -> a) -> m a

-- | Retrieves a function of the current environment.
asks :: MonadReader r m => (r -> a) -> m a

-- | The parameterizable reader monad.
gr
grComputations are functions of a shared environment.
gr
grThe <a>return</a> function ignores the environment, while
gr<tt>&gt;&gt;=</tt> passes the inherited environment to both
grsubcomputations.
type Reader r = ReaderT r Identity

-- | Runs a <tt>Reader</tt> and extracts the final value from it. (The
grinverse of <a>reader</a>.)
runReader :: () => Reader r a -> r -> a

-- | Transform the value returned by a <tt>Reader</tt>.
gr
gr<ul>
gr<li><pre><a>runReader</a> (<a>mapReader</a> f m) = f .
gr<a>runReader</a> m</pre></li>
gr</ul>
mapReader :: () => a -> b -> Reader r a -> Reader r b

-- | Execute a computation in a modified environment (a specialization of
gr<a>withReaderT</a>).
gr
gr<ul>
gr<li><pre><a>runReader</a> (<a>withReader</a> f m) = <a>runReader</a> m
gr. f</pre></li>
gr</ul>
withReader :: () => r' -> r -> Reader r a -> Reader r' a

-- | The reader monad transformer, which adds a read-only environment to
grthe given monad.
gr
grThe <a>return</a> function ignores the environment, while
gr<tt>&gt;&gt;=</tt> passes the inherited environment to both
grsubcomputations.
newtype ReaderT r (m :: k -> *) (a :: k) :: forall k. () => * -> k -> * -> k -> *
ReaderT :: r -> m a -> ReaderT r
runReaderT :: ReaderT r m a -> r -> m a

-- | Transform the computation inside a <tt>ReaderT</tt>.
gr
gr<ul>
gr<li><pre><a>runReaderT</a> (<a>mapReaderT</a> f m) = f .
gr<a>runReaderT</a> m</pre></li>
gr</ul>
mapReaderT :: () => m a -> n b -> ReaderT r m a -> ReaderT r n b

-- | Execute a computation in a modified environment (a more general
grversion of <a>local</a>).
gr
gr<ul>
gr<li><pre><a>runReaderT</a> (<a>withReaderT</a> f m) =
gr<a>runReaderT</a> m . f</pre></li>
gr</ul>
withReaderT :: () => r' -> r -> ReaderT r m a -> ReaderT r' m a


-- | The List monad.
module Control.Monad.List

-- | Parameterizable list monad, with an inner monad.
gr
gr<i>Note:</i> this does not yield a monad unless the argument monad is
grcommutative.
newtype ListT (m :: * -> *) a
ListT :: m [a] -> ListT a
[runListT] :: ListT a -> m [a]

-- | Map between <a>ListT</a> computations.
gr
gr<ul>
gr<li><pre><a>runListT</a> (<a>mapListT</a> f m) = f (<a>runListT</a>
grm)</pre></li>
gr</ul>
mapListT :: () => m [a] -> n [b] -> ListT m a -> ListT n b


-- | <ul>
gr<li><i>Computation type:</i> Computations which may fail or throw
grexceptions.</li>
gr<li><i>Binding strategy:</i> Failure records information about the
grcause/location of the failure. Failure values bypass the bound
grfunction, other values are used as inputs to the bound function.</li>
gr<li><i>Useful for:</i> Building computations from sequences of
grfunctions that may fail or using exception handling to structure error
grhandling.</li>
gr<li><i>Example type:</i> <tt><a>Either</a> String a</tt></li>
gr</ul>
gr
grThe Error monad (also called the Exception monad).
module Control.Monad.Except

-- | The strategy of combining computations that can throw exceptions by
grbypassing bound functions from the point an exception is thrown to the
grpoint that it is handled.
gr
grIs parameterized over the type of error information and the monad type
grconstructor. It is common to use <tt><a>Either</a> String</tt> as the
grmonad type constructor for an error monad in which error descriptions
grtake the form of strings. In that case and many other common cases the
grresulting monad is already defined as an instance of the
gr<a>MonadError</a> class. You can also define your own error type
grand/or use a monad type constructor other than <tt><a>Either</a>
gr<tt>String</tt></tt> or <tt><a>Either</a> <tt>IOError</tt></tt>. In
grthese cases you will have to explicitly define instances of the
gr<a>MonadError</a> class. (If you are using the deprecated
gr<a>Control.Monad.Error</a> or <a>Control.Monad.Trans.Error</a>, you
grmay also have to define an <a>Error</a> instance.)
class (Monad m) => MonadError e m | m -> e

-- | Is used within a monadic computation to begin exception processing.
throwError :: MonadError e m => e -> m a

-- | A handler function to handle previous errors and return to normal
grexecution. A common idiom is:
gr
gr<pre>
grdo { action1; action2; action3 } `catchError` handler
gr</pre>
gr
grwhere the <tt>action</tt> functions can call <a>throwError</a>. Note
grthat <tt>handler</tt> and the do-block must have the same return type.
catchError :: MonadError e m => m a -> (e -> m a) -> m a

-- | A monad transformer that adds exceptions to other monads.
gr
gr<tt>ExceptT</tt> constructs a monad parameterized over two things:
gr
gr<ul>
gr<li>e - The exception type.</li>
gr<li>m - The inner monad.</li>
gr</ul>
gr
grThe <a>return</a> function yields a computation that produces the
grgiven value, while <tt>&gt;&gt;=</tt> sequences two subcomputations,
grexiting on the first exception.
newtype ExceptT e (m :: * -> *) a
ExceptT :: m Either e a -> ExceptT e a

-- | The parameterizable exception monad.
gr
grComputations are either exceptions or normal values.
gr
grThe <a>return</a> function returns a normal value, while
gr<tt>&gt;&gt;=</tt> exits on the first exception. For a variant that
grcontinues after an error and collects all the errors, see
gr<a>Errors</a>.
type Except e = ExceptT e Identity

-- | The inverse of <a>ExceptT</a>.
runExceptT :: () => ExceptT e m a -> m Either e a

-- | Map the unwrapped computation using the given function.
gr
gr<ul>
gr<li><pre><a>runExceptT</a> (<a>mapExceptT</a> f m) = f
gr(<a>runExceptT</a> m)</pre></li>
gr</ul>
mapExceptT :: () => m Either e a -> n Either e' b -> ExceptT e m a -> ExceptT e' n b

-- | Transform any exceptions thrown by the computation using the given
grfunction.
withExceptT :: Functor m => e -> e' -> ExceptT e m a -> ExceptT e' m a

-- | Extractor for computations in the exception monad. (The inverse of
gr<a>except</a>).
runExcept :: () => Except e a -> Either e a

-- | Map the unwrapped computation using the given function.
gr
gr<ul>
gr<li><pre><a>runExcept</a> (<a>mapExcept</a> f m) = f (<a>runExcept</a>
grm)</pre></li>
gr</ul>
mapExcept :: () => Either e a -> Either e' b -> Except e a -> Except e' b

-- | Transform any exceptions thrown by the computation using the given
grfunction (a specialization of <a>withExceptT</a>).
withExcept :: () => e -> e' -> Except e a -> Except e' a


-- | <ul>
gr<li><i>Computation type:</i> Computations which may fail or throw
grexceptions.</li>
gr<li><i>Binding strategy:</i> Failure records information about the
grcause/location of the failure. Failure values bypass the bound
grfunction, other values are used as inputs to the bound function.</li>
gr<li><i>Useful for:</i> Building computations from sequences of
grfunctions that may fail or using exception handling to structure error
grhandling.</li>
gr<li><i>Zero and plus:</i> Zero is represented by an empty error and
grthe plus operation executes its second argument if the first
grfails.</li>
gr<li><i>Example type:</i> <tt><a>Either</a> String a</tt></li>
gr</ul>
gr
grThe Error monad (also called the Exception monad).

-- | <i>Deprecated: Use Control.Monad.Except instead</i>
module Control.Monad.Error

-- | The strategy of combining computations that can throw exceptions by
grbypassing bound functions from the point an exception is thrown to the
grpoint that it is handled.
gr
grIs parameterized over the type of error information and the monad type
grconstructor. It is common to use <tt><a>Either</a> String</tt> as the
grmonad type constructor for an error monad in which error descriptions
grtake the form of strings. In that case and many other common cases the
grresulting monad is already defined as an instance of the
gr<a>MonadError</a> class. You can also define your own error type
grand/or use a monad type constructor other than <tt><a>Either</a>
gr<tt>String</tt></tt> or <tt><a>Either</a> <tt>IOError</tt></tt>. In
grthese cases you will have to explicitly define instances of the
gr<a>MonadError</a> class. (If you are using the deprecated
gr<a>Control.Monad.Error</a> or <a>Control.Monad.Trans.Error</a>, you
grmay also have to define an <a>Error</a> instance.)
class (Monad m) => MonadError e m | m -> e

-- | Is used within a monadic computation to begin exception processing.
throwError :: MonadError e m => e -> m a

-- | A handler function to handle previous errors and return to normal
grexecution. A common idiom is:
gr
gr<pre>
grdo { action1; action2; action3 } `catchError` handler
gr</pre>
gr
grwhere the <tt>action</tt> functions can call <a>throwError</a>. Note
grthat <tt>handler</tt> and the do-block must have the same return type.
catchError :: MonadError e m => m a -> (e -> m a) -> m a

-- | An exception to be thrown.
gr
grMinimal complete definition: <a>noMsg</a> or <a>strMsg</a>.
class Error a

-- | Creates an exception without a message. The default implementation is
gr<tt><a>strMsg</a> ""</tt>.
noMsg :: Error a => a

-- | Creates an exception with a message. The default implementation of
gr<tt><a>strMsg</a> s</tt> is <a>noMsg</a>.
strMsg :: Error a => String -> a

-- | The error monad transformer. It can be used to add error handling to
grother monads.
gr
grThe <tt>ErrorT</tt> Monad structure is parameterized over two things:
gr
gr<ul>
gr<li>e - The error type.</li>
gr<li>m - The inner monad.</li>
gr</ul>
gr
grThe <a>return</a> function yields a successful computation, while
gr<tt>&gt;&gt;=</tt> sequences two subcomputations, failing on the first
grerror.
newtype ErrorT e (m :: * -> *) a
ErrorT :: m Either e a -> ErrorT e a
runErrorT :: ErrorT e m a -> m Either e a

-- | Map the unwrapped computation using the given function.
gr
gr<ul>
gr<li><pre><a>runErrorT</a> (<a>mapErrorT</a> f m) = f (<a>runErrorT</a>
grm)</pre></li>
gr</ul>
mapErrorT :: () => m Either e a -> n Either e' b -> ErrorT e m a -> ErrorT e' n b


-- | <ul>
gr<li><i>Computation type:</i> Computations which can be interrupted and
grresumed.</li>
gr<li><i>Binding strategy:</i> Binding a function to a monadic value
grcreates a new continuation which uses the function as the continuation
grof the monadic computation.</li>
gr<li><i>Useful for:</i> Complex control structures, error handling, and
grcreating co-routines.</li>
gr<li><i>Zero and plus:</i> None.</li>
gr<li><i>Example type:</i> <tt><a>Cont</a> r a</tt></li>
gr</ul>
gr
grThe Continuation monad represents computations in continuation-passing
grstyle (CPS). In continuation-passing style function result is not
grreturned, but instead is passed to another function, received as a
grparameter (continuation). Computations are built up from sequences of
grnested continuations, terminated by a final continuation (often
gr<tt>id</tt>) which produces the final result. Since continuations are
grfunctions which represent the future of a computation, manipulation of
grthe continuation functions can achieve complex manipulations of the
grfuture of the computation, such as interrupting a computation in the
grmiddle, aborting a portion of a computation, restarting a computation,
grand interleaving execution of computations. The Continuation monad
gradapts CPS to the structure of a monad.
gr
grBefore using the Continuation monad, be sure that you have a firm
grunderstanding of continuation-passing style and that continuations
grrepresent the best solution to your particular design problem. Many
gralgorithms which require continuations in other languages do not
grrequire them in Haskell, due to Haskell's lazy semantics. Abuse of the
grContinuation monad can produce code that is impossible to understand
grand maintain.
module Control.Monad.Cont
class Monad m => MonadCont m

-- | <tt>callCC</tt> (call-with-current-continuation) calls a function with
grthe current continuation as its argument. Provides an escape
grcontinuation mechanism for use with Continuation monads. Escape
grcontinuations allow to abort the current computation and return a
grvalue immediately. They achieve a similar effect to <a>throwError</a>
grand <a>catchError</a> within an <a>Error</a> monad. Advantage of this
grfunction over calling <tt>return</tt> is that it makes the
grcontinuation explicit, allowing more flexibility and better control
gr(see examples in <a>Control.Monad.Cont</a>).
gr
grThe standard idiom used with <tt>callCC</tt> is to provide a
grlambda-expression to name the continuation. Then calling the named
grcontinuation anywhere within its scope will escape from the
grcomputation, even if it is many layers deep within nested
grcomputations.
callCC :: MonadCont m => ((a -> m b) -> m a) -> m a

-- | Continuation monad. <tt>Cont r a</tt> is a CPS ("continuation-passing
grstyle") computation that produces an intermediate result of type
gr<tt>a</tt> within a CPS computation whose final result type is
gr<tt>r</tt>.
gr
grThe <tt>return</tt> function simply creates a continuation which
grpasses the value on.
gr
grThe <tt>&gt;&gt;=</tt> operator adds the bound function into the
grcontinuation chain.
type Cont r = ContT r Identity

-- | Construct a continuation-passing computation from a function. (The
grinverse of <a>runCont</a>)
cont :: () => a -> r -> r -> Cont r a

-- | The result of running a CPS computation with a given final
grcontinuation. (The inverse of <a>cont</a>)
runCont :: () => Cont r a -> a -> r -> r

-- | Apply a function to transform the result of a continuation-passing
grcomputation.
gr
gr<ul>
gr<li><pre><a>runCont</a> (<a>mapCont</a> f m) = f . <a>runCont</a>
grm</pre></li>
gr</ul>
mapCont :: () => r -> r -> Cont r a -> Cont r a

-- | Apply a function to transform the continuation passed to a CPS
grcomputation.
gr
gr<ul>
gr<li><pre><a>runCont</a> (<a>withCont</a> f m) = <a>runCont</a> m .
grf</pre></li>
gr</ul>
withCont :: () => b -> r -> a -> r -> Cont r a -> Cont r b

-- | The continuation monad transformer. Can be used to add continuation
grhandling to any type constructor: the <a>Monad</a> instance and most
grof the operations do not require <tt>m</tt> to be a monad.
gr
gr<a>ContT</a> is not a functor on the category of monads, and many
groperations cannot be lifted through it.
newtype ContT (r :: k) (m :: k -> *) a :: forall k. () => k -> k -> * -> * -> *
ContT :: a -> m r -> m r -> ContT a
runContT :: ContT r m a -> a -> m r -> m r

-- | Apply a function to transform the result of a continuation-passing
grcomputation. This has a more restricted type than the <tt>map</tt>
groperations for other monad transformers, because <a>ContT</a> does not
grdefine a functor in the category of monads.
gr
gr<ul>
gr<li><pre><a>runContT</a> (<a>mapContT</a> f m) = f . <a>runContT</a>
grm</pre></li>
gr</ul>
mapContT :: () => m r -> m r -> ContT r m a -> ContT r m a

-- | Apply a function to transform the continuation passed to a CPS
grcomputation.
gr
gr<ul>
gr<li><pre><a>runContT</a> (<a>withContT</a> f m) = <a>runContT</a> m .
grf</pre></li>
gr</ul>
withContT :: () => b -> m r -> a -> m r -> ContT r m a -> ContT r m b


-- | The MonadWriter class.
gr
grInspired by the paper <i>Functional Programming with Overloading and
grHigher-Order Polymorphism</i>, Mark P Jones
gr(<a>http://web.cecs.pdx.edu/~mpj/pubs/springschool.html</a>) Advanced
grSchool of Functional Programming, 1995.
module Control.Monad.Writer.Class
class (Monoid w, Monad m) => MonadWriter w m | m -> w

-- | <tt><a>writer</a> (a,w)</tt> embeds a simple writer action.
writer :: MonadWriter w m => (a, w) -> m a

-- | <tt><a>tell</a> w</tt> is an action that produces the output
gr<tt>w</tt>.
tell :: MonadWriter w m => w -> m ()

-- | <tt><a>listen</a> m</tt> is an action that executes the action
gr<tt>m</tt> and adds its output to the value of the computation.
listen :: MonadWriter w m => m a -> m (a, w)

-- | <tt><a>pass</a> m</tt> is an action that executes the action
gr<tt>m</tt>, which returns a value and a function, and returns the
grvalue, applying the function to the output.
pass :: MonadWriter w m => m (a, w -> w) -> m a

-- | <tt><a>listens</a> f m</tt> is an action that executes the action
gr<tt>m</tt> and adds the result of applying <tt>f</tt> to the output to
grthe value of the computation.
gr
gr<ul>
gr<li><pre><a>listens</a> f m = <a>liftM</a> (id *** f) (<a>listen</a>
grm)</pre></li>
gr</ul>
listens :: MonadWriter w m => (w -> b) -> m a -> m (a, b)

-- | <tt><a>censor</a> f m</tt> is an action that executes the action
gr<tt>m</tt> and applies the function <tt>f</tt> to its output, leaving
grthe return value unchanged.
gr
gr<ul>
gr<li><pre><a>censor</a> f m = <a>pass</a> (<a>liftM</a> (\x -&gt;
gr(x,f)) m)</pre></li>
gr</ul>
censor :: MonadWriter w m => (w -> w) -> m a -> m a
instance (GHC.Base.Monoid w, GHC.Base.Monad m) => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (GHC.Base.Monoid w, GHC.Base.Monad m) => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.Writer.Strict.WriterT w m)
instance (GHC.Base.Monoid w, GHC.Base.Monad m) => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (GHC.Base.Monoid w, GHC.Base.Monad m) => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance (Control.Monad.Trans.Error.Error e, Control.Monad.Writer.Class.MonadWriter w m) => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.Error.ErrorT e m)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.Maybe.MaybeT m)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.Reader.ReaderT r m)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.State.Lazy.StateT s m)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.State.Strict.StateT s m)


-- | Declaration of the MonadRWS class.
gr
grInspired by the paper <i>Functional Programming with Overloading and
grHigher-Order Polymorphism</i>, Mark P Jones
gr(<a>http://web.cecs.pdx.edu/~mpj/</a>) Advanced School of Functional
grProgramming, 1995.
module Control.Monad.RWS.Class
class (Monoid w, MonadReader r m, MonadWriter w m, MonadState s m) => MonadRWS r w s m | m -> r, m -> w, m -> s
instance (GHC.Base.Monoid w, GHC.Base.Monad m) => Control.Monad.RWS.Class.MonadRWS r w s (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (GHC.Base.Monoid w, GHC.Base.Monad m) => Control.Monad.RWS.Class.MonadRWS r w s (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance Control.Monad.RWS.Class.MonadRWS r w s m => Control.Monad.RWS.Class.MonadRWS r w s (Control.Monad.Trans.Except.ExceptT e m)
instance (Control.Monad.Trans.Error.Error e, Control.Monad.RWS.Class.MonadRWS r w s m) => Control.Monad.RWS.Class.MonadRWS r w s (Control.Monad.Trans.Error.ErrorT e m)
instance Control.Monad.RWS.Class.MonadRWS r w s m => Control.Monad.RWS.Class.MonadRWS r w s (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.RWS.Class.MonadRWS r w s m => Control.Monad.RWS.Class.MonadRWS r w s (Control.Monad.Trans.Maybe.MaybeT m)


-- | Strict RWS monad.
gr
grInspired by the paper <i>Functional Programming with Overloading and
grHigher-Order Polymorphism</i>, Mark P Jones
gr(<a>http://web.cecs.pdx.edu/~mpj/</a>) Advanced School of Functional
grProgramming, 1995.
module Control.Monad.RWS.Strict

-- | A monad containing an environment of type <tt>r</tt>, output of type
gr<tt>w</tt> and an updatable state of type <tt>s</tt>.
type RWS r w s = RWST r w s Identity

-- | Construct an RWS computation from a function. (The inverse of
gr<a>runRWS</a>.)
rws :: () => r -> s -> (a, s, w) -> RWS r w s a

-- | Unwrap an RWS computation as a function. (The inverse of <a>rws</a>.)
runRWS :: () => RWS r w s a -> r -> s -> (a, s, w)

-- | Evaluate a computation with the given initial state and environment,
grreturning the final value and output, discarding the final state.
evalRWS :: () => RWS r w s a -> r -> s -> (a, w)

-- | Evaluate a computation with the given initial state and environment,
grreturning the final state and output, discarding the final value.
execRWS :: () => RWS r w s a -> r -> s -> (s, w)

-- | Map the return value, final state and output of a computation using
grthe given function.
gr
gr<ul>
gr<li><pre><a>runRWS</a> (<a>mapRWS</a> f m) r s = f (<a>runRWS</a> m r
grs)</pre></li>
gr</ul>
mapRWS :: () => (a, s, w) -> (b, s, w') -> RWS r w s a -> RWS r w' s b

-- | <tt><a>withRWS</a> f m</tt> executes action <tt>m</tt> with an initial
grenvironment and state modified by applying <tt>f</tt>.
gr
gr<ul>
gr<li><pre><a>runRWS</a> (<a>withRWS</a> f m) r s = <a>uncurry</a>
gr(<a>runRWS</a> m) (f r s)</pre></li>
gr</ul>
withRWS :: () => r' -> s -> (r, s) -> RWS r w s a -> RWS r' w s a

-- | A monad transformer adding reading an environment of type <tt>r</tt>,
grcollecting an output of type <tt>w</tt> and updating a state of type
gr<tt>s</tt> to an inner monad <tt>m</tt>.
newtype RWST r w s (m :: * -> *) a
RWST :: r -> s -> m (a, s, w) -> RWST r w s a
runRWST :: RWST r w s m a -> r -> s -> m (a, s, w)

-- | Evaluate a computation with the given initial state and environment,
grreturning the final value and output, discarding the final state.
evalRWST :: Monad m => RWST r w s m a -> r -> s -> m (a, w)

-- | Evaluate a computation with the given initial state and environment,
grreturning the final state and output, discarding the final value.
execRWST :: Monad m => RWST r w s m a -> r -> s -> m (s, w)

-- | Map the inner computation using the given function.
gr
gr<ul>
gr<li><pre><a>runRWST</a> (<a>mapRWST</a> f m) r s = f (<a>runRWST</a> m
grr s)</pre></li>
gr</ul>
mapRWST :: () => m (a, s, w) -> n (b, s, w') -> RWST r w s m a -> RWST r w' s n b

-- | <tt><a>withRWST</a> f m</tt> executes action <tt>m</tt> with an
grinitial environment and state modified by applying <tt>f</tt>.
gr
gr<ul>
gr<li><pre><a>runRWST</a> (<a>withRWST</a> f m) r s = <a>uncurry</a>
gr(<a>runRWST</a> m) (f r s)</pre></li>
gr</ul>
withRWST :: () => r' -> s -> (r, s) -> RWST r w s m a -> RWST r' w s m a


-- | Lazy RWS monad.
gr
grInspired by the paper <i>Functional Programming with Overloading and
grHigher-Order Polymorphism</i>, Mark P Jones
gr(<a>http://web.cecs.pdx.edu/~mpj/</a>) Advanced School of Functional
grProgramming, 1995.
module Control.Monad.RWS.Lazy

-- | A monad containing an environment of type <tt>r</tt>, output of type
gr<tt>w</tt> and an updatable state of type <tt>s</tt>.
type RWS r w s = RWST r w s Identity

-- | Construct an RWS computation from a function. (The inverse of
gr<a>runRWS</a>.)
rws :: () => r -> s -> (a, s, w) -> RWS r w s a

-- | Unwrap an RWS computation as a function. (The inverse of <a>rws</a>.)
runRWS :: () => RWS r w s a -> r -> s -> (a, s, w)

-- | Evaluate a computation with the given initial state and environment,
grreturning the final value and output, discarding the final state.
evalRWS :: () => RWS r w s a -> r -> s -> (a, w)

-- | Evaluate a computation with the given initial state and environment,
grreturning the final state and output, discarding the final value.
execRWS :: () => RWS r w s a -> r -> s -> (s, w)

-- | Map the return value, final state and output of a computation using
grthe given function.
gr
gr<ul>
gr<li><pre><a>runRWS</a> (<a>mapRWS</a> f m) r s = f (<a>runRWS</a> m r
grs)</pre></li>
gr</ul>
mapRWS :: () => (a, s, w) -> (b, s, w') -> RWS r w s a -> RWS r w' s b

-- | <tt><a>withRWS</a> f m</tt> executes action <tt>m</tt> with an initial
grenvironment and state modified by applying <tt>f</tt>.
gr
gr<ul>
gr<li><pre><a>runRWS</a> (<a>withRWS</a> f m) r s = <a>uncurry</a>
gr(<a>runRWS</a> m) (f r s)</pre></li>
gr</ul>
withRWS :: () => r' -> s -> (r, s) -> RWS r w s a -> RWS r' w s a

-- | A monad transformer adding reading an environment of type <tt>r</tt>,
grcollecting an output of type <tt>w</tt> and updating a state of type
gr<tt>s</tt> to an inner monad <tt>m</tt>.
newtype RWST r w s (m :: * -> *) a
RWST :: r -> s -> m (a, s, w) -> RWST r w s a
runRWST :: RWST r w s m a -> r -> s -> m (a, s, w)

-- | Evaluate a computation with the given initial state and environment,
grreturning the final value and output, discarding the final state.
evalRWST :: Monad m => RWST r w s m a -> r -> s -> m (a, w)

-- | Evaluate a computation with the given initial state and environment,
grreturning the final state and output, discarding the final value.
execRWST :: Monad m => RWST r w s m a -> r -> s -> m (s, w)

-- | Map the inner computation using the given function.
gr
gr<ul>
gr<li><pre><a>runRWST</a> (<a>mapRWST</a> f m) r s = f (<a>runRWST</a> m
grr s)</pre></li>
gr</ul>
mapRWST :: () => m (a, s, w) -> n (b, s, w') -> RWST r w s m a -> RWST r w' s n b

-- | <tt><a>withRWST</a> f m</tt> executes action <tt>m</tt> with an
grinitial environment and state modified by applying <tt>f</tt>.
gr
gr<ul>
gr<li><pre><a>runRWST</a> (<a>withRWST</a> f m) r s = <a>uncurry</a>
gr(<a>runRWST</a> m) (f r s)</pre></li>
gr</ul>
withRWST :: () => r' -> s -> (r, s) -> RWST r w s m a -> RWST r' w s m a


-- | Declaration of the MonadRWS class.
gr
grInspired by the paper <i>Functional Programming with Overloading and
grHigher-Order Polymorphism</i>, Mark P Jones
gr(<a>http://web.cecs.pdx.edu/~mpj/</a>) Advanced School of Functional
grProgramming, 1995.
module Control.Monad.RWS


-- | Lazy writer monads.
gr
grInspired by the paper <i>Functional Programming with Overloading and
grHigher-Order Polymorphism</i>, Mark P Jones
gr(<a>http://web.cecs.pdx.edu/~mpj/pubs/springschool.html</a>) Advanced
grSchool of Functional Programming, 1995.
module Control.Monad.Writer.Lazy
class (Monoid w, Monad m) => MonadWriter w m | m -> w

-- | <tt><a>writer</a> (a,w)</tt> embeds a simple writer action.
writer :: MonadWriter w m => (a, w) -> m a

-- | <tt><a>tell</a> w</tt> is an action that produces the output
gr<tt>w</tt>.
tell :: MonadWriter w m => w -> m ()

-- | <tt><a>listen</a> m</tt> is an action that executes the action
gr<tt>m</tt> and adds its output to the value of the computation.
listen :: MonadWriter w m => m a -> m (a, w)

-- | <tt><a>pass</a> m</tt> is an action that executes the action
gr<tt>m</tt>, which returns a value and a function, and returns the
grvalue, applying the function to the output.
pass :: MonadWriter w m => m (a, w -> w) -> m a

-- | <tt><a>listens</a> f m</tt> is an action that executes the action
gr<tt>m</tt> and adds the result of applying <tt>f</tt> to the output to
grthe value of the computation.
gr
gr<ul>
gr<li><pre><a>listens</a> f m = <a>liftM</a> (id *** f) (<a>listen</a>
grm)</pre></li>
gr</ul>
listens :: MonadWriter w m => (w -> b) -> m a -> m (a, b)

-- | <tt><a>censor</a> f m</tt> is an action that executes the action
gr<tt>m</tt> and applies the function <tt>f</tt> to its output, leaving
grthe return value unchanged.
gr
gr<ul>
gr<li><pre><a>censor</a> f m = <a>pass</a> (<a>liftM</a> (\x -&gt;
gr(x,f)) m)</pre></li>
gr</ul>
censor :: MonadWriter w m => (w -> w) -> m a -> m a

-- | A writer monad parameterized by the type <tt>w</tt> of output to
graccumulate.
gr
grThe <a>return</a> function produces the output <a>mempty</a>, while
gr<tt>&gt;&gt;=</tt> combines the outputs of the subcomputations using
gr<a>mappend</a>.
type Writer w = WriterT w Identity

-- | Unwrap a writer computation as a (result, output) pair. (The inverse
grof <a>writer</a>.)
runWriter :: () => Writer w a -> (a, w)

-- | Extract the output from a writer computation.
gr
gr<ul>
gr<li><pre><a>execWriter</a> m = <a>snd</a> (<a>runWriter</a>
grm)</pre></li>
gr</ul>
execWriter :: () => Writer w a -> w

-- | Map both the return value and output of a computation using the given
grfunction.
gr
gr<ul>
gr<li><pre><a>runWriter</a> (<a>mapWriter</a> f m) = f (<a>runWriter</a>
grm)</pre></li>
gr</ul>
mapWriter :: () => (a, w) -> (b, w') -> Writer w a -> Writer w' b

-- | A writer monad parameterized by:
gr
gr<ul>
gr<li><tt>w</tt> - the output to accumulate.</li>
gr<li><tt>m</tt> - The inner monad.</li>
gr</ul>
gr
grThe <a>return</a> function produces the output <a>mempty</a>, while
gr<tt>&gt;&gt;=</tt> combines the outputs of the subcomputations using
gr<a>mappend</a>.
newtype WriterT w (m :: * -> *) a
WriterT :: m (a, w) -> WriterT w a
runWriterT :: WriterT w m a -> m (a, w)

-- | Extract the output from a writer computation.
gr
gr<ul>
gr<li><pre><a>execWriterT</a> m = <a>liftM</a> <a>snd</a>
gr(<a>runWriterT</a> m)</pre></li>
gr</ul>
execWriterT :: Monad m => WriterT w m a -> m w

-- | Map both the return value and output of a computation using the given
grfunction.
gr
gr<ul>
gr<li><pre><a>runWriterT</a> (<a>mapWriterT</a> f m) = f
gr(<a>runWriterT</a> m)</pre></li>
gr</ul>
mapWriterT :: () => m (a, w) -> n (b, w') -> WriterT w m a -> WriterT w' n b


-- | The MonadWriter class.
gr
grInspired by the paper <i>Functional Programming with Overloading and
grHigher-Order Polymorphism</i>, Mark P Jones
gr(<a>http://web.cecs.pdx.edu/~mpj/pubs/springschool.html</a>) Advanced
grSchool of Functional Programming, 1995.
module Control.Monad.Writer


-- | Strict writer monads.
gr
grInspired by the paper <i>Functional Programming with Overloading and
grHigher-Order Polymorphism</i>, Mark P Jones
gr(<a>http://web.cecs.pdx.edu/~mpj/pubs/springschool.html</a>) Advanced
grSchool of Functional Programming, 1995.
module Control.Monad.Writer.Strict
class (Monoid w, Monad m) => MonadWriter w m | m -> w

-- | <tt><a>writer</a> (a,w)</tt> embeds a simple writer action.
writer :: MonadWriter w m => (a, w) -> m a

-- | <tt><a>tell</a> w</tt> is an action that produces the output
gr<tt>w</tt>.
tell :: MonadWriter w m => w -> m ()

-- | <tt><a>listen</a> m</tt> is an action that executes the action
gr<tt>m</tt> and adds its output to the value of the computation.
listen :: MonadWriter w m => m a -> m (a, w)

-- | <tt><a>pass</a> m</tt> is an action that executes the action
gr<tt>m</tt>, which returns a value and a function, and returns the
grvalue, applying the function to the output.
pass :: MonadWriter w m => m (a, w -> w) -> m a

-- | <tt><a>listens</a> f m</tt> is an action that executes the action
gr<tt>m</tt> and adds the result of applying <tt>f</tt> to the output to
grthe value of the computation.
gr
gr<ul>
gr<li><pre><a>listens</a> f m = <a>liftM</a> (id *** f) (<a>listen</a>
grm)</pre></li>
gr</ul>
listens :: MonadWriter w m => (w -> b) -> m a -> m (a, b)

-- | <tt><a>censor</a> f m</tt> is an action that executes the action
gr<tt>m</tt> and applies the function <tt>f</tt> to its output, leaving
grthe return value unchanged.
gr
gr<ul>
gr<li><pre><a>censor</a> f m = <a>pass</a> (<a>liftM</a> (\x -&gt;
gr(x,f)) m)</pre></li>
gr</ul>
censor :: MonadWriter w m => (w -> w) -> m a -> m a

-- | A writer monad parameterized by the type <tt>w</tt> of output to
graccumulate.
gr
grThe <a>return</a> function produces the output <a>mempty</a>, while
gr<tt>&gt;&gt;=</tt> combines the outputs of the subcomputations using
gr<a>mappend</a>.
type Writer w = WriterT w Identity

-- | Unwrap a writer computation as a (result, output) pair. (The inverse
grof <a>writer</a>.)
runWriter :: () => Writer w a -> (a, w)

-- | Extract the output from a writer computation.
gr
gr<ul>
gr<li><pre><a>execWriter</a> m = <a>snd</a> (<a>runWriter</a>
grm)</pre></li>
gr</ul>
execWriter :: () => Writer w a -> w

-- | Map both the return value and output of a computation using the given
grfunction.
gr
gr<ul>
gr<li><pre><a>runWriter</a> (<a>mapWriter</a> f m) = f (<a>runWriter</a>
grm)</pre></li>
gr</ul>
mapWriter :: () => (a, w) -> (b, w') -> Writer w a -> Writer w' b

-- | A writer monad parameterized by:
gr
gr<ul>
gr<li><tt>w</tt> - the output to accumulate.</li>
gr<li><tt>m</tt> - The inner monad.</li>
gr</ul>
gr
grThe <a>return</a> function produces the output <a>mempty</a>, while
gr<tt>&gt;&gt;=</tt> combines the outputs of the subcomputations using
gr<a>mappend</a>.
newtype WriterT w (m :: * -> *) a
WriterT :: m (a, w) -> WriterT w a
[runWriterT] :: WriterT w a -> m (a, w)

-- | Extract the output from a writer computation.
gr
gr<ul>
gr<li><pre><a>execWriterT</a> m = <a>liftM</a> <a>snd</a>
gr(<a>runWriterT</a> m)</pre></li>
gr</ul>
execWriterT :: Monad m => WriterT w m a -> m w

-- | Map both the return value and output of a computation using the given
grfunction.
gr
gr<ul>
gr<li><pre><a>runWriterT</a> (<a>mapWriterT</a> f m) = f
gr(<a>runWriterT</a> m)</pre></li>
gr</ul>
mapWriterT :: () => m (a, w) -> n (b, w') -> WriterT w m a -> WriterT w' n b
