The internal representation of effect handlers. This is just a natural transformation from the effect type e (Eff es) to the effect monad Eff es for any effect stack es.

In interpreting functions (see Cleff.Internal.Interpret), the user-facing Handler type is transformed into this type.

The extensible effect monad. A monad Eff es is capable of performing any effect in the effect stack es, which is a type-level list that holds all effects available. However, most of the times, for flexibility, es should be a polymorphic type variable, and you should use the (:>) and (:>>) operators in constraints to indicate what effects are in the stack. For example,

Reader String :> es, State Bool :> es => Eff es Integer

allows you to perform operations of the Reader String effect and the State Bool effect in a computation returning an Integer.

The effect environment that corresponds effects in the stack to their respective InternalHandlers. This structure simulates memory: handlers are retrieved via pointers (HandlerPtrs), and for each effect in the stack we can either change what pointer it uses or change the handler the pointer points to. The former is used for global effect interpretation (reinterpretN) and the latter for local interpretation (toEffWith) in order to retain correct HO semantics. For more details on this see https://github.com/re-xyr/cleff/issues/5.

A pointer to InternalHandler in an Env.

Create an empty Env with no address allocated.

Adjust the effect stack via an function over Rec.

Allocate a new, empty address for a handler. \( O(1) \).

Read the handler a pointer points to. \( O(1) \).

Overwrite the handler a pointer points to. \( O(1) \).

Replace the handler pointer of an effect in the stack. \( O(n) \).

Add a new effect to the stack with its corresponding handler pointer. \( O(n) \).

Use the state of LHS as a newer version for RHS. \( O(1) \).

The list es list is concrete, i.e. is of the form '[a1, a2, ..., an], i.e. is not a type variable.

es is a subset of es'.

Perform an effect operation, i.e. a value of an effect type e :: Effect. This requires e to be in the effect stack.

Perform an action in another effect stack via a transformation to that stack; in other words, this function "maps" the effect operation from effect stack es to es'. This is a generalization of send; end users most likely won't need to use this.

send = sendVia id