Diving into Scala Cats - Monoids

Table of contents

Reading Time: 2 minutes

Today we are going to deep dive into the Scala Cats again to find out about Monoids. If you haven’t already read my post about Diving into Scala Cats – Semigroups I suggest you do so now.

What are Monoids?

The Monoid extends Semigroup and adds a default or fallback value for the given type. Monoid type class comes with two methods – one is the combine method of Semigroups, and another one is the empty method that performs identity operation.

In the post about Semigroups, we saw an example where we’re using Semigroups along with Scala’s fold() to operate on a collection of values:

def combineStrings(collection: Seq[String]): String = {
  collection.foldLeft("")(Semigroup[String].combine)
}

We discussed the limitation of Semigroups where we cannot write a generic method combineAll(collection: Seq[A]): [A] for the above expression because the fallback value will depend on the type of A (”” for String, 0 for Int, etc).

Monoid comes up with a solution to this shortcoming, by introducing an identity/empty element.

The signature of Monoid can be specified as:

trait Monoid[A] extends Semigroup[A] {   
  def empty: A 
}

How does identity element solves the limitation of Semigroups?

The empty String that we are passing in combineStrings is known as the identity or empty value, we can think of it as a fallback or default value. It resolves the shortcoming of Semigroups.

Now we can easily provide the implementation of generic method combineAll(collection: Seq[A]): [A] using Monoids:

def combineAll[A](collection: Seq[A])(implicit ev: Monoid[A]): A = {
  val monoid = Monoid[A]
  collection.foldLeft(monoid.empty)(monoid.combine)
}

Monoids hold Associativity and Identity Laws

Since Semigroups follow principle of associativity, same rules with some add-ons are applied to Monoids as well.

combine operation has to be associative and empty value should be an identity for the combine operation:

combine(x, empty) = combine(empty, x) = x

For example:

// Integer addition using 0 as an identity (Rules valid)
1 + 0 == 0 + 1 == 1

// Integer multiplication using 1 as an identity (Rules valid)
2 * 1 == 1 * 2 == 2

// Integer multiplication using 0 as an identity (Rules invalid)
2 * 0 == 0 * 2 != 2

So it’s clear the empty/identity element depends on the context not just on the type. That’s why Monoid (and Semigroup) implementations are specific not only to the type but also the combine operation.

Cats allows combining Monoids together to form bigger Monoids and write more generalized functions which will take something composable instead of some concrete types.

We’ll learn about more core concepts of Cats in our upcoming article.
Stay tuned!!!