In a previous post I discussed the basics of the Semigroup typeclass in Haskell, being an abstraction of a common algebraic structure. In this post I will discuss the basics of the ** monoid** data structure, as implemented in Haskell via the typeclass

*Monoid*.

### The connection between Semigroup and Monoid

Semigroup and Monoid are very closely connected concepts. Both represent algebraic structures consisting of a set of elements and a binary, associative operation. Monoids extend this algebraic structure with the addition of an **identity element**. Let's represent this algebraic structure like so:

```
(S, *, 0)
```

Here, *S* is the set of elements, *** is the associative, binary operation and *0* is the identity element. I'm using *** and *0* to represent the binary operation and the identity element in general, as opposed to multiplication and zero, following a convention from the book ** An Introduction to Category Theory** by Harold Simmons (Which I strongly recommend). The laws that a monoid

**must**obey are:

```
-- Identity
a1 * 0 = a1
0 * a1 = a1
-- Associativity
(a1 * a2) * a3 = a1 * (a2 * a3)
```

Given that a monoid is just a semigroup with an identitive element, any valid semigroup can be a monoid so long as such an identitive element is defined for it. Indeed, if we look at how Haskell defines the Monoid typeclass:

```
GHCi> :i Monoid
class Semigroup a => Monoid a where
mempty :: a
mappend :: a -> a -> a
mconcat :: [a] -> a
{-# MINIMAL mempty #-}
```

The *{-# MINIMAL mempty #-}* tells us that all we need to define a valid instance of the typeclass Monoid for a type *a* is to define *mempty*. This is because, given that *a* is a valid instance of Semigroup, it already has the necessary binary-associative operation.

To get the *mempty* of a certain type, you need to explicitly give *mempty* a type, like so:

```
GHCi> mempty :: String
""
GHCi> mempty :: Maybe String
Nothing
```

### Data.Monoid

Haskell comes with the 'Data.Monoid' package. This is loaded with a bunch of useful extras to enhance your usage of Monoids in Haskell.

For example, in my post on Semigroups, I implemented the *Sum* and *Product* types to wrap around numerical types to implement specific semigroups. These types were not an original creation by me (I used them to explain a specific concept), and are actually pulled from *Data.Monoid*!

```
GHCi> import Data.Monoid
GHCi> Sum 5 <> Sum 4
Sum {getSum = 9}
GHCi> mappend (Sum 3) (Sum 10)
Sum {getSum = 13}
GHCi> mconcat [(Product 2), (Product 4), (Product 6)]
Product {getProduct = 48}
```

Think of boolean values now. Like numbers, there's two semigroups that can be defined for them. *Data.Monoid* deals with this by providing for you the wrapper types of *Any* and *All*.

```
GHCi> Any True <> Any False
Any {getAny = True}
GHCi> mappend (All True) (All False)
All {getAll = False}
GHCi> mconcat $ map All [True, True, True, False, True]
All {getAll = False}
```

You can also use these types with *mempty*. See how they differ, despite nominally being wrappers over the same type:

```
GHCi> mempty :: All
All {getAll = True}
GHCi> mempty :: Any
Any {getAny = False}
GHCi> mempty :: Sum Int
Sum {getSum = 0}
GHCi> mempty :: Product Int
Product {getProduct = 1}
```

### A Weird Interlude

There's a couple of weird types defined in *Data.Monoid*. The first is called *Dual*. Here's what it does:

```
GHCi> mappend (Dual [1, 2, 3]) (Dual [4, 5, 6])
Dual {getDual = [4,5,6,1,2,3]}
GHCi> getDual $ mappend (Dual [1, 2, 3]) (Dual [4, 5, 6])
[4, 5, 6, 1, 2, 3]
```

The docs give a rather brief description:

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

There's also *Endo*. Here's a quick example of its usage:

```
GHCi> let thing = Endo ([1, 2, 3] ++) <> Endo (++ [4, 5, 6])
GHCi> appEndo thing [101, 102, 103]
[1,2,3,101,102,103,4,5,6]
```

The monoid of endomorphisms under composition.

If you're anything like me then the first time you read that definition, your mind was probably quite blank, before slowly reading through each of the words again, looking back at the example, back to the definition, before finally having that little lightbulb moment.

💡

###
Dealing with *Maybe*

*Data.Monoid* also includes two very nice wrappers for dealing with *Maybe* values. A type of *Maybe a* has an instance of Monoid providing that *a* has an instance of Monoid. For example:

```
GHCi> mappend (Just "Hello") (Just "World")
Just "HelloWorld"
GHCi> mappend (Just $ Sum 3) (Just $ Sum 7)
Just (Sum {getSum = 10})
```

The new types we get for dealing with *Maybe* are *First* and *Last*. Like their names suggest, they allow you to retrieve the first or the last *Just* values from a sequence of *Maybe*. Like so:

```
GHCi> First (Just "Merhaba") <> First Nothing <> First (Just "Dunya")
First {getFirst = Just "Merhaba"}
GHCi> getFirst $ First (Just "Merhaba") <> First Nothing <> First
(Just "Dunya")
Just "Merhaba"
```

And the same with *Last*:

```
GHCi> Last (Just "Merhaba") <> Last Nothing <> Last (Just "Dunya")
Last {getLast = Just "Dunya"}
GHCi> getLast $ Last (Just "Merhaba") <> Last Nothing <> Last (Just
"Dunya")
Just "Dunya"
```

*Data.Monoid* includes a few more gifts, but these also involve other other core Haskell typeclasses, and I would prefer to go over them in their own post, just for them.

### Monoidal Functions (Assuming 'monoidal' is even a word)

One often overlooked instance of *Monoid* is defined for functions of type

*(a -> b)*, where *b* itself has an instance of *Monoid* defined.

```
GHCi> :i Monoid
...
instance Monoid b => Monoid (a -> b)
...
```

An example of using this instance of *Monoid* can actually be seen in my other post here, about "Monoidal FizzBuzz".

### Key takeaways

- A monoid is an algebraic structure consisting of a set of elements, an associative-binary operation, and an identity element.
- A monoid is just a semigroup with the addition of an identitive element.
- The minimal definition for an instance of monoid for a type
*a*is simply*mempty*, as something must implement the semigroup typeclass before an instance of monoid can be defined. -
*Data.Monoid*includes some useful wrappers for working with certain types that can have multiple valid monoids.

## Discussion

Shouldn't 1 be the identity element for multiplication?

`a1 * 0 != a1`

For multiplication, 1 is indeed the identitive element. Here, * represents a generic associative-binary operation, and 0 represents a generic identitive element. I should have made this more clear in the post, I apologize.