An effectful computation. An Effect l a may perform any of the effects specified by the list of effects l before returning a result of type a. The definition is isomorphic to the following GADT:

data Effect l a where
    Done :: a -> Effect l a
    Side :: Union l (Effect l a) -> Effect l a

Converts an computation that produces no effects into a regular value.

Executes an effect of type f that produces a return value of type a.

Executes an effect of type f that produces a return value of type r. Note that a specific instance of this function is of type Member f l => f (Effect l a) -> Effect l a, which allows users to send effects parameterized by effects.

The class of types which result in an effect. That is:

Effect l r
a -> Effect l r
a -> b -> Effect l r
...

Completely handles an effect. The second function parameter is passed an effect value and a continuation function.

The most common instantiation of this function is:

(a -> Effect l b) -> (f (Effect l b) -> Effect l b) -> Effect (f ': l) a -> Effect l b

Handles an effect without eliminating it. The second function parameter is passed an effect value and a continuation function.

The most common instantiation of this function is:

(a -> Effect l b) -> (f (Effect l b) -> Effect l b) -> Effect l a -> Effect l b

Adds an arbitrary effect to the head of the effect list.

Enables an effect that was previously disabled.

Hides an effect f by translating each instance of the effect into an equivalent effect further into the effect list.

conceal = eliminate return (\x k -> send x >>= k)

Hides an effect f by translating each instance of the effect into an equivalent effect at the head of the effect list.

Translates the first effect in the effect list into another effect.

rename f = eliminate return (\x k -> send (f x) >>= k) . swap . extend

Reorders the first two effects in a computation.

Rotates the first three effects in a computation.

Converts a set of effects l into a single effect f.

 mask f = conceal . rename f . unflatten

Converts an effect f into a set of effects l.

 unmask f = flatten . rename f . reveal

Represents a union of the list of type constructors in l parameterized by a. As an effect, it represents the union of each type constructor's corresponding effect. From the user's perspective, it provides a way to encapsulate multiple effects.

Distributes the sub-effects of a Union effect across a computation.

Collects some effects in a computation into a Union effect.

A constraint specifying that e is a member of the Row l.

A refined Membership constraint that can infer f from l, given name. In order for this to be used, Is name f must be defined. For example:

data Reader r a = ...

type instance Is Reader f = IsReader f

type IsReader f where
    IsReader (Reader r) = True
    IsReader f = False

type ReaderEffect r l = MemberEffect Reader (Reader r) l

ask :: ReaderEffect r l => Effect l r
ask = ...

Given the constraint ReaderEffect r l in the above example, r can be inferred from l.

Returns a boolean value indicating whether f belongs to the group of effects identified by name. This allows MemberEffect to infer the associated types for arbitrary effects.

A type level list with explicit removals.

Appends two type level Rows.

The class of Rows with statically known lengths.

The class of Rows that do not contain deletions (`:-).