base-4.6.0.1: Basic libraries

Portability | portable
Stability | experimental
Maintainer | libraries@haskell.org
Safe Haskell | Trustworthy

Data.Monoid

Contents

- Monoid typeclass
- Bool wrappers
- Num wrappers
- Maybe wrappers

Description

A class for monoids (types with an associative binary operation that has an identity) with various general-purpose instances.

Synopsis

- class Monoid a where
  - mempty :: a
  - mappend :: a -> a -> a
  - mconcat :: [a] -> a
- (<>) :: Monoid m => m -> m -> m
- newtype Dual a = Dual {
  - getDual :: a
  }
- newtype Endo a = Endo {
  - appEndo :: a -> a
  }
- newtype All = All {
  - getAll :: Bool
  }
- newtype Any = Any {
  - getAny :: Bool
  }
- newtype Sum a = Sum {
  - getSum :: a
  }
- newtype Product a = Product {
  - getProduct :: a
  }
- newtype First a = First {
  - getFirst :: Maybe a
  }
- newtype Last a = Last {
  - getLast :: Maybe a
  }

# Monoid typeclass

class Monoid a where

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.

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 `newtype`s and make those instances of `Monoid`, e.g. `Sum` and `Product`.

Methods

mempty :: a

Identity of `mappend`

mappend :: a -> a -> a

An associative operation

mconcat :: [a] -> a

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 `Maybe` forming a `Monoid` according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup `S` may be turned into a monoid simply by adjoining an element `e` not in `S` and defining `e*e = e` and `e*s = s = s*e` for all `s ∈ S`." Since there is no "Semigroup" typeclass providing just `mappend`, we use `Monoid` instead.
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 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 m => m -> m -> m

An infix synonym for `mappend`.

newtype Dual a

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

Constructors

Dual |
Fields getDual :: a

Instances

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) |
Monoid a => Monoid (Dual a) |

newtype Endo a

The monoid of endomorphisms under composition.

Constructors

Endo |
Fields appEndo :: a -> a

Instances

Monoid (Endo a) |

# Bool wrappers

newtype All

Boolean monoid under conjunction.

Constructors

All |
Fields getAll :: Bool

Instances

Bounded All |
Eq All |
Ord All |
Read All |
Show All |
Monoid All |

newtype Any

Boolean monoid under disjunction.

Constructors

Any |
Fields getAny :: Bool

Instances

Bounded Any |
Eq Any |
Ord Any |
Read Any |
Show Any |
Monoid Any |

# Num wrappers

newtype Sum a

Monoid under addition.

Constructors

Sum |
Fields getSum :: a

Instances

Bounded a => Bounded (Sum a) |
Eq a => Eq (Sum a) |
Ord a => Ord (Sum a) |
Read a => Read (Sum a) |
Show a => Show (Sum a) |
Num a => Monoid (Sum a) |

newtype Product a

Monoid under multiplication.

Constructors

Product |
Fields getProduct :: a

Instances

Bounded a => Bounded (Product a) |
Eq a => Eq (Product a) |
Ord a => Ord (Product a) |
Read a => Read (Product a) |
Show a => Show (Product a) |
Num a => Monoid (Product 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))

newtype First a

Maybe monoid returning the leftmost non-Nothing value.

Constructors

First |
Fields getFirst :: Maybe a

Instances

Eq a => Eq (First a) |
Ord a => Ord (First a) |
Read a => Read (First a) |
Show a => Show (First a) |
Monoid (First a) |

newtype Last a

Maybe monoid returning the rightmost non-Nothing value.

Constructors

Last |
Fields getLast :: Maybe a

Instances

Eq a => Eq (Last a) |
Ord a => Ord (Last a) |
Read a => Read (Last a) |
Show a => Show (Last a) |
Monoid (Last a) |