type RWS r w s = RWST r w s Identity
A monad containing an environment of type r, output of type w
and an updatable state of type s.
A monad transformer that combines ReaderT,
WriterT and
StateT.
This version uses continuation-passing-style for the writer part
to achieve constant space usage.
For a lazy version with the same interface,
see Control.Monad.Trans.RWS.Lazy.
type RWS r w s = RWST r w s IdentityA monad containing an environment of type r, output of type w
and an updatable state of type s.
rws :: (Monoid w) => (r -> s -> (a, s, w)) -> RWS r w s aConstruct an RWS computation from a function.
(The inverse of runRWS.)
runRWS :: (Monoid w) => RWS r w s a -> r -> s -> (a, s, w)Unwrap an RWS computation as a function.
(The inverse of rws.)
evalRWS :: (Monoid w) => RWS r w s a -> r -> s -> (a, w)Evaluate a computation with the given initial state and environment, returning the final value and output, discarding the final state.
RWS computation to execute
rinitial environment
sinitial value
(a, w)final value and output
execRWS :: (Monoid w) => RWS r w s a -> r -> s -> (s, w)Evaluate a computation with the given initial state and environment, returning the final state and output, discarding the final value.
RWS computation to execute
rinitial environment
sinitial value
(s, w)final state and output
mapRWS :: (Monoid w, Monoid w') => ((a, s, w) -> (b, s, w')) -> RWS r w s a -> RWS r w' s bMap the return value, final state and output of a computation using the given function.
runRWS (mapRWS f m) r s = f (runRWS m r s)
withRWS :: (r' -> s -> (r, s)) -> RWS r w s a -> RWS r' w s a executes action withRWS f mm with an initial environment
and state modified by applying f.
runRWS (withRWS f m) r s = uncurry (runRWS m) (f r s)
newtype RWST r w s m aA monad transformer adding reading an environment of type r,
collecting an output of type w and updating a state of type s
to an inner monad m.
rwsT :: (Functor m, Monoid w) => (r -> s -> m (a, s, w)) -> RWST r w s m aConstruct an RWST computation from a function.
(The inverse of runRWST.)
runRWST :: (Monoid w) => RWST r w s m a -> r -> s -> m (a, s, w)Unwrap an RWST computation as a function.
(The inverse of rwsT.)
evalRWST :: (Monad m, Monoid w) => RWST r w s m a -> r -> s -> m (a, w)Evaluate a computation with the given initial state and environment, returning the final value and output, discarding the final state.
computation to execute
computation yielding final value and output
rinitial environment
sinitial value
execRWST :: (Monad m, Monoid w) => RWST r w s m a -> r -> s -> m (s, w)Evaluate a computation with the given initial state and environment, returning the final state and output, discarding the final value.
computation to execute
computation yielding final state and output
rinitial environment
sinitial value
mapRWST :: (Monad n, Monoid w, Monoid w') => (m (a, s, w) -> n (b, s, w')) -> RWST r w s m a -> RWST r w' s n bMap the inner computation using the given function.
mapRWST :: (m (a, s, w) -> n (b, s, w')) -> RWST r w s m a -> RWST r w' s n brunRWST (mapRWST f m) r s = f (runRWST m r s)
withRWST :: (r' -> s -> (r, s)) -> RWST r w s m a -> RWST r' w s m a executes action withRWST f mm with an initial environment
and state modified by applying f.
runRWST (withRWST f m) r s = uncurry (runRWST m) (f r s)
reader :: (Monad m) => (r -> a) -> RWST r w s m aConstructor for computations in the reader monad (equivalent to asks).
ask :: (Monad m) => RWST r w s m rFetch the value of the environment.
local :: (r -> r) -> RWST r w s m a -> RWST r w s m aExecute a computation in a modified environment
runRWST (local f m) r s = runRWST m (f r) s
asks :: (Monad m) => (r -> a) -> RWST r w s m aRetrieve a function of the current environment.
asks f = liftM f ask
writer :: (Monoid w, Monad m) => (a, w) -> RWST r w s m aConstruct a writer computation from a (result, output) pair.
tell :: (Monoid w, Monad m) => w -> RWST r w s m () is an action that produces the output tell ww.
listen :: (Monoid w, Monad m) => RWST r w s m a -> RWST r w s m (a, w) is an action that executes the action listen mm and adds its
output to the value of the computation.
runRWST (listen m) r s = liftM (\ (a, w) -> ((a, w), w)) (runRWST m r s)
listens :: (Monoid w, Monad m) => (w -> b) -> RWST r w s m a -> RWST r w s m (a, b) is an action that executes the action listens f mm and adds
the result of applying f to the output to the value of the computation.
listens f m = liftM (id *** f) (listen m)
runRWST (listens f m) r s = liftM (\ (a, w) -> ((a, f w), w)) (runRWST m r s)
pass :: (Monoid w, Monoid w', Monad m) => RWST r w s m (a, w -> w') -> RWST r w' s m a is an action that executes the action pass mm, which returns
a value and a function, and returns the value, applying the function
to the output.
runRWST (pass m) r s = liftM (\ ((a, f), w) -> (a, f w)) (runRWST m r s)
censor :: (Monoid w, Monad m) => (w -> w) -> RWST r w s m a -> RWST r w s m a is an action that executes the action censor f mm and
applies the function f to its output, leaving the return value
unchanged.
censor f m = pass (liftM (\ x -> (x,f)) m)
runRWST (censor f m) r s = liftM (\ (a, w) -> (a, f w)) (runRWST m r s)
state :: (Monad m) => (s -> (a, s)) -> RWST r w s m aConstruct a state monad computation from a state transformer function.
get :: (Monad m) => RWST r w s m sFetch the current value of the state within the monad.
put :: (Monad m) => s -> RWST r w s m () sets the state within the monad to put ss.
modify :: (Monad m) => (s -> s) -> RWST r w s m () is an action that updates the state to the result of
applying modify ff to the current state.
modify f = get >>= (put . f)
gets :: (Monad m) => (s -> a) -> RWST r w s m aGet a specific component of the state, using a projection function supplied.
gets f = liftM f get
liftCallCC :: CallCC m (a, s, w) (b, s, w) -> CallCC (RWST r w s m) a bUniform lifting of a callCC operation to the new monad.
This version rolls back to the original state on entering the
continuation.
liftCallCC' :: CallCC m (a, s, w) (b, s, w) -> CallCC (RWST r w s m) a bIn-situ lifting of a callCC operation to the new monad.
This version uses the current state on entering the continuation.
liftCatch :: Catch e m (a, s, w) -> Catch e (RWST r w s m) aLift a catchE operation to the new monad.
The uniformity property (see Control.Monad.Signatures) implies that
the lifted catchE discards any output or changes to the state from
the body on entering the handler.
instance (Generic r, Generic w, Generic s, Generic m, Generic a) => Generic (RWST r w s m a)instance (Functor m) => Functor (RWST r w s m)instance (Functor m, Monad m) => Applicative (RWST r w s m)instance (Functor m, MonadPlus m) => Alternative (RWST r w s m)instance (Monad m) => Monad (RWST r w s m)instance (Fail.MonadFail m) => Fail.MonadFail (RWST r w s m)instance (Functor m, MonadPlus m) => MonadPlus (RWST r w s m)instance (MonadFix m) => MonadFix (RWST r w s m)instance MonadTrans (RWST r w s)instance (MonadIO m) => MonadIO (RWST r w s m)Community contribution. The service has not verified this documentation.
Target: Linux on x86-64. Some inferred types and resolved links are not available.
Generator: aihc-haddock-858b1951-web-1
Metadata snapshot: ac77ab7d2b1e88487eeab41661abedb7bfb8bc846deb92e7874c08d166bff65d
Open the dependency plan · Download the documentation model