Control.Eff.State

Strict state effect

Example: implementing Fresh

 runFresh' :: (Typeable i, Enum i, Num i) => Eff (Fresh i :> r) w -> i -> Eff r w
 runFresh' m s = fst <$> runState s (loop $ admin m)
  where
   loop (Val x) = return x
   loop (E u)   = case decomp u of
     Right (Fresh k) -> do
                       n <- getState
                       putState (n + 1)
                       loop (k n)
     Left u' -> send (\k -> unsafeReUnion $ k <$> u') >>= loop

Read-write State

data State s w

Strict state effect

Instances

Typeable2 State

Functor (State s)

getState :: Typeable e => Member (State e) r => Eff r e

Return the current value of the state.

putState :: Typeable e => Member (State e) r => e -> Eff r ()

Write a new value of the state.

onState :: (Typeable s, Member (State s) r) => (s -> s) -> Eff r ()

Transform the state with a function.

runState

Arguments

:: Typeable s

=> s

Initial state

-> Eff (State s :> r) w

Effect incorporating State

-> Eff r (s, w)

Effect containing final state and a return value

Run a State effect.

Reader

data Reader e v

The request for a value of type e from the current environment. This environment is analogous to a parameter of type e.

Instances

Typeable2 Reader

Functor (Reader e)

getReader :: (Typeable e, Member (Reader e) r) => Eff r e

Get the current value from a Reader.

runReader :: Typeable e => Eff (Reader e :> r) w -> e -> Eff r w

The handler of Reader requests. The return type shows that all Reader requests are fully handled.

local :: (Typeable e, Member (Reader e) r) => (e -> e) -> Eff r a -> Eff r a

Locally rebind the value in the dynamic environment. This function both requests and admins Reader requests.

Writer

data Writer e v

The request to remember a value of type e in the current environment

Instances

Typeable2 Writer

Functor (Writer e)

putWriter :: (Typeable e, Member (Writer e) r) => e -> Eff r ()

runWriter :: Typeable e => Eff (Writer e :> r) w -> Eff r (Maybe e, w)

Handle Writer requests by overwriting previous values. If no value of type e was returned, Nothing is returned; otherwise return Just the most recent value written.

runPusher :: Typeable e => Eff (Writer e :> r) w -> Eff r ([e], w)

Handle Writer requests by stacking written values on to a list.