unsafeSpanBenign before after thing runs the before action before evaluating `strat thing`, then runs the after action.

unsafeSpanBenign is not typically used directly in programs, but used to write safe benign-effect-spanning functions. It's a typical way of declaring effects as benign.

To call unsafeSpanBenign safely, make sure that the before and after actions are indeed benign.

An alternative to unsafeSpanBenign is to simply call unsafePerformIO directly over a bracket. See the source code for unsafeSpanBenign.

A (typed) key which lets you retrieve data in the lexical state.

Create a new field.

Fields are typically not exposed directly but only used internally to a module to make sure that other module don't create inconsistent contexts for you.

withAltering f g strat thing evaluates thing with the lexical state's field f set by g in the style of alter.

The reason why we need the strat argument is that, as a direct consequence of the design, the lexical state is passed dynamically to thing. That is, the state that is seen by a piece of code depends on where it's executed: if a lazy thunk escapes withAltering, then it's going to be picking up a different state. strat lets us be deliberate about what escapes and what doesn't. Namely the altered state is available precisely during the evaluation of strat thing.

withSetting f a thing evaluates thing with the local state's field f set to a.

See withAltering for more explanations.

This lets you modify the lexical state in an IO monad scope. The lexical state is still shared. See also withAltering.

Like withAlteringIO, but the strat is lazy.

Sets the lexical state in an IO context. See also withSetting and withAlteringIO.

Like withSettingIO, but the strat is lazy.

lookupLexicalState f returns Just a if a is the (lexical) value of field f in the lexical state. It returns Nothing is the field is unset.

lookupLexicalState f returns a if a is the (lexical) value of field f in the lexical state. It throws an error if the field is unset.

lookupLexicalState d f returns a if a is the (lexical) value of field f in the lexical state. It returns d if the field is unset.

In non-IO monadic code (that is when monads are used as a way to organise pure code), naturally, we'll be wanting to use benign effect as well. How scopes and running monadic code interleave doesn't have a generic answer. This is because monadic code is fundamentally staged: first you build a monadic expression, then it is run. Benign effects, and in particular local state updates, must happen when the monad is run, not when the expression is built.

Just like there isn't a generic run function, since all monads interpret the monadic expression differently, each monad needs to explain how they implement withAltering and unsafeSpanBenign. This is what the (admittedly poorly named) EvalM class lets monad do.

'withAlteringM f g strat thing works like withAltering f g strat thing, except that thing is a monadic action. The strat evaluates the return value. 'withAlteringM f g strat thing spans over the evaluation. See also EvalM.

Like withAlteringM, but the strat is lazy.

Like withSetting, but in a monadic context. See also withAlteringM.

Like withSettingM, but the strat is lazy.

Like unsafeSpanBenign, but in a monadic context. See also withAlteringM.

Like unsafeSpanBenignM, but the strat is lazy.

Evaluation strategies. The idea is that evaluating with strategy strat is the same as evaluating `strat a` in whnf.

This is inspired by Strategy from the parallel package. It's actually roughly the same type, but a little more modern. Making sure in particular that E, as a monoid, is strict, so that

foldMap :: Foldable t => Strat a -> Strat (t a)

Evaluates all the positions in a container.

A unit type with a strict monoid instance.

Doesn't do any evaluation.

Evaluates in whnf. Like seq