Lift a computation into a bigger effect stack with one more effect. For a more general version see raiseN.

Lift a computation into a bigger effect stack with arbitrarily more effects. This function requires TypeApplications.

Lift a computation with a fixed, known effect stack into some superset of the stack.

Eliminate a duplicate effect from the top of the effect stack. For a more general version see subsumeN.

Eliminate several duplicate effects from the top of the effect stack. This function requires TypeApplications.

The send-site environment.

The typeclass that indicates a handler scope, handling effect e sent from the effect stack esSend in the effect stack es.

You should not define instances for this typeclass whatsoever.

Get the pointer to the current effect handler itself.

Get the send-site Env.

Newtype wrapper for instantiating the Handling typeclass locally, a la the reflection trick. We do not use the reflection library directly so as not to expose this piece of implementation detail to the user.

Instantiate an Handling typeclass, i.e. pass an implicit send-site environment in. This function shouldn't be directly used anyhow.

The type of an effect handler, which is a function that transforms an effect e from an arbitrary effect stack into computations in the effect stack es.

The type of a simple transformation function from effect e to e'.

Transform a Handler into an InternalHandler given a pointer that is going to point to the InternalHandler and the current Env.

Interpret an effect e in terms of effects in the effect stack es with an effect handler.

Like interpret, but adds a new effect e' that can be used in the handler.

Like reinterpret, but adds two new effects.

Like reinterpret, but adds three new effects.

Like reinterpret, but adds arbitrarily many new effects. This function requires TypeApplications.

Respond to an effect while being able to leave it unhandled (i.e. you can resend the effects in the handler).

Like interpose, but allows to introduce one new effect to use in the handler.

Like impose, but allows introducing arbitrarily many effects. This requires TypeApplications.

Interpret an effect in terms of another effect in the stack via a simple Translator.

Like transform, but instead of using an effect in stack, add a new one to the top of it.

Common implementation of transform and translate. It is overly general on its own so it is not exported in Cleff.

Run a computation in the current effect stack. This is useful for interpreting higher-order effects, like a bracketing effect:

data Resource m a where
  Bracket :: m a -> (a -> m ()) -> (a -> m b) -> Resource m b

Bracket alloc dealloc use ->
  bracket
    (toEff alloc)
    (toEff . dealloc)
    (toEff . use)

Run a computation in the current effect stack, but handles the current effect inside the computation differently by providing a new Handler. This is useful for interpreting effects with local contexts, like Local:

runReader :: r -> Eff (Reader r ': es) ~> Eff es
runReader x = interpret (handle x)
  where
    handle :: r -> Handler (Reader r) es
    handle r = \case
      Ask       -> pure r
      Local f m -> toEffWith (handle $ f r) m

Temporarily gain the ability to lift some Eff es actions into Eff esSend. This is useful for dealing with effect operations with the monad type in the negative position, which means it's unlikely that you need to use this function in implementing your effects.