DeepControl.Monad.State

This module is just a concise mimic for State 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 StateT, 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 => 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)

modify :: MonadState s m => (s -> s) -> m ()

gets :: MonadState s m => (s -> a) -> m a

Level-0

newtype State s a

Constructors

State

Fields

runState :: s -> (a, s)

Instances

MonadState s (State s)

Monad (State s)

Functor (State s)

Applicative (State s)

evalState :: State s a -> s -> a

execState :: State s a -> s -> s

mapState :: ((a, s) -> (b, s)) -> State s a -> State s b

withState :: (s -> s) -> State s a -> State s a

Level-1

newtype StateT s m a

Constructors

StateT

Fields

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

Instances

Monad m => MonadState s (StateT s m)

MonadTrans (StateT s)

Monad m => Monad (StateT s m)

Functor m => Functor (StateT s m)

Monad m => Applicative (StateT s m)

(MonadIO m, Monad m) => MonadIO (StateT s m)

evalStateT :: Monad m => StateT s m a -> s -> m a

execStateT :: Monad m => StateT s m a -> s -> m s

mapStateT :: (m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b

withStateT :: (s -> s) -> StateT s m a -> StateT s m a

liftCatch :: Catch e m (a, s) -> Catch e (StateT s m) a

Level-2

newtype StateT2 s m1 m2 a

Constructors

StateT2

Fields

runStateT2 :: s -> m1 (m2 (a, s))

Instances

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

MonadTrans2 (StateT2 s)

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

(Functor m1, Functor m2) => Functor (StateT2 s m1 m2)

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

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

evalStateT2 :: (Monad m1, Monad2 m2) => StateT2 s m1 m2 a -> s -> m1 (m2 a)

execStateT2 :: (Monad m1, Monad2 m2) => StateT2 s m1 m2 a -> s -> m1 (m2 s)

mapStateT2 :: (m1 (m2 (a, s)) -> n1 (n2 (b, s))) -> StateT2 s m1 m2 a -> StateT2 s n1 n2 b

withStateT2 :: (s -> s) -> StateT2 s m1 m2 a -> StateT2 s m1 m2 a

Level-3

newtype StateT3 s m1 m2 m3 a

Constructors

StateT3

Fields

runStateT3 :: s -> m1 (m2 (m3 (a, s)))

Instances

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

MonadTrans3 (StateT3 s)

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

(Functor m1, Functor m2, Functor m3) => Functor (StateT3 s m1 m2 m3)

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

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

evalStateT3 :: (Monad m1, Monad2 m2, Monad3 m3) => StateT3 s m1 m2 m3 a -> s -> m1 (m2 (m3 a))

execStateT3 :: (Monad m1, Monad2 m2, Monad3 m3) => StateT3 s m1 m2 m3 a -> s -> m1 (m2 (m3 s))

mapStateT3 :: (m1 (m2 (m3 (a, s))) -> n1 (n2 (n3 (b, s)))) -> StateT3 s m1 m2 m3 a -> StateT3 s n1 n2 n3 b

withStateT3 :: (s -> s) -> StateT3 s m1 m2 m3 a -> StateT3 s m1 m2 m3 a