Control.Monad.Trans.MultiState.Lazy

The multi-valued version of mtl's State / StateT

MultiStateT

newtype MultiStateT x m a

A State transformer monad patameterized by:

• x - The list of types constituting the state,
• m - The inner monad.

MultiStateT corresponds to mtl's StateT, but can contain a heterogenous list of types.

This heterogenous list is represented using Types.Data.List, i.e:

• '[] - The empty list,
• a ': b - A list where a is an arbitrary type and b is the rest list.

For example,

MultiStateT '[Int, Bool] :: (* -> *) -> (* -> *)

is a State wrapper containing the types [Int, Bool].

Constructors

MultiStateT

Fields

• runMultiStateTRaw :: StateT (HList x) m a

Instances

MonadBase b m => MonadBase b (MultiStateT s m)

Methods

liftBase :: b α -> MultiStateT s m α

MonadBaseControl b m => MonadBaseControl b (MultiStateT s m)

Associated Types

type StM (MultiStateT s m :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (MultiStateT s m) b -> b a) -> MultiStateT s m a

restoreM :: StM (MultiStateT s m) a -> MultiStateT s m a

MonadState s m => MonadState s (MultiStateT c m)

Methods

get :: MultiStateT c m s

put :: s -> MultiStateT c m ()

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

MonadWriter w m => MonadWriter w (MultiStateT c m)

Methods

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

tell :: w -> MultiStateT c m ()

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

pass :: MultiStateT c m (a, w -> w) -> MultiStateT c m a

(Monad m, ContainsType a c) => MonadMultiState a (MultiStateT c m)

Methods

mSet :: a -> MultiStateT c m ()

mGet :: MultiStateT c m a

MonadTrans (MultiStateT x)

Methods

lift :: Monad m => m a -> MultiStateT x m a

MonadTransControl (MultiStateT s)

Associated Types

type StT (MultiStateT s :: (* -> *) -> * -> *) a :: *

Methods

liftWith :: Monad m => (Run (MultiStateT s) -> m a) -> MultiStateT s m a

restoreT :: Monad m => m (StT (MultiStateT s) a) -> MultiStateT s m a

Monad m => Monad (MultiStateT x m)

Methods

(>>=) :: MultiStateT x m a -> (a -> MultiStateT x m b) -> MultiStateT x m b

(>>) :: MultiStateT x m a -> MultiStateT x m b -> MultiStateT x m b

return :: a -> MultiStateT x m a

fail :: String -> MultiStateT x m a

Functor f => Functor (MultiStateT x f)

Methods

fmap :: (a -> b) -> MultiStateT x f a -> MultiStateT x f b

(<$) :: a -> MultiStateT x f b -> MultiStateT x f a

MonadFix m => MonadFix (MultiStateT s m)

Methods

mfix :: (a -> MultiStateT s m a) -> MultiStateT s m a

(Applicative m, Monad m) => Applicative (MultiStateT x m)

Methods

pure :: a -> MultiStateT x m a

(<*>) :: MultiStateT x m (a -> b) -> MultiStateT x m a -> MultiStateT x m b

(*>) :: MultiStateT x m a -> MultiStateT x m b -> MultiStateT x m b

(<*) :: MultiStateT x m a -> MultiStateT x m b -> MultiStateT x m a

MonadIO m => MonadIO (MultiStateT c m)

Methods

liftIO :: IO a -> MultiStateT c m a

(Functor m, Applicative m, MonadPlus m) => Alternative (MultiStateT s m)

Methods

empty :: MultiStateT s m a

(<|>) :: MultiStateT s m a -> MultiStateT s m a -> MultiStateT s m a

some :: MultiStateT s m a -> MultiStateT s m [a]

many :: MultiStateT s m a -> MultiStateT s m [a]

MonadPlus m => MonadPlus (MultiStateT s m)

Methods

mzero :: MultiStateT s m a

mplus :: MultiStateT s m a -> MultiStateT s m a -> MultiStateT s m a

type StT (MultiStateT s) a

type StT (MultiStateT s) a = (a, HList s)

type StM (MultiStateT s m) a

