Moduleeffectful-core-2.7.1.2GHC2021

Effectful.State.Static.Local

Support for access to a mutable value of a particular type.

The value is thread local. If you want it to be shared between threads, use Effectful.State.Static.Shared.

Note: unlike the Control.Monad.Trans.State.StateT monad transformer from the transformers library, the State effect doesn't discard state updates when an exception is received:

Example3 expressions

>>> import Control.Exception (ErrorCall)>>> import Control.Monad.Catch>>> import Control.Monad.Trans.State.Strict qualified as S

Example1 expression

>>> :{  (`S.execStateT` "Hi") . handle (\(_::ErrorCall) -> pure ()) $ do    S.modify (++ " there!")    error "oops":}"Hi"

Example1 expression

>>> :{  runEff . execState "Hi" . handle (\(_::ErrorCall) -> pure ()) $ do    modify (++ " there!")    error "oops":}"Hi there!"

1 type
10 values

Packageeffectful-core-2.7.1.2
Exports11
LanguageGHC2021
LicenceBSD-3-Clause
SourceLocal.hs

Effect

1 declaration

datadata State s (a :: Type -> Type) b

Provide access to a strict (WHNF), thread local, mutable value of type s.

Instances2DispatchOf, StaticRep

type DispatchOf (State s) = 'Static 'NoSideEffectsDefined in effectful-core-2.7.1.2 · Effectful.State.Static.Local
data StaticRep (State s)
- State s
Defined in effectful-core-2.7.1.2 · Effectful.State.Static.Local

Handlers

valuerunState

:: HasCallStack
=> s
The initial state.
-> Eff (State s ': es) a
-> Eff es (a, s)

Run the State effect with the given initial state and return the final value along with the final state.

valueevalState

:: HasCallStack
=> s
The initial state.
-> Eff (State s ': es) a
-> Eff es a

Run the State effect with the given initial state and return the final value, discarding the final state.

valueexecState

:: HasCallStack
=> s
The initial state.
-> Eff (State s ': es) a
-> Eff es s

Run the State effect with the given initial state and return the final state, discarding the final value.

Operations

valueget :: (HasCallStack, State s :> es) => Eff es s

Fetch the current value of the state.

valuegets

:: (HasCallStack, State s :> es)
=> (s -> a)
The function to apply to the state.
-> Eff es a

Get a function of the current state.

gets f ≡ f <$> get

valueput :: (HasCallStack, State s :> es) => s -> Eff es ()

Set the current state to the given value.

valuestate

:: (HasCallStack, State s :> es)
=> (s -> (a, s))
The function to modify the state.
-> Eff es a

Apply the function to the current state and return a value.

valuemodify

:: (HasCallStack, State s :> es)
=> (s -> s)
The function to modify the state.
-> Eff es ()

Apply the function to the current state.

modify f ≡ state (\s -> ((), f s))

valuestateM

:: (HasCallStack, State s :> es)
=> (s -> Eff es (a, s))
The function to modify the state.
-> Eff es a

Deprecated. State modifications made via operations of the same State effect within the callback are discarded. Use a combination of get and put instead.

Apply the monadic function to the current state and return a value.

valuemodifyM

:: (HasCallStack, State s :> es)
=> (s -> Eff es s)
The monadic function to modify the state.
-> Eff es ()

Deprecated. State modifications made via operations of the same State effect within the callback are discarded. Use a combination of get and put instead.

Apply the monadic function to the current state.

modifyM f ≡ stateM (\s -> ((), ) <$> f s)