| Copyright | (c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001 |
|---|---|
| License | BSD-style (see the file libraries/base/LICENSE) |
| Maintainer | libraries@haskell.org |
| Stability | experimental |
| Portability | portable |
| Safe Haskell | Trustworthy |
| Language | Haskell2010 |
Data.Monoid
Description
A class for monoids (types with an associative binary operation that has an identity) with various general-purpose instances.
Monoid typeclass
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 =
foldrmappend mempty
The method names refer to the monoid of lists under concatenation, but there are many other instances.
Minimal complete definition: mempty and mappend.
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.
Methods
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.
Instances
| Monoid Ordering | |
| Monoid () | |
| Monoid Any | |
| Monoid All | |
| Monoid Event | |
| Monoid [a] | |
| Monoid a => Monoid (Maybe a) | Lift a semigroup into |
| Monoid (Last a) | |
| Monoid (First a) | |
| Num a => Monoid (Product a) | |
| Num a => Monoid (Sum a) | |
| Monoid (Endo a) | |
| Monoid a => Monoid (Dual a) | |
| Monoid b => Monoid (a -> b) | |
| (Monoid a, Monoid b) => Monoid (a, b) | |
| Monoid (Proxy * s) | |
| Monoid a => Monoid (Const a b) | |
| Typeable (* -> Constraint) Monoid | |
| (Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) | |
| (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) |
The dual of a monoid, obtained by swapping the arguments of mappend.
Instances
| Generic1 Dual | |
| Bounded a => Bounded (Dual a) | |
| Eq a => Eq (Dual a) | |
| Ord a => Ord (Dual a) | |
| Read a => Read (Dual a) | |
| Show a => Show (Dual a) | |
| Generic (Dual a) | |
| Monoid a => Monoid (Dual a) | |
| type Rep1 Dual = D1 D1Dual (C1 C1_0Dual (S1 S1_0_0Dual Par1)) | |
| type Rep (Dual a) = D1 D1Dual (C1 C1_0Dual (S1 S1_0_0Dual (Rec0 a))) |
The monoid of endomorphisms under composition.
Bool wrappers
Boolean monoid under conjunction.
Boolean monoid under disjunction.
Num wrappers
Monoid under addition.
Instances
| Generic1 Sum | |
| Bounded a => Bounded (Sum a) | |
| Eq a => Eq (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 => Monoid (Sum a) | |
| type Rep1 Sum = D1 D1Sum (C1 C1_0Sum (S1 S1_0_0Sum Par1)) | |
| type Rep (Sum a) = D1 D1Sum (C1 C1_0Sum (S1 S1_0_0Sum (Rec0 a))) |
Monoid under multiplication.
Constructors
| Product | |
Fields
| |
Instances
| Generic1 Product | |
| Bounded a => Bounded (Product a) | |
| Eq a => Eq (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 => Monoid (Product a) | |
| type Rep1 Product = D1 D1Product (C1 C1_0Product (S1 S1_0_0Product Par1)) | |
| type Rep (Product a) = D1 D1Product (C1 C1_0Product (S1 S1_0_0Product (Rec0 a))) |
Maybe wrappers
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.
Instances
Maybe monoid returning the rightmost non-Nothing value.