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 effects monad. The 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.

The best practice is to always use a polymorphic type variable for the effect stack es, and then use the type operators (:>) and (:>>) in constraints to indicate what effects are available in the stack. For example,

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

means you can perform operations of the Reader String effect and the State Bool effect in a computation returning an Integer. The reason why you should always use a polymorphic effect stack as opposed to a concrete list of effects are that

• it can contain other effects that are used by computations other than the current one, and
• it does not require you to run the effects in any particular order.

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 an effect handler.

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) \).

e :> es means the effect e is present in the effect stack es, and therefore can be sended in an Eff es computation.

xs :>> es means the list of effects xs are all present in the effect stack es. This is a convenient type alias for (e1 :> es, ..., en :> es).

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

es is a subset of es', i.e. all elements of es are in 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 largely generalized version of send; only use this if you are sure about what you're doing.

send = sendVia id

Since: 0.2.0.0