Sometime ago I started to code using the functional paradigm in **Node.js** and **Elixir**.

When you try to make the switch from a *non-pure* functional language to a *pure* one (such as **Haskell**), you can find some scaring concepts like **Functors** (we talked about them previously) and **Monoids**.

What if I tell you that you’re already using them?

What if I tell you that you’ve always used them without knowing it?

Let’s see what the heck is a Monoid.

## Monoid Axioms

Let’s do a bit of maths using the `+`

operation:

```
5 + 5 = 10
(10 + 5) + 15 = (5 + 15) + 10
10 + 0 = 0 + 10
```

We can immediately notice three things:

- The result will always be the same, doesn’t matter the order in which we’re doing the sum operation. We can try to sum
`(10 + 5) + 15`

and`(5 + 15) + 10`

, but we’ll always get the same result. - There is a case where adding a number, the result won’t change at all.
`10 + 0`

returns just`10`

. - Let’s look at the first equation: there is a kind of binary operation that takes two things of type
`int`

and returns an element of the same type (`int`

).

Pretty easy, isn’t it? Now let’s call these things with their proper names:

**Associative Property**

The associative property states that you can add or multiply regardless of how the numbers are grouped. By 'grouped' we mean 'how you use parenthesis'. In other words, if you are adding or multiplying it does not matter where you put the parenthesis. Add some parenthesis any where you like! (read more here)

**Identity Element**

The identity property for addition tells us that zero added to any number is the number itself. Zero is called the "additive identity." The identity property for multiplication tells us that the number 1 multiplied times any number gives the number itself. The number 1 is called the "multiplicative identity.” (source)

**Binary Operation**

The word "binary" means composed of two pieces. A binary operation is simply a rule for combining two values to create a new value. The most widely known binary operations are those learned in elementary school: addition, subtraction, multiplication and division on various sets of numbers. (read more here)

So guess what is a **Monoid**?

A Monoid is a set that is closed under an **associative binary operation** and has an **identity** element.

Once again, let’s summarize the three rules that compose a Monoid:

- A binary operation that combines two things and returns a third thing of the same type.
- That binary operation must be associative.
- There must be some kind of identity element for the binary operation.

For instance, we can clearly see that the **division** operation does not respect those rules:

```
(10 / 5) / 2 = 1
10 / (5 / 2) = 0.25
```

but the **multiplication** does:

```
10 * 10 = 100
10 * (5 * 2) = (10 * 5) * 2
10 * 1 = 10
```

## Why should I care about Monoids?

Now let’s make a little example using the ES6 reduce method in **TypeScript**.

```
const myList: number[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const mySum: number = myList.reduce((x, y) => x + y, 0);
```

What’s happening here? In that case, the **reduce** method combines the *Nth* element of the list with an accumulator until there’s only one element left.

For instance, it starts with `1 + 2`

, then with `3 + 3`

(where the first `3`

is the result of the previous operation, `1 + 2`

) and so on:

```
(1 + 2) + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10
(3 + 3) + 4 + 5 + 6 + 7 + 8 + 9 + 10
(6 + 4) + 5 + 6 + 7 + 8 + 9 + 10
(10 + 5) + 6 + 7 + 8 + 9 + 10
(15 + 6) + 7 + 8 + 9 + 10
(21 + 7) + 8 + 9 + 10
(28 + 8) + 9 + 10
(36 + 9) + 10
(45 + 10)
55
```

now let’s assume that we have a list with millions of numbers. How long would it take to compute that task?

Now, let’s think about the associative property. It doesn’t matter the execution order for our operations, right? So that operation can be done in parallel on multiple threads, cores, nodes!

Let’s say that reducing an array of 100 elements on a single core takes 10 seconds (a lot of time, I know, but it’s just for keeping things simple); splitting that operation on five cores may reduce the execution time up to five times!

And what about the **identity property**? Our reduce function expects to combine two things… but what if I pass an empty list? Or what if that list has only on element?

You can notice how the **reduce** method solves that problem by letting us to add the initial value as parameter:

```
const mySum: number = myArray.reduce(sumElements, 0);
// initial value ^
```

as you can see, we’re passing the addition identity which is `0`

. If we’re parallelizing the code above on multiple cores/threads/nodes, it doesn’t matter if we’re passing `0`

as initial value in our `reduce`

function.

## Other Monoids

As I said at the beginning of the article, we’re already using Monoids without even knowing:

**Boolean**

Boolean `AND`

and `OR`

are Monoids. Their identity is `TRUE`

for `AND`

and `FALSE`

for `OR`

:

```
(true && false) && true = (false && true) && true
(true || false) && true = (false || true) && true
```

**String**

String concatenation is also a Monoid. Its identity element is the empty string `""`

:

```
("Hello" + " ") + "World!" = "Hello" + (" " + "World!")
```

**List/Arrays**

Just like strings, list/arrays are Monoids and their identity element is the empty list/array `[]`

:

```
[1, 2, 3, 4] + ([5, 6] + [7, 8, 9, 10]) = ([1, 2, 3, 4] + [5, 6]) + [7, 8, 9, 10]
```

there are also other Monoids and I bet that you’re already using them… try to guess others of them!

## Benefits of Monoids

Ok I have to be honest, we’ve just seen some abstract mathematical concepts, but what are the advantages of using Monoids when programming?

First of all, thanks to the **associativity property** we can parallelize our algorithms, reason on them with a “divide and conquer” mindset and we also get support for incremental for free.

**Identity element** ensure a correct computation given a starting/default value for our functions, so no error will be spawned because of missing values during our operations.

Understanding Monoids (alongside Functors) is also fundamental for another hot topic in mathematics and computer science: **Monads**. But we’ll talk about them in future!