Copyright | (c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001 |
---|---|

License | BSD-style (see the file LICENSE) |

Maintainer | [email protected] |

Stability | experimental |

Portability | portable |

Safe Haskell | Safe |

Language | Haskell98 |

A monad transformer that combines `ReaderT`

, `WriterT`

and `StateT`

. This version is lazy; for a strict version with the same interface, see Control.Monad.Trans.RWS.Strict.

type RWS r w s = RWST r w s Identity Source

A monad containing an environment of type `r`

, output of type `w`

and an updatable state of type `s`

.

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

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

.)

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

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

.)

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

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

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

Map the return value, final state and output of a computation using the given function.

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

`withRWS f m`

executes action `m`

with an initial environment and state modified by applying `f`

.

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`

.

Monoid w => MonadTrans (RWST r w s) | |

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

Functor m => Functor (RWST r w s m) | |

(Monoid w, MonadFix m) => MonadFix (RWST r w s m) | |

(Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) | |

(Monoid w, Functor m, MonadPlus m) => Alternative (RWST r w s m) | |

(Monoid w, MonadPlus m) => MonadPlus (RWST r w s m) | |

(Monoid w, MonadIO m) => MonadIO (RWST r w s m) |

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

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

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

Map the inner computation using the given function.

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

`withRWST f m`

executes action `m`

with an initial environment and state modified by applying `f`

.

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

Constructor for computations in the reader monad (equivalent to `asks`

).

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

Fetch the value of the environment.

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

Execute a computation in a modified environment

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

Retrieve a function of the current environment.

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

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

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

`tell w`

is an action that produces the output `w`

.

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

`listen m`

is an action that executes the action `m`

and adds its output to the value of the computation.

listens :: (Monoid w, Monad m) => (w -> b) -> RWST r w s m a -> RWST r w s m (a, b) Source

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

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

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

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

`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 :: (Monoid w, Monad m) => (s -> (a, s)) -> RWST r w s m a Source

Construct a state monad computation from a state transformer function.

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

Fetch the current value of the state within the monad.

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

`put s`

sets the state within the monad to `s`

.

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

`modify f`

is an action that updates the state to the result of applying `f`

to the current state.

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

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

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

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 Source

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 Source

Lift a `catchE`

operation to the new monad.

© The University of Glasgow and others

Licensed under a BSD-style license (see top of the page).

https://downloads.haskell.org/~ghc/7.10.3/docs/html/libraries/transformers-0.4.2.0/Control-Monad-Trans-RWS-Lazy.html