Modulerio-0.1.25.0Haskell2010

RIO.State

Provides reexports of MonadState and related helpers.

Synopsis

class MonadState
value gets
value modify
value modify'
type State
value runState
value evalState
value execState
value mapState
value withState
newtype StateT
value evalStateT
value execStateT
value mapStateT
value withStateT

Packagerio-0.1.25.0
Exports15
LanguageHaskell2010
LicenceMIT
SourceState.hs

classclass Monad m => MonadState s (m :: Type -> Type) | m -> s where

Source#

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

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.

Instances18MonadState, …

MonadState s m => MonadState s (CatchT m)Defined in exceptions-0.10.12 · Control.Monad.Catch.Pure
MonadState s m => MonadState s (MaybeT m)Defined in mtl-2.3.2 · Control.Monad.State.Class
HasStateRef s env => MonadState s (RIO env)Defined in rio-0.1.25.0 · RIO.Prelude.RIO
Monad m => MonadState s (StateT s m)Defined in mtl-2.3.2 · Control.Monad.State.Class
Monad m => MonadState s (StateT s m)Defined in mtl-2.3.2 · Control.Monad.State.Class
MonadState s m => MonadState s (ExceptT e m)Defined in mtl-2.3.2 · Control.Monad.State.Class
MonadState s m => MonadState s (IdentityT m)Defined in mtl-2.3.2 · Control.Monad.State.Class
MonadState s m => MonadState s (ReaderT r m)Defined in mtl-2.3.2 · Control.Monad.State.Class
MonadState s m => MonadState s (SelectT r m)Defined in mtl-2.3.2 · Control.Monad.State.Class
(Monoid w, MonadState s m) => MonadState s (AccumT w m)Defined in mtl-2.3.2 · Control.Monad.State.Class
(Monoid w, MonadState s m) => MonadState s (WriterT w m)Defined in mtl-2.3.2 · Control.Monad.State.Class
(Monoid w, MonadState s m) => MonadState s (WriterT w m)Defined in mtl-2.3.2 · Control.Monad.State.Class
(Monoid w, MonadState s m) => MonadState s (WriterT w m)Defined in mtl-2.3.2 · Control.Monad.State.Class
MonadState s m => MonadState s (ContT r m)Defined in mtl-2.3.2 · Control.Monad.State.Class
(MonadState s m, MonadState s n) => MonadState s (Product m n)Defined in mtl-2.3.2 · Control.Monad.State.Class
(Monad m, Monoid w) => MonadState s (RWST r w s m)Defined in mtl-2.3.2 · Control.Monad.State.Class
(Monad m, Monoid w) => MonadState s (RWST r w s m)Defined in mtl-2.3.2 · Control.Monad.State.Class
(Monad m, Monoid w) => MonadState s (RWST r w s m)Defined in mtl-2.3.2 · Control.Monad.State.Class

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

Source#

Gets specific component of the state, using a projection function supplied.

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

Source#

Monadic state transformer.

Maps an old state to a new state inside a state monad. The old state is thrown away.

     Main> :t modify ((+1) :: Int -> Int)
     modify (...) :: (MonadState Int a) => a ()

This says that modify (+1) acts over any Monad that is a member of the MonadState class, with an Int state.

valuemodify' :: MonadState s m => (s -> s) -> m ()

Source#

A variant of modify in which the computation is strict in the new state.

typetype State s = StateT s Identity

Source#

A state monad parameterized by the type s of the state to carry.

The return function leaves the state unchanged, while >>= uses the final state of the first computation as the initial state of the second.

valuerunState

:: State s a
state-passing computation to execute
-> s
initial state
-> (a, s)
return value and final state

Source#

Unwrap a state monad computation as a function. (The inverse of state.)

valueevalState

:: State s a
state-passing computation to execute
-> s
initial value
-> a
return value of the state computation

Source#

Evaluate a state computation with the given initial state and return the final value, discarding the final state.

```
evalState m s = fst (runState m s)
```

valueexecState

:: State s a
state-passing computation to execute
-> s
initial value
-> s
final state

Source#

Evaluate a state computation with the given initial state and return the final state, discarding the final value.

```
execState m s = snd (runState m s)
```

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

Source#

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

runState (mapState f m) = f . runState m

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

Source#

withState f m executes action m on a state modified by applying f.

```
withState f m = modify f >> m
```

newtypenewtype StateT s (m :: Type -> Type) a

Source#

A state transformer monad parameterized by:

s - The state.
m - The inner monad.

