DeepControl.Monad.Trans.RWS

This module extended RWS Monad in mtl(monad-transformer-library).

Documentation

module Control.Monad.RWS

class Monad m => MonadReader r m | m -> r where

See examples in Control.Monad.Reader. Note, the partially applied function type (->) r is a simple reader monad. See the instance declaration below.

Minimal complete definition

(ask | reader), local

Methods

ask :: m r

Retrieves the monad environment.

local

Arguments

:: (r -> r)

The function to modify the environment.

-> m a

Reader to run in the modified environment.

-> m a

Executes a computation in a modified environment.

reader

Arguments

:: (r -> a)

The selector function to apply to the environment.

-> m a

Retrieves a function of the current environment.

Instances

MonadReader r m => MonadReader r (MaybeT m)

MonadReader r m => MonadReader r (ListT m)

MonadReader r m => MonadReader r (IdentityT m)

MonadReader r ((->) r)

(Monoid w, MonadReader r m) => MonadReader r (WriterT w m)

(Monoid w, MonadReader r m) => MonadReader r (WriterT w m)

MonadReader r m => MonadReader r (StateT s m)

MonadReader r m => MonadReader r (StateT s m)

Monad m => MonadReader r (ReaderT r m)

MonadReader r m => MonadReader r (ExceptT e m)

(Error e, MonadReader r m) => MonadReader r (ErrorT e m)

MonadReader r' m => MonadReader r' (ContT r m)

(Monad m1, Monad2 m2) => MonadReader r (ReaderT2 r m1 m2)

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

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

(Monad m1, Monad2 m2, Monad3 m3) => MonadReader r (ReaderT3 r m1 m2 m3)

(Monoid w, Monad m1, Monad2 m2) => MonadReader r (RWST2 r w s m1 m2)

(Monoid w, Monad m1, Monad2 m2, Monad3 m3) => MonadReader r (RWST3 r w s m1 m2 m3)

class (Monoid w, Monad m) => MonadWriter w m | m -> w where

Minimal complete definition

(writer | tell), listen, pass

Methods

writer :: (a, w) -> m a

writer (a,w) embeds a simple writer action.

tell :: w -> m ()

tell w is an action that produces the output w.

listen :: m a -> m (a, w)

listen m is an action that executes the action m and adds its output to the value of the computation.

pass :: m (a, w -> w) -> 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.

Instances

MonadWriter w m => MonadWriter w (MaybeT m)

MonadWriter w m => MonadWriter w (IdentityT m)

(Monoid w, Monad m) => MonadWriter w (WriterT w m)

(Monoid w, Monad m) => MonadWriter w (WriterT w m)

MonadWriter w m => MonadWriter w (StateT s m)

MonadWriter w m => MonadWriter w (StateT s m)

MonadWriter w m => MonadWriter w (ReaderT r m)

MonadWriter w m => MonadWriter w (ExceptT e m)

(Error e, MonadWriter w m) => MonadWriter w (ErrorT e m)

(Monoid w, Monad m1, Monad2 m2) => MonadWriter w (WriterT2 w m1 m2)

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

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

(Monoid w, Monad m1, Monad2 m2, Monad3 m3) => MonadWriter w (WriterT3 w m1 m2 m3)

(Monoid w, Monad m1, Monad2 m2) => MonadWriter w (RWST2 r w s m1 m2)

(Monoid w, Monad m1, Monad2 m2, Monad3 m3) => MonadWriter w (RWST3 r w s m1 m2 m3)

class Monad m => MonadState s m | m -> s where

Minimal definition is either both of get and put or just state

Minimal complete definition

state | get, put

Methods

get :: m s

Return the state from the internals of the monad.

put :: s -> m ()

Replace the state inside the monad.

state :: (s -> (a, s)) -> m a

Embed a simple state action into the monad.

Instances

MonadState s m => MonadState s (MaybeT m)

MonadState s m => MonadState s (ListT m)

MonadState s m => MonadState s (IdentityT m)

(Monoid w, MonadState s m) => MonadState s (WriterT w m)

(Monoid w, MonadState s m) => MonadState s (WriterT w m)

Monad m => MonadState s (StateT s m)

Monad m => MonadState s (StateT s m)

MonadState s m => MonadState s (ReaderT r m)

MonadState s m => MonadState s (ExceptT e m)

(Error e, MonadState s m) => MonadState s (ErrorT e m)

MonadState s m => MonadState s (ContT r m)

