Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
Phantom State Transformer type and functions.
Synopsis
- data PhantomStateT s m a
- type PhantomState s = PhantomStateT s Identity
- useState :: Applicative m => (s -> m a) -> PhantomStateT s m ()
- changeState :: Applicative m => (s -> s) -> PhantomStateT s m ()
- useAndChangeState :: (s -> m s) -> PhantomStateT s m ()
- runPhantomStateT :: PhantomStateT s m a -> s -> m s
- runPhantomState :: PhantomState s a -> s -> s
Documentation
data PhantomStateT s m a Source #
The Phantom State Transformer is like the
State Monad Transformer, but it does not hold
any value. Therefore, it automatically discards
the result of any computation. Only changes in
the state and effects will remain. This transformer
produces a new Applicative
functor from any Monad
.
The primitive operations in this functor are:
useState
: Performs effects. State is unchanged.changeState
: Changes state. No effect is performed.useAndChangeState
: Changes state and performs effects.
Although useState
and changeState
are defined in
terms of useAndChangeState
:
useState f = useAndChangeState (\s -> f s *> pure s) changeState f = useAndChangeState (pure . f)
So useAndChangeState
is the only actual primitive.
Use runPhantomStateT
(or runPhantomState
) to get
the result of a phantom state computation.
Instances
type PhantomState s = PhantomStateT s Identity Source #
Type synonym of PhantomStateT
where the underlying Monad
is the Identity
monad.
useState :: Applicative m => (s -> m a) -> PhantomStateT s m () Source #
Perform an applicative action using the current state, leaving the state unchanged. The result will be discarded, so only the effect will remain.
changeState :: Applicative m => (s -> s) -> PhantomStateT s m () Source #
Modify the state using a pure function. No effect will be produced, only the state will be modified.
useAndChangeState :: (s -> m s) -> PhantomStateT s m () Source #
Combination of useState
and changeState
. It allows you to change the state while
performing any effects. The new state will be the result of applying the argument
function to the old state. The following equations hold:
useState f *> changeState g } } = useAndChangeState (\s -> f s *> g s) changeState g *> useState f }
:: PhantomStateT s m a | Phantom state computation |
-> s | Initial state |
-> m s | Final result |
Perform a phantom state computation by setting an initial state and running all the actions from there.
:: PhantomState s a | Phantom state computation |
-> s | Initial state |
-> s | Final result |
Specialized version of runPhantomStateT
where the underlying
Monad
is the Identity
monad.