DeepControl.Monad.RWS

This module is just a concise mimic for RWS Monad in mtl(monad-transformer-library). The qualifier "concise" means that this module doesn't make no attempt to transform functions of any kind of Monad automatically. So when making some new data type of RWSTx, you have to manually define involved Monad instances, for example MonadError, by making use of the transformation functions such as trans, trans2, etc. Admittedly it is tedious though, you can deeply understand monad-transformation mechanism instead.

Documentation

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)

MonadReader r (Reader 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 m => MonadReader r (ReaderT r m)

Monoid w => MonadReader r (RWS r w s)

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

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

(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 => MonadWriter w (Writer w)

(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 m) => MonadWriter w (WriterT w m)

Monoid w => MonadWriter w (RWS r w s)

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

MonadState s (State s)

(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 m => MonadState s (StateT s m)

Monoid w => MonadState s (RWS r w s)

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

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

(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-0

newtype RWS r w s a

Constructors

RWS

Fields

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

Instances

Monoid w => MonadReader r (RWS r w s)

Monoid w => MonadState s (RWS r w s)

Monoid w => MonadWriter w (RWS r w s)

Monoid w => Monad (RWS r w s)

Functor (RWS r w s)

Monoid w => Applicative (RWS r w s)

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

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

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

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

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

Level-1

newtype RWST r w s m a

Constructors

RWST

Fields

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

Instances

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

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

(Monoid w, Monad m) => MonadWriter w (RWST r w s 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, Monad m) => Applicative (RWST r w s m)

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

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

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

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

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

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

liftCatch :: Catch e m (a, s, w) -> Catch e (RWST r w s m) a

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