Community
Modules 24

Control.Monad.Trans.RWS

experimental

A monad transformer that combines ReaderT, WriterT and StateT. This version is lazy; for a constant-space version with almost the same interface, see Control.Monad.Trans.RWS.CPS.

module Control.Monad.Trans.RWS.Lazy transformers-0.6.3.0 · 30 declarations

ask :: (Monoid w, Monad m) => RWST r w s m r

Fetch the value of the environment.

asks :: (Monoid w, Monad m) => (r -> a) -> RWST r w s m a

Retrieve a function of the current environment.

  • asks f = liftM f ask

censor :: (Monad m) => (w -> w) -> RWST r w s m a -> RWST r w s m a

censor f m is an action that executes the action m 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)

evalRWS :: 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

r

initial environment

s

initial value

(a, w)

final value and output

evalRWST :: (Monad m) => 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

r

initial environment

s

initial value

execRWS :: 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

r

initial environment

s

initial value

(s, w)

final state and output

execRWST :: (Monad m) => 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

r

initial environment

s

initial value

get :: (Monoid w, Monad m) => RWST r w s m s

Fetch the current value of the state within the monad.

gets :: (Monoid w, Monad m) => (s -> a) -> RWST r w s m a

Get a specific component of the state, using a projection function supplied.

  • gets f = liftM f get

liftCallCC :: (Monoid w) => CallCC m (a, s, w) (b, s, w) -> CallCC (RWST r w s m) a b

Uniform lifting of a callCC operation to the new monad. This version rolls back to the original state on entering the continuation.

liftCallCC' :: (Monoid w) => CallCC m (a, s, w) (b, s, w) -> CallCC (RWST r w s m) a b

In-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) a

Lift 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.

listen :: (Monad m) => RWST r w s m a -> RWST r w s m (a, w)

listen m is an action that executes the action m 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 :: (Monad m) => (w -> b) -> RWST r w s m a -> RWST r w s m (a, b)

listens f m is an action that executes the action m 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)

local :: (r -> r) -> RWST r w s m a -> RWST r w s m a

Execute a computation in a modified environment

  • runRWST (local f m) r s = runRWST m (f r) s

mapRWS :: ((a, s, w) -> (b, s, w')) -> RWS r w s a -> RWS r w' s b

Map 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)

mapRWST :: (m (a, s, w) -> n (b, s, w')) -> RWST r w s m a -> RWST r w' s n b

Map the inner computation using the given function.

  • runRWST (mapRWST f m) r s = f (runRWST m r s)

modify :: (Monoid w, Monad m) => (s -> s) -> RWST r w s m ()

modify f is an action that updates the state to the result of applying f to the current state.

  • modify f = get >>= (put . f)

pass :: (Monad m) => RWST r w s m (a, w -> w) -> RWST r w s m a

pass m is an action that executes the action m, 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)

put :: (Monoid w, Monad m) => s -> RWST r w s m ()

put s sets the state within the monad to s.

reader :: (Monoid w, Monad m) => (r -> a) -> RWST r w s m a

Constructor for computations in the reader monad (equivalent to asks).

runRWS :: RWS r w s a -> r -> s -> (a, s, w)

Unwrap an RWS computation as a function. (The inverse of rws.)

rws :: (r -> s -> (a, s, w)) -> RWS r w s a

Construct an RWS computation from a function. (The inverse of runRWS.)

state :: (Monoid w, Monad m) => (s -> (a, s)) -> RWST r w s m a

Construct a state monad computation from a state transformer function.

tell :: (Monad m) => w -> RWST r w s m ()

tell w is an action that produces the output w.

withRWS :: (r' -> s -> (r, s)) -> RWS r w s a -> RWS r' w s a

withRWS f m executes action m with an initial environment and state modified by applying f.

  • runRWS (withRWS f m) r s = uncurry (runRWS m) (f r s)

withRWST :: (r' -> s -> (r, s)) -> RWST r w s m a -> RWST r' w s m a

withRWST f m executes action m with an initial environment and state modified by applying f.

  • runRWST (withRWST f m) r s = uncurry (runRWST m) (f r s)

writer :: (Monad m) => (a, w) -> RWST r w s m a

Construct a writer computation from a (result, output) pair.

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.

newtype RWST r w s m a

A 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 :: r -> s -> m (a, s, w) -> RWST r w s m a

runRWST :: RWST r w s m a -> r -> s -> m (a, s, w)

Maintainer
R.Paterson@city.ac.uk
Portability
portable
Copyright
(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001
License
BSD-style (see the file LICENSE)
Build record and source files

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

Import a package

Enter a package name and an exact version from Hackage. The site contains imported versions only.