The monad that all effects in this library are based on.

An effectful computation is a value of type `Eff r a`. In this signature, r is a type-level list of effects that are being requested and need to be handled inside an effectful computation. a is the computation's result similar to other monads.

A computation's result can be retrieved via the run function. However, all effects used in the computation need to be handled by the use of the effects' run* functions before unwrapping the final result. For additional details, see the documentation of the effects you are using.

Get the result from a pure computation

A pure computation has type Eff '[] a. The empty effect-list indicates that no further effects need to be handled.

Case analysis for Eff datatype. If the value is Val a apply the first function to a; if it is E u q, apply the second function.

Case analysis for impure computations for Eff datatype. This uses prj.

Case analysis for impure computations for Eff datatype. This uses decomp.

Lifting: emulating monad transformers

A convenient alias to 'SetMember Lift (Lift m) r', which allows us to assert that the lifted type occurs ony once in the effect list.

Same as Lifted but with additional MonadBaseControl constraint

embed an operation of type `m a` into the Eff monad when Lift m is in a part of the effect-list.

The handler of Lift requests. It is meant to be terminal: we only allow a single Lifted Monad. Note, too, how this is different from other handlers.

Catching of dynamic exceptions See the problem in http://okmij.org/ftp/Haskell/misc.html#catch-MonadIO

You need this when using catches.

Catch multiple dynamic exceptions. The implementation follows that in Control.Exception almost exactly. Not yet tested. Could this be useful for control with cut?

The data constructors of Union are not exported

Strong Sum (Existential with the evidence) is an open union t is can be a GADT and hence not necessarily a Functor. Int is the index of t in the list r; that is, the index of t in the universe r

Typeclass that asserts that effect t is contained inside the effect-list r.

The FindElem typeclass is an implementation detail and not required for using the effect list or implementing custom effects.

This class is used for emulating monad transformers

Respond to requests of type t.

Abstract the recursive relay pattern, i.e., "somebody else's problem".

A convenient pattern: given a request (in an open union), either handle it (using default Handler) or relay it.

Handle implies that all requests of type t are dealt with, i.e., k (the response type) doesn't have t as part of its effect list. The Relay k r constraint ensures that k is an effectful computation (with effectlist r).

Note that we can only handle the leftmost effect type (a consequence of the OpenUnion implementation.

A less commonly needed variant with an explicit handler (instead of Handle t k constraint).

Intercept the request and possibly respond to it, but leave it unhandled. The Relay k r constraint ensures that k is an effectful computation (with effectlist r). As such, the effect type t will show up in the response type k.

A less common variant which uses the default handle from the Handle t k instance (in general, we may need to define new datatypes to call respond_relay with the default handler).

Embeds a less-constrained Eff into a more-constrained one. Analogous to MTL's lift.

Send a request and wait for a reply (resulting in an effectful computation).

Effectful arrow type: a function from a to b that also does effects denoted by r

An effectful function from a to b that is a composition of one or more effectful functions. The paremeter r describes the overall effect.

The composition members are accumulated in a type-aligned queue. Using a newtype here enables us to define Category and Arrow instances.

convert single effectful arrow into composable type. i.e., convert Arr to Arrs

Application to the `generalized effectful function' Arrs r b w, i.e., convert Arrs to Arr

Syntactic sugar for qApp

Lift a function to an arrow

The identity arrow

Arrow composition

Common pattern: append Arr to Arrs

Compose effectful arrows (and possibly change the effect!)

Compose effectful arrows (and possibly change the effect!)

Compose and then apply to function. This is a common pattern when processing requests. Different options of f allow us to handle or relay the request and continue on.