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:
Furthermore, the Monad and Applicative operations should relate as follows:
• `pure = return`
• ```m1 <*> m2 = m1 >>= (x1 -> m2
>>= (x2 -> return (x1 x2)))```
The above laws imply:
• ```fmap f xs = xs >>= return .
f```
• `(>>) = (*>)`
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.
The environment in which most criterion code executes.
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:
Furthermore, the Monad and Applicative operations should relate as follows:
• `pure = return`
• ```m1 <*> m2 = m1 >>= (x1 -> m2
>>= (x2 -> return (x1 x2)))```
The above laws imply:
• ```fmap f xs = xs >>= return .
f```
• `(>>) = (*>)`
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.
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.
Type definitions for the constraint solver
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:
• `return a >>= k = k a`
• `m >>= return = m`
• ```m >>= (\x -> k x >>= h) = (m
>>= k) >>= h```
Furthermore, the Monad and Applicative operations should relate as follows:
• `pure = return`
• `(<*>) = ap`
The above laws imply:
• ```fmap f xs = xs >>= return .
f```
• `(>>) = (*>)`
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.
Monad class implementing an Open Sound Control transport.