**Packages**- is:exact
- is:module
- base
- criterion
- Cabal
- ghc
- hedgehog
- base-compat
- haskell-gi-base
- rio
- classy-prelude
- numeric-prelude
- profunctors
- rerebase
- fgl
- protolude
- base-prelude
- cgi
- genvalidity-hspec
- hosc

The Monad class defines the basic operations over a
*monad*, a concept from a branch of mathematics known as
*category theory*. From the perspective of a Haskell programmer,
however, it is best to think of a monad as an *abstract datatype*
of actions. Haskell's `do` expressions provide a convenient
syntax for writing monadic expressions.
Instances of Monad should satisfy the following:

*Left identity*`return a >>= k = k a`*Right identity*`m >>= return = m`*Associativity*`m >>= (\x -> k x >>= h) = (m >>= k) >>= h`

Cabal Distribution.Compat.Prelude.Internal, ghc GHC.Prelude, hedgehog Hedgehog.Internal.Prelude, base-compat Control.Monad.Compat Control.Monad.Compat, haskell-gi-base Data.GI.Base.ShortPrelude, rio RIO.Prelude.Types, classy-prelude ClassyPrelude, numeric-prelude NumericPrelude NumericPrelude.Base

The Monad class defines the basic operations over a
*monad*, a concept from a branch of mathematics known as
*category theory*. From the perspective of a Haskell programmer,
however, it is best to think of a monad as an *abstract datatype*
of actions. Haskell's `do` expressions provide a convenient
syntax for writing monadic expressions.
Instances of Monad should satisfy the following:

*Left identity*`return a >>= k = k a`*Right identity*`m >>= return = m`*Associativity*`m >>= (\x -> k x >>= h) = (m >>= k) >>= h`

The CompPipeline monad and associated ops
Defined in separate module so that it can safely be imported from
Hooks

Hides away distracting bookkeeping while lambda lifting into a
LiftM monad.

Functions for working with the typechecker environment (setters,
getters...).

Utilities related to Monad and Applicative classes Mostly for
backwards compatibility.

The Monad class defines the basic operations over a
*monad*, a concept from a branch of mathematics known as
*category theory*. From the perspective of a Haskell programmer,
however, it is best to think of a monad as an *abstract datatype*
of actions. Haskell's `do` expressions provide a convenient
syntax for writing monadic expressions.
Instances of Monad should satisfy the following laws:
Furthermore, the Monad and Applicative operations should
relate as follows:
The above laws imply:
and that pure and (<*>) satisfy the applicative
functor laws.
The instances of Monad for lists, Maybe and IO
defined in the Prelude satisfy these laws.

Internal stuff that most people shouldn't have to use. This module
mostly deals with the internals of the CGIT monad transformer.

Monad properties
You will need `TypeApplications` to use these.