Safe Haskell | Safe |
---|---|
Language | Haskell2010 |
Specialised functions for folds of function applications. The converter has been specialised to the identity converter.
- type FoldlApp p r f = FoldlApp (~) p r f
- type FoldrApp p r f = FoldrApp (~) p r f
- foldlApp :: forall p r f. FoldlApp p r f => (r -> p -> r) -> r -> f
- foldlMApp :: forall m p r f. (Monad m, FoldlApp p (m r) f) => (r -> p -> m r) -> r -> f
- foldrApp :: forall p r f. FoldrApp p r f => (p -> r -> r) -> r -> f
- foldrMApp :: forall m p r f. (Monad m, FoldrApp p (m r) f) => (p -> r -> m r) -> r -> f
- class Applicative m => Monad m
Documentation
type FoldlApp p r f = FoldlApp (~) p r f Source #
Data.FoldApp.FoldlApp
with the identity converter chosen.
type FoldrApp p r f = FoldrApp (~) p r f Source #
Data.FoldApp.FoldrAPp
with the identity converter chosen.
foldlApp :: forall p r f. FoldlApp p r f => (r -> p -> r) -> r -> f Source #
Left-associative fold of function applications.
foldlMApp :: forall m p r f. (Monad m, FoldlApp p (m r) f) => (r -> p -> m r) -> r -> f Source #
Monadic left-associative fold of function applications.
foldrApp :: forall p r f. FoldrApp p r f => (p -> r -> r) -> r -> f Source #
Right-associative fold of function applications.
foldrMApp :: forall m p r f. (Monad m, FoldrApp p (m r) f) => (p -> r -> m r) -> r -> f Source #
Monadic right-associative fold of function applications.
class Applicative m => Monad m #
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.
Monad [] | |
Monad Maybe | |
Monad IO | |
Monad U1 | |
Monad Par1 | |
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 ((->) r) | |
Monad (Either e) | |
Monad f => Monad (Rec1 f) | |
Monoid a => Monad ((,) a) | |
Monad m => Monad (WrappedMonad m) | |
Monad (Proxy *) | |
Monad (State s) | |
(Monad f, Monad g) => Monad ((:*:) f g) | |
Monad f => Monad (Alt * f) | |
Monad f => Monad (M1 i c f) | |