The return function leaves the state unchanged, while >>= uses the final state of the first computation as the initial state of the second.

Constructors

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

Instances26MonadAccum, MonadError, MonadReader, MonadState, MonadWriter, MonadSelect, …

MonadAccum w m => MonadAccum w (StateT s m)Defined in mtl-2.3.2 · Control.Monad.Accum
MonadError e m => MonadError e (StateT s m)Defined in mtl-2.3.2 · Control.Monad.Error.Class
MonadReader r m => MonadReader r (StateT s m)Defined in mtl-2.3.2 · Control.Monad.Reader.Class
Monad m => MonadState s (StateT s m)Defined in mtl-2.3.2 · Control.Monad.State.Class
MonadWriter w m => MonadWriter w (StateT s m)Defined in mtl-2.3.2 · Control.Monad.Writer.Class
MonadSelect w m => MonadSelect w (StateT s m)Defined in mtl-2.3.2 · Control.Monad.Select
'Readerizes' the state: the 'ranking' function can see a value of type s, but not modify it. Effectively, can be thought of as 'extending' the 'ranking' by all values in s, but which s gets given to any rank calls is predetermined by the 'outer state' (and cannot change).
MonadTrans (StateT s)Defined in transformers-0.6.3.0 · Control.Monad.Trans.State.Lazy
Monad m => Monad (StateT s m)Defined in transformers-0.6.3.0 · Control.Monad.Trans.State.Lazy
Functor m => Functor (StateT s m)Defined in transformers-0.6.3.0 · Control.Monad.Trans.State.Lazy
MonadFix m => MonadFix (StateT s m)Defined in transformers-0.6.3.0 · Control.Monad.Trans.State.Lazy
MonadFail m => MonadFail (StateT s m)Defined in transformers-0.6.3.0 · Control.Monad.Trans.State.Lazy
(Functor m, Monad m) => Applicative (StateT s m)Defined in transformers-0.6.3.0 · Control.Monad.Trans.State.Lazy
(Functor m, MonadPlus m) => Alternative (StateT s m)Defined in transformers-0.6.3.0 · Control.Monad.Trans.State.Lazy
MonadPlus m => MonadPlus (StateT s m)Defined in transformers-0.6.3.0 · Control.Monad.Trans.State.Lazy
MonadIO m => MonadIO (StateT s m)Defined in transformers-0.6.3.0 · Control.Monad.Trans.State.Lazy
Contravariant m => Contravariant (StateT s m)Defined in transformers-0.6.3.0 · Control.Monad.Trans.State.Lazy
MonadCont m => MonadCont (StateT s m)Defined in mtl-2.3.2 · Control.Monad.Cont.Class
MonadCatch m => MonadCatch (StateT s m)Defined in exceptions-0.10.12 · Control.Monad.Catch
MonadMask m => MonadMask (StateT s m)Defined in exceptions-0.10.12 · Control.Monad.Catch
MonadThrow m => MonadThrow (StateT s m)Defined in exceptions-0.10.12 · Control.Monad.Catch
PrimMonad m => PrimMonad (StateT s m)Defined in primitive-0.9.1.0 · Control.Monad.Primitive
Monad z => Zoom (StateT s z) (StateT t z) s tDefined in microlens-mtl-0.2.1.1 · Lens.Micro.Mtl.Internal
Generic (StateT s m a)Defined in transformers-0.6.3.0 · Control.Monad.Trans.State.Lazy
type Rep (StateT s m a) = D1 ('MetaData "StateT" "Control.Monad.Trans.State.Lazy" "transformers-0.6.3.0-34b4" 'True) (C1 ('MetaCons "StateT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runStateT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (s -> m (a, s)))))Defined in transformers-0.6.3.0 · Control.Monad.Trans.State.Lazy
type PrimState (StateT s m) = PrimState mDefined in primitive-0.9.1.0 · Control.Monad.Primitive
type Zoomed (StateT s z) = Focusing zDefined in microlens-mtl-0.2.1.1 · Lens.Micro.Mtl.Internal

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

Source#

Evaluate a state computation with the given initial state and return the final value, discarding the final state.

evalStateT m s = liftM fst (runStateT m s)

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

Source#

Evaluate a state computation with the given initial state and return the final state, discarding the final value.

execStateT m s = liftM snd (runStateT m s)

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

Source#

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

runStateT (mapStateT f m) = f . runStateT m

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

Source#

withStateT f m executes action m on a state modified by applying f.

```
withStateT f m = modify f >> m
```