| Copyright | (c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001 |
|---|---|
| License | BSD-style (see the file libraries/base/LICENSE) |
| Maintainer | [email protected] |
| Stability | experimental |
| Portability | portable |
| Safe Haskell | Trustworthy |
| Language | Haskell2010 |
A class for monoids (types with an associative binary operation that has an identity) with various general-purpose instances.
The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following laws:
mappend mempty x = x
mappend x mempty = x
mappend x (mappend y z) = mappend (mappend x y) z
mconcat = foldr mappend memptyThe method names refer to the monoid of lists under concatenation, but there are many other instances.
Some types can be viewed as a monoid in more than one way, e.g. both addition and multiplication on numbers. In such cases we often define newtypes and make those instances of Monoid, e.g. Sum and Product.
Identity of mappend
An associative operation
Fold a list using the monoid. For most types, the default definition for mconcat will be used, but the function is included in the class definition so that an optimized version can be provided for specific types.
| Monoid Ordering | |
| Monoid () | |
| Monoid Any | |
| Monoid All | |
| Monoid Lifetime |
|
| Monoid Event | |
| Monoid [a] | |
| Monoid a => Monoid (Maybe a) | Lift a semigroup into |
| Monoid a => Monoid (IO a) | |
| Monoid (Last a) | |
| Monoid (First a) | |
| Num a => Monoid (Product a) | |
| Num a => Monoid (Sum a) | |
| Monoid (Endo a) | |
| Monoid a => Monoid (Dual a) | |
| Semigroup a => Monoid (Option a) | |
| Monoid m => Monoid (WrappedMonoid m) | |
| (Ord a, Bounded a) => Monoid (Max a) | |
| (Ord a, Bounded a) => Monoid (Min a) | |
| Monoid a => Monoid (Identity a) | |
| Monoid b => Monoid (a -> b) | |
| (Monoid a, Monoid b) => Monoid (a, b) | |
| Monoid (Proxy k s) | |
| (Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) | |
| Alternative f => Monoid (Alt * f a) | |
| Monoid a => Monoid (Const k a b) | |
| (Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d) | |
| (Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e) | |
(<>) :: Monoid m => m -> m -> m infixr 6 Source
An infix synonym for mappend.
Since: 4.5.0.0
The dual of a Monoid, obtained by swapping the arguments of mappend.
| Monad Dual | |
| Functor Dual | |
| MonadFix Dual | |
| Applicative Dual | |
| Foldable Dual | |
| Traversable Dual | |
| Generic1 Dual | |
| MonadZip Dual | |
| Bounded a => Bounded (Dual a) | |
| Eq a => Eq (Dual a) | |
| Data a => Data (Dual a) | |
| Ord a => Ord (Dual a) | |
| Read a => Read (Dual a) | |
| Show a => Show (Dual a) | |
| Generic (Dual a) | |
| Semigroup a => Semigroup (Dual a) | |
| Monoid a => Monoid (Dual a) | |
| type Rep1 Dual | |
| type Rep (Dual a) | |
The monoid of endomorphisms under composition.
Boolean monoid under conjunction (&&).
Boolean monoid under disjunction (||).
Monoid under addition.
| Monad Sum | |
| Functor Sum | |
| MonadFix Sum | |
| Applicative Sum | |
| Foldable Sum | |
| Traversable Sum | |
| Generic1 Sum | |
| MonadZip Sum | |
| Bounded a => Bounded (Sum a) | |
| Eq a => Eq (Sum a) | |
| Data a => Data (Sum a) | |
| Num a => Num (Sum a) | |
| Ord a => Ord (Sum a) | |
| Read a => Read (Sum a) | |
| Show a => Show (Sum a) | |
| Generic (Sum a) | |
| Num a => Semigroup (Sum a) | |
| Num a => Monoid (Sum a) | |
| type Rep1 Sum | |
| type Rep (Sum a) | |
Monoid under multiplication.
| Product | |
Fields
| |
| Monad Product | |
| Functor Product | |
| MonadFix Product | |
| Applicative Product | |
| Foldable Product | |
| Traversable Product | |
| Generic1 Product | |
| MonadZip Product | |
| Bounded a => Bounded (Product a) | |
| Eq a => Eq (Product a) | |
| Data a => Data (Product a) | |
| Num a => Num (Product a) | |
| Ord a => Ord (Product a) | |
| Read a => Read (Product a) | |
| Show a => Show (Product a) | |
| Generic (Product a) | |
| Num a => Semigroup (Product a) | |
| Num a => Monoid (Product a) | |
| type Rep1 Product | |
| type Rep (Product a) | |
To implement find or findLast on any Foldable:
findLast :: Foldable t => (a -> Bool) -> t a -> Maybe a
findLast pred = getLast . foldMap (x -> if pred x
then Last (Just x)
else Last Nothing)
Much of Data.Map's interface can be implemented with Data.Map.alter. Some of the rest can be implemented with a new alterA function and either First or Last:
alterA :: (Applicative f, Ord k) =>
(Maybe a -> f (Maybe a)) -> k -> Map k a -> f (Map k a)
instance Monoid a => Applicative ((,) a) -- from Control.Applicative
insertLookupWithKey :: Ord k => (k -> v -> v -> v) -> k -> v
-> Map k v -> (Maybe v, Map k v)
insertLookupWithKey combine key value =
Arrow.first getFirst . alterA doChange key
where
doChange Nothing = (First Nothing, Just value)
doChange (Just oldValue) =
(First (Just oldValue),
Just (combine key value oldValue))
Maybe monoid returning the leftmost non-Nothing value.
First a is isomorphic to Alt Maybe a, but precedes it historically.
| Monad First | |
| Functor First | |
| MonadFix First | |
| Applicative First | |
| Foldable First | |
| Traversable First | |
| Generic1 First | |
| MonadZip First | |
| Eq a => Eq (First a) | |
| Data a => Data (First a) | |
| Ord a => Ord (First a) | |
| Read a => Read (First a) | |
| Show a => Show (First a) | |
| Generic (First a) | |
| Semigroup (First a) | |
| Monoid (First a) | |
| type Rep1 First | |
| type Rep (First a) | |
Maybe monoid returning the rightmost non-Nothing value.
Last a is isomorphic to Dual (First a), and thus to Dual (Alt Maybe a)
| Monad Last | |
| Functor Last | |
| MonadFix Last | |
| Applicative Last | |
| Foldable Last | |
| Traversable Last | |
| Generic1 Last | |
| MonadZip Last | |
| Eq a => Eq (Last a) | |
| Data a => Data (Last a) | |
| Ord a => Ord (Last a) | |
| Read a => Read (Last a) | |
| Show a => Show (Last a) | |
| Generic (Last a) | |
| Semigroup (Last a) | |
| Monoid (Last a) | |
| type Rep1 Last | |
| type Rep (Last a) | |
Monoid under <|>.
Since: 4.8.0.0
| Monad f => Monad (Alt * f) | |
| Functor f => Functor (Alt * f) | |
| MonadFix f => MonadFix (Alt * f) | |
| Applicative f => Applicative (Alt * f) | |
| Generic1 (Alt * f) | |
| MonadPlus f => MonadPlus (Alt * f) | |
| Alternative f => Alternative (Alt * f) | |
| MonadZip f => MonadZip (Alt * f) | |
| Enum (f a) => Enum (Alt k f a) | |
| Eq (f a) => Eq (Alt k f a) | |
| (Data (f a), Data a, Typeable (* -> *) f) => Data (Alt * f a) | |
| Num (f a) => Num (Alt k f a) | |
| Ord (f a) => Ord (Alt k f a) | |
| Read (f a) => Read (Alt k f a) | |
| Show (f a) => Show (Alt k f a) | |
| Generic (Alt k f a) | |
| Alternative f => Semigroup (Alt * f a) | |
| Alternative f => Monoid (Alt * f a) | |
| type Rep1 (Alt * f) | |
| type Rep (Alt k f a) | |
© The University of Glasgow and others
Licensed under a BSD-style license (see top of the page).
https://downloads.haskell.org/~ghc/8.0.1/docs/html/libraries/base-4.9.0.0/Data-Monoid.html