| Portability | portable |
|---|---|
| Stability | provisional |
| Maintainer | libraries@haskell.org |
Control.Monad.Instances
Documentation
The Functor class is used for types that can be mapped over.
Instances of Functor should satisfy the following laws:
fmap id == id fmap (f . g) == fmap f . fmap g
The instances of Functor for lists, Data.Maybe.Maybe and System.IO.IO
satisfy these laws.
Instances
| Functor [] | |
| Functor IO | |
| Functor Maybe | |
| Functor ReadP | |
| Functor ReadPrec | |
| Functor STM | |
| Functor ZipList | |
| Functor Id | |
| Functor ((->) r) | |
| Functor (Either a) | |
| Functor ((,) a) | |
| Functor (ST s) | |
| Ix i => Functor (Array i) | |
| Functor (ST s) | |
| Monad m => Functor (WrappedMonad m) | |
| Functor (Const m) | |
| Functor (StateR s) | |
| Functor (StateL s) | |
| Arrow a => Functor (WrappedArrow a b) |
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.
Minimal complete definition: >>= and return.
Instances of Monad should satisfy the following laws:
return a >>= k == k a m >>= return == m m >>= (\x -> k x >>= h) == (m >>= k) >>= h
Instances of both Monad and Functor should additionally satisfy the law:
fmap f xs == xs >>= return . f
The instances of Monad for lists, Data.Maybe.Maybe and System.IO.IO
defined in the Prelude satisfy these laws.
Methods
(>>=) :: forall a b. m a -> (a -> m b) -> m bSource
Sequentially compose two actions, passing any value produced by the first as an argument to the second.
(>>) :: forall a b. m a -> m b -> m bSource
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.