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 operator (:>) 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. A convenient shorthand, (:>>), can also be used to indicate multiple effects being in a stack:

'[Reader String, State Bool] :>> es => Eff es 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 type of effects. An effect e m a takes an effect monad type m :: Type -> Type and a result type a :: Type.

The effect environment that corresponds effects in the stack to their respective handlers. 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.

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'.

Type level list concatenation.

A natural transformation from f to g. With this, instead of writing

runSomeEffect :: Eff (SomeEffect : es) a -> Eff es a

you can write:

runSomeEffect :: Eff (SomeEffect : es) ~> Eff es