Skip to content

HORIZON HASKELL Docs lts/ghc-10.0.x77a86622026-10-31Search packagesCtrl K

Theme: |

GHC 10.0.0.20260917 · lts/ghc-10.0.x · 77a8662 · 2026-10-31

Moduletransformers-0.6.3.0Haskell2010

Control.Monad.Trans.RWS.Strict

A monad transformer that combines ReaderT, WriterT and StateT. This version is strict; for a lazy version with the same interface, see Control.Monad.Trans.RWS.Lazy. Although the output is built strictly, it is not possible to achieve constant space behaviour with this transformer: for that, use Control.Monad.Trans.RWS.CPS instead.

Contents

The RWS monad
The RWST monad transformer
Reader operations
Writer operations
State operations
Lifting other operations

Synopsis

type RWS
value rws
value runRWS
value evalRWS
value execRWS
value mapRWS
value withRWS
newtype RWST
value evalRWST
value execRWST
value mapRWST
value withRWST
value reader
value ask
value local
value asks
value writer
value tell
value listen
value listens
value pass
value censor
value state
value get
value put
value modify
value gets
value liftCallCC
value liftCallCC'
value liftCatch

Packagetransformers-0.6.3.0
Exports30
LanguageHaskell2010
LicenceBSD-3-Clause
SourceStrict.hs

The RWS monad

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

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

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

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

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

valueevalRWS

:: RWS r w s a
RWS computation to execute
-> r
initial environment
-> s
initial value
-> (a, w)
final value and output

Evaluate a computation with the given initial state and environment, returning the final value and output, discarding the final state.

valueexecRWS

:: RWS r w s a
RWS computation to execute
-> r
initial environment
-> s
initial value
-> (s, w)
final state and output

Evaluate a computation with the given initial state and environment, returning the final state and output, discarding the final value.

valuemapRWS :: ((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)

valuewithRWS :: (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)

The RWST monad transformer

newtypenewtype RWST r w s (m :: Type -> Type) 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.

Constructors

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

Instances12MonadTrans, Monad, Functor, MonadFix, MonadFail, Applicative, …

Monoid w => MonadTrans (RWST r w s)Defined in transformers-0.6.3.0 · Control.Monad.Trans.RWS.Strict
(Monoid w, Monad m) => Monad (RWST r w s m)Defined in transformers-0.6.3.0 · Control.Monad.Trans.RWS.Strict
Functor m => Functor (RWST r w s m)Defined in transformers-0.6.3.0 · Control.Monad.Trans.RWS.Strict
(Monoid w, MonadFix m) => MonadFix (RWST r w s m)Defined in transformers-0.6.3.0 · Control.Monad.Trans.RWS.Strict
(Monoid w, MonadFail m) => MonadFail (RWST r w s m)Defined in transformers-0.6.3.0 · Control.Monad.Trans.RWS.Strict
(Monoid w, Functor m, Monad m) => Applicative (RWST r w s m)Defined in transformers-0.6.3.0 · Control.Monad.Trans.RWS.Strict
(Monoid w, Functor m, MonadPlus m) => Alternative (RWST r w s m)Defined in transformers-0.6.3.0 · Control.Monad.Trans.RWS.Strict
(Monoid w, MonadPlus m) => MonadPlus (RWST r w s m)Defined in transformers-0.6.3.0 · Control.Monad.Trans.RWS.Strict
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)Defined in transformers-0.6.3.0 · Control.Monad.Trans.RWS.Strict
Contravariant m => Contravariant (RWST r w s m)Defined in transformers-0.6.3.0 · Control.Monad.Trans.RWS.Strict
Generic (RWST r w s m a)Defined in transformers-0.6.3.0 · Control.Monad.Trans.RWS.Strict
type Rep (RWST r w s m a) = D1 ('MetaData "RWST" "Control.Monad.Trans.RWS.Strict" "transformers-0.6.3.0-34b4" 'True) (C1 ('MetaCons "RWST" 'PrefixI 'True) (S1 ('MetaSel ('Just "runRWST") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (r -> s -> m (a, s, w)))))Defined in transformers-0.6.3.0 · Control.Monad.Trans.RWS.Strict

valueevalRWST

:: Monad m
=> RWST r w s m a
computation to execute
-> r
initial environment
-> s
initial value
-> m (a, w)
computation yielding final value and output

Evaluate a computation with the given initial state and environment, returning the final value and output, discarding the final state.

valueexecRWST

:: Monad m
=> RWST r w s m a
computation to execute
-> r
initial environment
-> s
initial value
-> m (s, w)
computation yielding final state and output

Evaluate a computation with the given initial state and environment, returning the final state and output, discarding the final value.

valuemapRWST

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

valuewithRWST :: (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)

Reader operations

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

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

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

Fetch the value of the environment.

valuelocal :: (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

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

Retrieve a function of the current environment.

```
asks f = liftM f ask
```

Writer operations

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

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

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

tell w is an action that produces the output w.

valuelisten :: 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)

valuelistens :: 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)

valuepass :: 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)

valuecensor :: 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)

State operations

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

Construct a state monad computation from a state transformer function.

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

Fetch the current value of the state within the monad.

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

put s sets the state within the monad to s.

valuemodify :: (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)
```

valuegets :: (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
```

Lifting other operations

valueliftCallCC

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

valueliftCallCC'

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

valueliftCatch :: 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.