Documentation

Handler is a function that takes a result or an effect and a continuation |and handles it.

e is the effect functor you are handling

r represents the type of the type list of the remaining effects. Usually you want to be polymorphic in this.

a is the result type of the program you will handle

b is the result of handled computation.

Comp represents a computation. It is either a pure value or a computation that needs further evaluation and effect handling.

Result structure of the program is isomorphic to `Free (Union r) a`

effect is meant to be used as a helper function for defining new effects. See predefined effects for examples. Good way to use it is to pass in a lambda expression with explicit k for continuation. You will need to manually inj into the Union because of some GHC limitations.

A program without effects is guaranteed to be pure so you can safely convert it into a value.

Like runPure but for program results. You only need this for implementing some handlers.

Use a Handler on an Eff program to stripe away the first layer of effects. There are some issues if you are using a handler that is somewhat polymorphic in e As the compiler cannot figure out which effect are you handling. Currently the best solution seems to be to manually specify type of the handler such that it is monomorphic in e. Sorry.

Finish a program and convert it into a result structure.

Convert a result back into a program in order to compose it. This function might not be needed and might introduce some performance issues (it is used in handle) but we didn't find a way to drop it.

Smart constructor for Union. Injects the functor into any union of which the said functor is a member. Please note that only the type constructor need be a Typeable.

The Member type clas denotes that f is a member of type list r

The class Typeable allows a concrete representation of a type to be calculated.