
Data.Monoid  Portability  portable  Stability  experimental  Maintainer  libraries@haskell.org 





Description 
The Monoid class with various generalpurpose instances.
Inspired by the paper
/Functional Programming with Overloading and
HigherOrder Polymorphism/,
Mark P Jones (http://citeseer.ist.psu.edu/jones95functional.html)
Advanced School of Functional Programming, 1995.


Synopsis 




Monoid typeclass



The monoid class.
A minimal complete definition must supply mempty and mappend,
and these should satisfy the monoid laws.
  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 All  Monoid Any  Monoid Ordering  Monoid ()  (Monoid a, Monoid b) => Monoid (a, b)  (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)  Monoid b => Monoid (a > b)  Monoid a => Monoid (Dual a)  Monoid (Endo a)  Monoid (First a)  Monoid (Last a)  Monoid a => Monoid (Maybe a)  Num a => Monoid (Product a)  Num a => Monoid (Sum a)  Monoid [a] 




The dual of a monoid, obtained by swapping the arguments of mappend.
 Constructors   Instances  



The monoid of endomorphisms under composition.
 Constructors   Instances  


Bool wrappers



Boolean monoid under conjunction.
 Constructors   Instances  



Boolean monoid under disjunction.
 Constructors   Instances  


Num wrappers



Monoid under addition.
 Constructors   Instances  



Monoid under multiplication.
 Constructors   Instances  


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 nonNothing value.
 Constructors   Instances  



Maybe monoid returning the rightmost nonNothing value.
 Constructors   Instances  


Produced by Haddock version 0.9 