| Safe Haskell | Safe |
|---|---|
| Language | Haskell98 |
Control.Monad.Compat
- class Applicative m => Monad m where
- class (Alternative m, Monad m) => MonadPlus m where
Documentation
class Applicative m => Monad m where #
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.
Minimal complete definition
Methods
(>>=) :: m a -> (a -> m b) -> m b infixl 1 #
Sequentially compose two actions, passing any value produced by the first as an argument to the second.
(>>) :: m a -> m b -> m b infixl 1 #
Sequentially compose two actions, discarding any value produced by the first, like sequencing operators (such as the semicolon) in imperative languages.
Inject a value into the monadic type.
Fail with a message. This operation is not part of the
mathematical definition of a monad, but is invoked on pattern-match
failure in a do expression.
As part of the MonadFail proposal (MFP), this function is moved
to its own class MonadFail (see Control.Monad.Fail for more
details). The definition here will be removed in a future
release.
Instances
| Monad [] | |
| Monad Maybe | |
| Monad IO | |
| Monad U1 | |
| Monad Par1 | |
| Monad P | |
| Monad Complex | |
| Monad STM | |
| Monad Dual | |
| Monad Sum | |
| Monad Product | |
| Monad First | |
| Monad Last | |
| Monad ReadPrec | |
| Monad ReadP | |
| Monad ((->) r) | |
| Monad (Either e) | |
| Monad f => Monad (Rec1 f) | |
| Monoid a => Monad ((,) a) | |
| Monad (ST s) | |
| Monad (ST s) | |
| Monad m => Monad (WrappedMonad m) | |
| Monad (Proxy *) | |
| (Monad f, Monad g) => Monad ((:*:) f g) | |
| Monad f => Monad (Alt * f) | |
| Monad f => Monad (M1 i c f) | |
class (Alternative m, Monad m) => MonadPlus m where #
Monads that also support choice and failure.
Methods
the identity of mplus. It should also satisfy the equations
mzero >>= f = mzero v >> mzero = mzero
an associative operation
Instances