| Safe Haskell | Safe |
|---|---|
| Language | Haskell2010 |
Precursor.Control.Monad
Contents
- class Applicative m => Monad m where
- (>>=) :: Monad m => forall a b. m a -> (a -> m b) -> m b
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- join :: Monad m => m (m a) -> m a
- foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
- foldlM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
- foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
- foldrM_ :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m ()
- (<$!>) :: Monad m => (a -> b) -> m a -> m b
- (>>) :: Monad m => forall a b. m a -> m b -> m b
- fail :: Monad m => forall a. String -> m a
- return :: Monad m => forall a. a -> m a
Monad class
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 Q | |
| Monad Identity | |
| Monad Min | |
| Monad Max | |
| Monad First | |
| Monad Last | |
| Monad Option | |
| Monad NonEmpty | |
| Monad Complex | |
| Monad Dual | |
| Monad Sum | |
| Monad Product | |
| Monad First | |
| Monad Last | |
| Monad Seq | |
| Monad Product # | |
| Monad Sum # | |
| Monad ((->) r) | |
| Monad (Either e) | |
| Monad f => Monad (Rec1 f) | |
| Monoid a => Monad ((,) a) | |
| Monad m => Monad (WrappedMonad m) | |
| ArrowApply a => Monad (ArrowMonad a) | |
| Monad (Proxy *) | |
| Monad (State s) | |
| (Monad f, Monad g) => Monad ((:*:) f g) | |
| Monad f => Monad (Alt * f) | |
| (Monad m, Error e) => Monad (ErrorT e m) | |
| Monad m => Monad (StateT s m) | |
| Monad (Tagged k s) | |
| Monad f => Monad (M1 i c f) | |
| (Monad f, Monad g) => Monad (Product * f g) | |
Functions
Naming conventions
The functions in this library use the following naming conventions:
- A postfix '
M' always stands for a function in the Kleisli category: The monad type constructormis added to function results (modulo currying) and nowhere else. So, for example,
filter :: (a -> Bool) -> [a] -> [a] filterM :: (Monad m) => (a -> m Bool) -> [a] -> m [a]
- A postfix '
_' changes the result type from(m a)to(m ()). Thus, for example:
sequence :: Monad m => [m a] -> m [a] sequence_ :: Monad m => [m a] -> m ()
- A prefix '
m' generalizes an existing function to a monadic form. Thus, for example:
sum :: Num a => [a] -> a msum :: MonadPlus m => [m a] -> m a
Basic Monad functions
(>>=) :: Monad m => forall a b. m a -> (a -> m b) -> m b #
Sequentially compose two actions, passing any value produced by the first as an argument to the second.
(=<<) :: Monad m => (a -> m b) -> m a -> m b infixr 1 #
Same as >>=, but with the arguments interchanged.
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c infixr 1 #
Left-to-right Kleisli composition of monads.
join :: Monad m => m (m a) -> m a #
The join function is the conventional monad join operator. It
is used to remove one level of monadic structure, projecting its
bound argument into the outer level.
Generalisations of list functions
foldlM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m () Source #
Like foldlM, but discards the result.
foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b #
Monadic fold over the elements of a structure, associating to the right, i.e. from right to left.
foldrM_ :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m () Source #
Like foldrM, but discards the result.
Strict monadic functions
Avoid
(>>) :: Monad m => forall a b. m a -> m b -> m b #
Sequentially compose two actions, discarding any value produced by the first, like sequencing operators (such as the semicolon) in imperative languages.
fail :: Monad m => forall a. String -> m a #
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.