type StM (MultiStateT s m) a = ComposeSt (MultiStateT s) m a

type MultiStateTNull = MultiStateT '[]

A MultiState transformer carrying an empty state.

type MultiState x = MultiStateT x Identity

A state monad parameterized by the list of types x of the state to carry.

Similar to State s = StateT s Identity

MonadMultiState class

class Monad m => MonadMultiState a m where

All methods must be defined.

The idea is: Any monad stack is instance of MonadMultiState a, iff the stack contains a MultiStateT x with a element of x.

Minimal complete definition

mSet, mGet

Methods

mSet :: a -> m ()

state set function for values of type a.

mGet :: m a

state get function for values of type a.

Instances

(MonadTrans t, Monad (t m), MonadMultiState a m) => MonadMultiState a (t m)

Methods

mSet :: a -> t m ()

mGet :: t m a

(Monad m, ContainsType a c) => MonadMultiState a (MultiStateT c m)

Methods

mSet :: a -> MultiStateT c m ()

mGet :: MultiStateT c m a

(Monad m, ContainsType a c) => MonadMultiState a (MultiStateT c m)

Methods

mSet :: a -> MultiStateT c m ()

mGet :: MultiStateT c m a

(Monad m, ContainsType a s) => MonadMultiState a (MultiRWST r w s m)

Methods

mSet :: a -> MultiRWST r w s m ()

mGet :: MultiRWST r w s m a

(Monad m, ContainsType a s) => MonadMultiState a (MultiRWST r w s m)

Methods

mSet :: a -> MultiRWST r w s m ()

mGet :: MultiRWST r w s m a

run-functions

runMultiStateT :: Functor m => HList s -> MultiStateT s m a -> m (a, HList s)

runMultiStateTAS :: Functor m => HList s -> MultiStateT s m a -> m (a, HList s)

runMultiStateTSA :: Monad m => HList s -> MultiStateT s m a -> m (HList s, a)

runMultiStateTA :: Monad m => HList s -> MultiStateT s m a -> m a

runMultiStateTS :: Monad m => HList s -> MultiStateT s m a -> m (HList s)

runMultiStateT_ :: Functor m => HList s -> MultiStateT s m a -> m ()

runMultiStateTNil :: Monad m => MultiStateT '[] m a -> m a

runMultiStateTNil_ :: Functor m => MultiStateT '[] m a -> m ()

with-functions (single state)

withMultiState :: Monad m => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m (a, s)

withMultiStateAS :: Monad m => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m (a, s)

withMultiStateSA :: Monad m => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m (s, a)

withMultiStateA :: Monad m => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m a

withMultiStateS :: Monad m => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m s

withMultiState_ :: (Functor m, Monad m) => s -> MultiStateT (s ': ss) m a -> MultiStateT ss m ()

with-functions (multiple states)

withMultiStates :: Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (a, HList s1)

withMultiStatesAS :: Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (a, HList s1)

withMultiStatesSA :: Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (HList s1, a)

withMultiStatesA :: Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m a

withMultiStatesS :: Monad m => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m (HList s1)

withMultiStates_ :: (Functor m, Monad m) => HList s1 -> MultiStateT (Append s1 s2) m a -> MultiStateT s2 m ()

without-function (single state)

withoutMultiState :: (Functor m, Monad m) => MultiStateT ss m a -> MultiStateT (s ': ss) m a

inflate-functions (run single state in multiple states)

inflateState :: (Monad m, ContainsType s ss) => StateT s m a -> MultiStateT ss m a

inflateReader :: (Monad m, ContainsType r ss) => ReaderT r m a -> MultiStateT ss m a

inflateWriter :: (Monad m, ContainsType w ss, Monoid w) => WriterT w m a -> MultiStateT ss m a

other functions

mapMultiStateT :: (m (a, HList w) -> m' (a', HList w)) -> MultiStateT w m a -> MultiStateT w m' a'

Map both the return value and the state of a computation using the given function.

mGetRaw :: Monad m => MultiStateT a m (HList a)

A raw extractor of the contained HList (i.e. the complete state).

mPutRaw :: Monad m => HList s -> MultiStateT s m ()