Module

Control.Monad.State.Trans

Package: purescript-transformers
Repository: purescript/purescript-transformers

This module defines the state monad transformer, StateT.

#StateT Source

newtype StateT s m a

The state monad transformer.

This monad transformer extends the base monad with the operations get and put which can be used to model a single piece of mutable state.

The MonadState type class describes the operations supported by this monad.

Constructors

StateT (s -> m (Tuple a s))

Instances

Newtype (StateT s m a) _
(Functor m) => Functor (StateT s m)
(Monad m) => Apply (StateT s m)
(Monad m) => Applicative (StateT s m)
(Monad m, Alt m) => Alt (StateT s m)
(Monad m, Plus m) => Plus (StateT s m)
(Monad m, Alternative m) => Alternative (StateT s m)
(Monad m) => Bind (StateT s m)
(Monad m) => Monad (StateT s m)
(MonadRec m) => MonadRec (StateT s m)
(MonadZero m) => MonadZero (StateT s m)
(MonadPlus m) => MonadPlus (StateT s m)
MonadTrans (StateT s)
Lazy (StateT s m a)
(MonadEff eff m) => MonadEff eff (StateT s m)
(MonadCont m) => MonadCont (StateT s m)
(MonadThrow e m) => MonadThrow e (StateT s m)
(MonadError e m) => MonadError e (StateT s m)
(MonadAsk r m) => MonadAsk r (StateT s m)
(MonadReader r m) => MonadReader r (StateT s m)
(Monad m) => MonadState s (StateT s m)
(MonadTell w m) => MonadTell w (StateT s m)
(MonadWriter w m) => MonadWriter w (StateT s m)

#runStateT Source

runStateT :: forall a m s. StateT s m a -> s -> m (Tuple a s)

Run a computation in the StateT monad.

#evalStateT Source

evalStateT :: forall a m s. Functor m => StateT s m a -> s -> m a

Run a computation in the StateT monad, discarding the final state.

#execStateT Source

execStateT :: forall a m s. Functor m => StateT s m a -> s -> m s

Run a computation in the StateT monad discarding the result.

#mapStateT Source

mapStateT :: forall b a m2 m1 s. (m1 (Tuple a s) -> m2 (Tuple b s)) -> StateT s m1 a -> StateT s m2 b

Change the result type in a StateT monad action.

#withStateT Source

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

Modify the final state in a StateT monad action.

Re-exports from Control.Monad.State.Class

#MonadState Source

class (Monad m) <= MonadState s m | m -> s where

The MonadState s type class represents those monads which support a single piece of mutable state of type s.

state f updates the state using the function f.

An implementation is provided for StateT, and for other monad transformers defined in this library.

Laws:

do { get ; get } = get
do { put x ; put y } = put y
do { put x ; get } = put x $> x
do { s <- get ; put s } = pure unit

Members

state :: forall a. (s -> (Tuple a s)) -> m a

#put Source

put :: forall s m. MonadState s m => s -> m Unit

Set the state.

#modify Source

modify :: forall m s. MonadState s m => (s -> s) -> m Unit

Modify the state by applying a function to the current state.

#gets Source

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

Get a value which depends on the current state.

#get Source

get :: forall s m. MonadState s m => m s

Get the current state.

Re-exports from Control.Monad.Trans.Class

#MonadTrans Source

class MonadTrans t  where

The MonadTrans type class represents monad transformers.

A monad transformer is a type constructor of kind (* -> *) -> * -> *, which takes a Monad as its first argument, and returns another Monad.

This allows us to add additional effects to an existing monad. By iterating this process, we create monad transformer stacks, which contain all of the effects required for a particular computation.

The laws state that lift is a Monad morphism.

Laws:

lift (pure a) = pure a
lift (do { x <- m ; y }) = do { x <- lift m ; lift y }

Members

lift :: forall a m. Monad m => m a -> t m a