Derive necessary instances for an Effect typeclass to work with avail. Specifically, this only works with typeclasses without superclasses; see avail' for a version that takes care of superclasses.

Derive necessary instances for an Effect typeclass to work with avail. This is a generalized version of avail that allows you to pass in a list of superclasses.

For superclasses Sup :: [Effect] and current class Cls :: Effect, the code generated is:

instance IsEff Cls where
  type Superclasses Cls = Sup
deriving newtype instance (Cls m, Eff Cls) => Cls (M m)

Although this is very little code, it is still boilerplate and defining them by hand is error-prone. Therefore, please do not define instances for M by hand (except when doing dirty hacks); use this function instead.

Introduce one type variable a.

Introduce two type variables a, b.

Introduce three type variables a, b, c.

Introduce four type variables a, b, c, d.

Introduce five type variables a, b, c, d, e.

Introduce arbitrarily many type variables a1, a2, a3, ....

Introduce one type variable with given name.

Introduce two type variables with given names.

Introduce three type variables with given names.

Introduce four type variables with given names.

Introduce five type variables with given names.

Introduce arbitrarily many type variables with given names.

The M monad transformer acts as a barrier of effects. For example, for a monad type App and any effect typeclass MonadOvO that App has an instance of, the constraint Eff MonadOvO is required to perform the methods of MonadOvO in the monad M App as defined for the App monad.

In particular, M is expected to be used on a concrete monad instead of a polymorphic one. This is particularly good in terms of program performance, and generally means instead of writing this:

f :: MonadState Int m => m ()

You should write

f :: Eff (MonadState Int) => M App ()

where App is a monad stack of your choice that has support of MonadState Int. This also means there is no MonadTrans instance for M.

Note: you should not define instances of M for effect typeclasses directly by hand as that is error-prone and may create holes in effect management. For defining instances of effect typeclasses for M, check out the Avail.Derive module and specifically the avail and avail' TH functions.

Also keep in mind that typeclasses inside mtl, exceptions, unliftio, monad-control and capability work with M out-of-the-box so no instance for them is needed to be defined on M by you.