The Eff monad provides the implementation of a computation that performs an arbitrary set of algebraic effects. In Eff effs a, effs is a type-level list that contains all the effects that the computation may perform. For example, a computation that produces an Integer by consuming a String from the global environment and acting upon a single mutable cell containing a Bool would have the following type:

Eff '[Reader String, State Bool] Integer

Normally, a concrete list of effects is not used to parameterize Eff. Instead, the Member or Members constraints are used to express constraints on the list of effects without coupling a computation to a concrete list of effects. For example, the above example would more commonly be expressed with the following type:

Members '[Reader String, State Bool] effs => Eff effs Integer

This abstraction allows the computation to be used in functions that may perform other effects, and it also allows the effects to be handled in any order.

Effectful arrow type: a function from a :: * to b :: * that also does effects denoted by effs :: [* -> *].

An effectful function from a :: * to b :: * that is a composition of several effectful functions. The paremeter effs :: [* -> *] describes the overall effect. The composition members are accumulated in a type-aligned queue.

“Sends” an effect, which should be a value defined as part of an effect algebra (see the module documentation for Control.Monad.Freer), to an effectful computation. This is used to connect the definition of an effect to the Eff monad so that it can be used and handled.

Identical to send, but specialized to the final effect in effs to assist type inference. This is useful for running actions in a monad transformer stack used in conjunction with runM.

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

Runs a pure Eff computation, since an Eff computation that performs no effects (i.e. has no effects in its type-level list) is guaranteed to be pure. This is usually used as the final step of running an effectful computation, after all other effects have been discharged using effect handlers.

Typically, this function is composed as follows:

someProgram
  & runEff1 eff1Arg
  & runEff2 eff2Arg1 eff2Arg2
  & run

Like run, runM runs an Eff computation and extracts the result. Unlike run, runM allows a single effect to remain within the type-level list, which must be a monad. The value returned is a computation in that monad, which is useful in conjunction with sendM or liftBase for plugging in traditional transformer stacks.

Given a request, either handle it or relay it.

Parameterized handleRelay. Allows sending along some state of type s :: * to be handled for the target effect, or relayed to a handler that can- handle the target effect.

Intercept the request and possibly reply to it, but leave it unhandled.

Like interpose, but with support for an explicit state to help implement the interpreter.

Interpret an effect by transforming it into another effect on top of the stack. The primary use case of this function is allow interpreters to be defined in terms of other ones without leaking intermediary implementation details through the type signature.

Like replaceRelay, but with support for an explicit state to help implement the interpreter.

Function application in the context of an array of effects, Arrs effs b w.

Composition of effectful arrows (Arrs). Allows for the caller to change the effect environment, as well.

A data type for representing nondeterminstic choice.