Copyright  (c) Andy Gill 2001 (c) Oregon Graduate Institute of Science and Technology 2001 

License  BSDstyle (see the file libraries/base/LICENSE) 
Maintainer  libraries@haskell.org 
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 generalpurpose instances.
 class Monoid a where
 (<>) :: Monoid m => m > m > m
 newtype Dual a = Dual {
 getDual :: a
 newtype Endo a = Endo {
 appEndo :: a > a
 newtype All = All {}
 newtype Any = Any {}
 newtype Sum a = Sum {
 getSum :: a
 newtype Product a = Product {
 getProduct :: a
 newtype First a = First {}
 newtype Last a = Last {}
 newtype Alt f a = Alt {
 getAlt :: f a
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 =
foldr
mappend mempty
The 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 newtype
s and make those instances
of Monoid
, e.g. Sum
and Product
.
Identity of mappend
mappend :: a > a > a Source #
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.
Monad Dual Source #  
Functor Dual Source #  
MonadFix Dual Source #  
Applicative Dual Source #  
Foldable Dual Source #  
Traversable Dual Source #  
Generic1 Dual Source #  
MonadZip Dual Source #  
Bounded a => Bounded (Dual a) Source #  
Eq a => Eq (Dual a) Source #  
Data a => Data (Dual a) Source #  
Ord a => Ord (Dual a) Source #  
Read a => Read (Dual a) Source #  
Show a => Show (Dual a) Source #  
Generic (Dual a) Source #  
Semigroup a => Semigroup (Dual a) Source #  
Monoid a => Monoid (Dual a) Source #  
type Rep1 Dual Source #  
type Rep (Dual a) Source #  
The monoid of endomorphisms under composition.
Bool
wrappers
Boolean monoid under conjunction (&&
).
Boolean monoid under disjunction (
).
Num
wrappers
Monoid under addition.
Monad Sum Source #  
Functor Sum Source #  
MonadFix Sum Source #  
Applicative Sum Source #  
Foldable Sum Source #  
Traversable Sum Source #  
Generic1 Sum Source #  
MonadZip Sum Source #  
Bounded a => Bounded (Sum a) Source #  
Eq a => Eq (Sum a) Source #  
Data a => Data (Sum a) Source #  
Num a => Num (Sum a) Source #  
Ord a => Ord (Sum a) Source #  
Read a => Read (Sum a) Source #  
Show a => Show (Sum a) Source #  
Generic (Sum a) Source #  
Num a => Semigroup (Sum a) Source #  
Num a => Monoid (Sum a) Source #  
type Rep1 Sum Source #  
type Rep (Sum a) Source #  
Monoid under multiplication.
Product  

Monad Product Source #  
Functor Product Source #  
MonadFix Product Source #  
Applicative Product Source #  
Foldable Product Source #  
Traversable Product Source #  
Generic1 Product Source #  
MonadZip Product Source #  
Bounded a => Bounded (Product a) Source #  
Eq a => Eq (Product a) Source #  
Data a => Data (Product a) Source #  
Num a => Num (Product a) Source #  
Ord a => Ord (Product a) Source #  
Read a => Read (Product a) Source #  
Show a => Show (Product a) Source #  
Generic (Product a) Source #  
Num a => Semigroup (Product a) Source #  
Num a => Monoid (Product a) Source #  
type Rep1 Product Source #  
type Rep (Product a) Source #  
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.
is isomorphic to First
a
, but precedes it
historically.Alt
Maybe
a
Monad First Source #  
Functor First Source #  
MonadFix First Source #  
Applicative First Source #  
Foldable First Source #  
Traversable First Source #  
Generic1 First Source #  
MonadZip First Source #  
Eq a => Eq (First a) Source #  
Data a => Data (First a) Source #  
Ord a => Ord (First a) Source #  
Read a => Read (First a) Source #  
Show a => Show (First a) Source #  
Generic (First a) Source #  
Semigroup (First a) Source #  
Monoid (First a) Source #  
type Rep1 First Source #  
type Rep (First a) Source #  
Maybe monoid returning the rightmost nonNothing value.
is isomorphic to Last
a
, and thus to
Dual
(First
a)Dual
(Alt
Maybe
a)
Monad Last Source #  
Functor Last Source #  
MonadFix Last Source #  
Applicative Last Source #  
Foldable Last Source #  
Traversable Last Source #  
Generic1 Last Source #  
MonadZip Last Source #  
Eq a => Eq (Last a) Source #  
Data a => Data (Last a) Source #  
Ord a => Ord (Last a) Source #  
Read a => Read (Last a) Source #  
Show a => Show (Last a) Source #  
Generic (Last a) Source #  
Semigroup (Last a) Source #  
Monoid (Last a) Source #  
type Rep1 Last Source #  
type Rep (Last a) Source #  
Alternative
wrapper
Monoid under <>
.
Since: 4.8.0.0
Monad f => Monad (Alt * f) Source #  
Functor f => Functor (Alt * f) Source #  
MonadFix f => MonadFix (Alt * f) Source #  
Applicative f => Applicative (Alt * f) Source #  
Generic1 (Alt * f) Source #  
MonadPlus f => MonadPlus (Alt * f) Source #  
Alternative f => Alternative (Alt * f) Source #  
MonadZip f => MonadZip (Alt * f) Source #  
Enum (f a) => Enum (Alt k f a) Source #  
Eq (f a) => Eq (Alt k f a) Source #  
(Data (f a), Data a, Typeable (* > *) f) => Data (Alt * f a) Source #  
Num (f a) => Num (Alt k f a) Source #  
Ord (f a) => Ord (Alt k f a) Source #  
Read (f a) => Read (Alt k f a) Source #  
Show (f a) => Show (Alt k f a) Source #  
Generic (Alt k f a) Source #  
Alternative f => Semigroup (Alt * f a) Source #  
Alternative f => Monoid (Alt * f a) Source #  
type Rep1 (Alt * f) Source #  
type Rep (Alt k f a) Source #  