Documentation

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.

The kind of effect typeclasses, i.e. those that define a set of operations on a monad. Examples include MonadIO and MonadReader.

This type is the same as the Capability type in capability.

Any Effect being used with avail should have an instance of this class. Specifically, this class stores the superclasses of effect typeclasses. For example, MonadUnliftIO has a superclass MonadIO.

You won't need to define instances of this by hand; instead, use the avail' Template Haskell function.

The primitive phantom effect constraint that does not take superclasses into account. You should not use this directly; use Eff or Effs instead. Additionally, you definitely shouldn't define instances for this class.

The constraint that indicates an effect is available for use, i.e. you can perform methods defined by instances of the effect typeclass e in a M monad.

Convenient alias for (Eff e1, Eff e2, ..., Eff en).

The newtype wrapper used to circumvent the impredicative problem of GHC and perform the reflection trick in rip'. You have no reason to use this directly.

Brutally rip off an Eff' constraint, a la the reflection trick. This is highly unsafe in terms of effect management.

Brutally rip off an Eff constraint. This means rip'ing off the Eff' constraint of the current Effect and then rips off constraints of all Superclasses recursively. This is highly unsafe in terms of effect management.

The list of effect typeclasses es is known at compile time. This is required for functions like runM.

Unwrap the M monad into the underlying concrete monad. This is rarely needed as most of the time you would also want to eliminate Eff constraints at the same time; for that see runM.

Unwrap the M monad into the underlying concrete monad and also eliminating Eff constraints. You need TypeApplications in order to specify the list of Effects you want to eliminate Eff constraints for:

runM @'[MonadReader Env, MonadState Store, MonadError MyErr] app

Note that functions like (&) generally does not work with this function; either apply directly or use ($) only.