Monoid module:Data

A type a is a Monoid if it provides an associative function (<>) that lets you combine any two values of type a into one, and a neutral element (mempty) such that
a <> mempty == mempty <> a == a
A Monoid is a Semigroup with the added requirement of a neutral element. Thus any Monoid is a Semigroup, but not the other way around.

Examples

The Sum monoid is defined by the numerical addition operator and `0` as neutral element:
>>> import Data.Int

>>> mempty :: Sum Int
Sum {getSum = 0}

>>> Sum 1 <> Sum 2 <> Sum 3 <> Sum 4 :: Sum Int
Sum {getSum = 10}
We can combine multiple values in a list into a single value using the mconcat function. Note that we have to specify the type here since Int is a monoid under several different operations:
>>> mconcat [1,2,3,4] :: Sum Int
Sum {getSum = 10}

>>> mconcat [] :: Sum Int
Sum {getSum = 0}
Another valid monoid instance of Int is Product It is defined by multiplication and `1` as neutral element:
>>> Product 1 <> Product 2 <> Product 3 <> Product 4 :: Product Int
Product {getProduct = 24}

>>> mconcat [1,2,3,4] :: Product Int
Product {getProduct = 24}

>>> mconcat [] :: Product Int
Product {getProduct = 1}
The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following: You can alternatively define mconcat instead of mempty, in which case the laws are: 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 newtypes and make those instances of Monoid, e.g. Sum and Product. NOTE: Semigroup is a superclass of Monoid since base-4.11.0.0.
TextShow instances for Monoid-related newtypes. Since: 2
A type a is a Monoid if it provides an associative function (<>) that lets you combine any two values of type a into one, and a neutral element (mempty) such that
a <> mempty == mempty <> a == a
A Monoid is a Semigroup with the added requirement of a neutral element. Thus any Monoid is a Semigroup, but not the other way around.

Examples

The Sum monoid is defined by the numerical addition operator and `0` as neutral element:
>>> import Data.Int (Int)

>>> mempty :: Sum Int
Sum {getSum = 0}

>>> Sum 1 <> Sum 2 <> Sum 3 <> Sum 4 :: Sum Int
Sum {getSum = 10}
We can combine multiple values in a list into a single value using the mconcat function. Note that we have to specify the type here since Int is a monoid under several different operations:
>>> mconcat [1,2,3,4] :: Sum Int
Sum {getSum = 10}

>>> mconcat [] :: Sum Int
Sum {getSum = 0}
Another valid monoid instance of Int is Product It is defined by multiplication and `1` as neutral element:
>>> Product 1 <> Product 2 <> Product 3 <> Product 4 :: Product Int
Product {getProduct = 24}

>>> mconcat [1,2,3,4] :: Product Int
Product {getProduct = 24}

>>> mconcat [] :: Product Int
Product {getProduct = 1}
Bidirectional transforms for Data.Monoid.
Eliminator functions for data types in Data.Monoid. All of these are re-exported from Data.Eliminator with the following exceptions:
Extension of Monoid that allows testing a value for equality with mempty. The following law must hold:
null x == (x == mempty)
Furthermore, the performance of this method should be constant, i.e., independent of the length of its argument.
For base < 4.11, the Monoid' constraint is a synonym for things which are instances of both Semigroup and Monoid. For base version 4.11 and onwards, Monoid has Semigroup as a superclass already, so for backwards compatibility Monoid' is provided as a synonym for Monoid.
This module provides a HashMap variant which uses the value's Monoid instance to accumulate conflicting entries when merging Maps. While some functions mirroring those of HashMap are provided here for convenience, more specialized needs will likely want to use either the Newtype or Wrapped instances to manipulate the underlying Map.
A HashMap with monoidal accumulation
This module provides a IntMap variant which uses the value's Monoid instance to accumulate conflicting entries when merging Maps. While some functions mirroring those of IntMap are provided here for convenience, more specialized needs will likely want to use either the Newtype or Wrapped instances to manipulate the underlying Map.
An IntMap with monoidal accumulation
This module provides a Map variant which uses the value's Monoid instance to accumulate conflicting entries when merging Maps. While some functions mirroring those of Map are provided here for convenience, more specialized needs will likely want to use either the Newtype or Wrapped instances to manipulate the underlying Map.
A Map with monoidal accumulation