The effect for lifting and unlifting the IO monad, allowing you to use MonadIO, MonadUnliftIO, PrimMonad, MonadCatch, MonadThrow and MonadMask functionalities. This is the "final" effect that most effects eventually are interpreted into. For example, you can do:

log :: IOE :> es => Eff es ()
log = liftIO (putStrLn "Test logging")

It is not recommended to use this effect in application code, as it is too liberal and allows arbitrary IO. Ideally, this is only used in interpreting more fine-grained effects.

Note that this is not a real effect and cannot be interpreted in any way besides thisIsPureTrustMe and runIOE. It is similar to Polysemy's Final effect which also cannot be interpreted. This is mainly for performance concern, but also that there doesn't really exist reasonable interpretations other than the current one, given the underlying implementation of the Eff monad.

IOE can be a real effect though, and you can enable the dynamic-ioe build flag to have that. However it is only for reference purposes and should not be used in production code.

Lift an IO computation into Eff. This function is highly unsafe and should not be used directly; use liftIO instead, or if you're interpreting higher-order effects, use fromIO.

Give a runner function a way to run Eff actions as an IO computation. This function is highly unsafe and should not be used directly; use withRunInIO instead, or if you're interpreting higher-order effects, use withToIO.

Unsafely eliminate an IOE effect from the top of the effect stack. This is mainly for implementing effects that uses IO but does not do anything really impure (i.e. can be safely used unsafeDupablePerformIO on), such as a State effect.

Unwrap an Eff computation with side effects into an IO computation, given that all effects other than IOE are interpreted.

Unwrap a pure Eff computation into a pure value, given that all effects are interpreted.

The type of an IO effect handler, which is a function that transforms an effect e into IO computations. This is used for interpretIO.

Interpret an effect in terms of IO, by transforming an effect into IO computations.

interpretIO f = interpret (liftIO . f)

Temporarily gain the ability to unlift an Eff esSend computation into IO. This is useful for dealing with higher-order effects that involves IO.

Lift an IO computation into Eff esSend. This is useful for dealing with effect operations with the monad type in the negative position within IOE, like masking.