(Monad m1, Monad2 m2) => MonadState s (StateT2 s m1 m2)

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

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

(Monad m1, Monad2 m2, Monad3 m3) => MonadState s (StateT3 s m1 m2 m3)

(Monoid w, Monad m1, Monad2 m2) => MonadState s (RWST2 r w s m1 m2)

(Monoid w, Monad m1, Monad2 m2, Monad3 m3) => MonadState s (RWST3 r w s m1 m2 m3)

Level-2

newtype RWST2 r w s m1 m2 a

Constructors

RWST2

Fields

runRWST2 :: r -> s -> m1 (m2 (a, s, w))

Instances

(Monoid w, Monad m1, Monad2 m2) => MonadReader r (RWST2 r w s m1 m2)

(Monoid w, Monad m1, Monad2 m2) => MonadState s (RWST2 r w s m1 m2)

(Monoid w, Monad m1, Monad2 m2) => MonadWriter w (RWST2 r w s m1 m2)

Monoid w => MonadTrans2 (RWST2 r w s)

(Monoid w, Monad m1, Monad2 m2) => Monad (RWST2 r w s m1 m2)

(Functor m1, Functor m2) => Functor (RWST2 r w s m1 m2)

(Monoid w, Monad m1, Monad2 m2) => Applicative (RWST2 r w s m1 m2)

(Monoid w, MonadIO m1, Monad m1, Monad2 m2) => MonadIO (RWST2 r w s m1 m2)

rwsT2 :: (Monad m1, Monad2 m2) => (r -> s -> (a, s, w)) -> RWST2 r w s m1 m2 a

evalRWST2 :: (Monad m1, Monad2 m2) => RWST2 r w s m1 m2 a -> r -> s -> m1 (m2 (a, w))

execRWST2 :: (Monad m1, Monad2 m2) => RWST2 r w s m1 m2 a -> r -> s -> m1 (m2 (s, w))

mapRWST2 :: (m1 (m2 (a, s, w)) -> n1 (n2 (b, s, w'))) -> RWST2 r w s m1 m2 a -> RWST2 r w' s n1 n2 b

withRWST2 :: (r' -> s -> (r, s)) -> RWST2 r w s m1 m2 a -> RWST2 r' w s m1 m2 a

Level-3

newtype RWST3 r w s m1 m2 m3 a

Constructors

RWST3

Fields

runRWST3 :: r -> s -> m1 (m2 (m3 (a, s, w)))

Instances

(Monoid w, Monad m1, Monad2 m2, Monad3 m3) => MonadReader r (RWST3 r w s m1 m2 m3)

(Monoid w, Monad m1, Monad2 m2, Monad3 m3) => MonadState s (RWST3 r w s m1 m2 m3)

(Monoid w, Monad m1, Monad2 m2, Monad3 m3) => MonadWriter w (RWST3 r w s m1 m2 m3)

Monoid w => MonadTrans3 (RWST3 r w s)

(Monoid w, Monad m1, Monad2 m2, Monad3 m3) => Monad (RWST3 r w s m1 m2 m3)

(Functor m1, Functor m2, Functor m3) => Functor (RWST3 r w s m1 m2 m3)

(Monoid w, Monad m1, Monad2 m2, Monad3 m3) => Applicative (RWST3 r w s m1 m2 m3)

(Monoid w, MonadIO m1, Monad m1, Monad2 m2, Monad3 m3) => MonadIO (RWST3 r w s m1 m2 m3)

rwsT3 :: (Monad m1, Monad2 m2, Monad3 m3) => (r -> s -> (a, s, w)) -> RWST3 r w s m1 m2 m3 a

evalRWST3 :: (Monad m1, Monad2 m2, Monad3 m3) => RWST3 r w s m1 m2 m3 a -> r -> s -> m1 (m2 (m3 (a, w)))

execRWST3 :: (Monad m1, Monad2 m2, Monad3 m3) => RWST3 r w s m1 m2 m3 a -> r -> s -> m1 (m2 (m3 (s, w)))

mapRWST3 :: (m1 (m2 (m3 (a, s, w))) -> n1 (n2 (n3 (b, s, w')))) -> RWST3 r w s m1 m2 m3 a -> RWST3 r w' s n1 n2 n3 b

withRWST3 :: (r' -> s -> (r, s)) -> RWST3 r w s m1 m2 m3 a -> RWST3 r' w s m1 m2 m3 a