HanLHo. - Fractional Architect & Software Product Engineer - scala3

FizzBuzz fun: Exploring Functional Programming Design Patterns : Monoids

2023-12-04T00:00:00+00:00
In this post, we will continue from where we left off in a previous article in this series, "FizzBuzz Fun in Scala: Combining Functions," and explore where further abstraction leads us in terms of functional programming design patterns. Our goal is to show that, despite their intimidating name, Monoids are a logical, reusable design pattern that emerges when reducing list-like structures to a single value—a task quite common in everyday development. As for Scala 3, we will also utilize contextual abstractions instead of Scala 2 implicits, to combine more complex structures from smaller ones.
Combining values using a single abstraction</h2>
Below is the code we will start with. If you would like to understand this code better please see the FizzBuzz fun in Scala: Combining functions</a> post.
// Commenting the Scala 3 version / Scala CLI directive
</span>//> using scala 3.3.1
</span>
</span>def </span>combine</span>[</span>A</span>](
</span>    </span>f1</span>: </span>A </span>=> </span>Option</span>[</span>String</span>],
</span>    </span>f2</span>: </span>A </span>=> </span>Option</span>[</span>String</span>]
</span>): </span>A </span>=> </span>Option</span>[</span>String</span>] =
</span>  </span>a </span>=>
</span>    (f1(a), f2(a)) </span>match
</span>      </span>case </span>(Some(</span>s1</span>), Some(</span>s2</span>)) </span>=> </span>Some(s1 + s2)
</span>      </span>case </span>(None, Some(</span>s2</span>))     </span>=> </span>Some(s2)
</span>      </span>case </span>(Some(</span>s1</span>), None)     </span>=> </span>Some(s1)
</span>      </span>case </span>(None, None)         </span>=> </span>None
</span>
</span>val </span>fizzbuzzAt</span>: </span>Int </span>=> </span>String </span>=
</span>  extension (word: </span>String</span>)
</span>    </span>def </span>every</span>(</span>n</span>: </span>Int</span>): </span>Int </span>=> </span>Option</span>[</span>String</span>] = </span>i </span>=>
</span>      </span>if</span> i % n == </span>0</span> then Some(word) </span>else </span>None
</span>
</span>  </span>val </span>wordShouts </span>= List(
</span>    "</span>Fizz</span>".every(</span>3</span>),
</span>    "</span>Buzz</span>".every(</span>5</span>)
</span>  )
</span>  </span>val </span>combined </span>= wordShouts.fold(</span>_ </span>=> </span>None)(combine)
</span>  </span>val </span>fizzbuzz</span>: </span>Int </span>=> </span>String </span>= </span>i </span>=>
</span>    combined(i).getOrElse(i.toString)
</span>  fizzbuzz
</span>end fizzbuzzAt
</span>
</span>def </span>fizzbuzz</span>(</span>n</span>: </span>Int</span>): </span>List</span>[</span>String</span>] =
</span>  LazyList
</span>    .from(</span>1</span>)
</span>    .map(fizzbuzzAt)
</span>    .take(n)
</span>    .toList
</span>end fizzbuzz
</span>
</span>@</span>main </span>def </span>fizzbuzz</span>(): </span>Unit </span>=
</span>  fizzbuzz(</span>20</span>).foreach(</span>fb </span>=></span> print(fb + "</span>,</span>"))
</span>end fizzbuzz
</span></code></pre>

💡</div>
Code can be run using Scala CLI</strong></a>. Save a copy of a complete example in e.g. FizzBuzz.scala</code> and run it like: scala-cli run FizzBuzz.scala</code>. In this article, a complete runnable example can be recognised by a //> using scala 3.3.1</code> directive near the top of the file.</div>
</div>
We will begin by zooming in on how we 'combined' multiple functions with the type signature Int => Option[String]</code> into a single one:</p>
def </span>combine</span>[</span>A</span>](
</span>    </span>f1</span>: </span>A </span>=> </span>Option</span>[</span>String</span>],
</span>    </span>f2</span>: </span>A </span>=> </span>Option</span>[</span>String</span>]
</span>): </span>A </span>=> </span>Option</span>[</span>String</span>] =
</span>  </span>a </span>=>
</span>    (f1(a), f2(a)) </span>match
</span>      </span>case </span>(Some(</span>s1</span>), Some(</span>s2</span>)) </span>=> </span>Some(s1 + s2)
</span>      </span>case </span>(None, Some(</span>s2</span>))     </span>=> </span>Some(s2)
</span>      </span>case </span>(Some(</span>s1</span>), None)     </span>=> </span>Some(s1)
</span>      </span>case </span>(None, None)         </span>=> </span>None
</span></code></pre>
which is used as:</p>
val </span>combined </span>= wordShouts.fold(</span>_ </span>=> </span>None)(combine)
</span></code></pre>
In the `fold</code>` we seem to have two related functions so let's define them together:</p>
trait</span> Combiner</span>[</span>B</span>]:
</span>  </span>def </span>zero</span>: </span>B
</span>  </span>def </span>combine</span>(</span>b1</span>: </span>B</span>, </span>b2</span>: </span>B</span>): </span>B
</span></code></pre>
The zero</code> function enables us to define an element that 'does not count' when combining elements. The combine</code> function allows us to merge elements of the same type into another element of the same type. For example, consider integers: we could combine them using addition, in which case the zero element would be 0; alternatively, we could combine them using multiplication, in which case the zero element would be 1.</p>
Looking at the type signature of combine</code>:</p>
def </span>combine</span>[</span>A</span>](
</span>    </span>f1</span>: </span>A </span>=> </span>Option</span>[</span>String</span>],
</span>    </span>f2</span>: </span>A </span>=> </span>Option</span>[</span>String</span>]
</span>): </span>A </span>=> </span>Option</span>[</span>String</span>]
</span></code></pre>
We can see that B</code> in Combiner[B]</code> in this case would be of type A => Option[String]</code>, so the instance for our type of Combiner</code> would look like this:</p>
new </span>Combiner</span>[</span>A </span>=> </span>Option</span>[</span>String</span>]]:
</span>  </span>override def </span>zero</span>: </span>A </span>=> </span>Option</span>[</span>String</span>] = </span>???
</span>  </span>override def </span>combine</span>(
</span>        </span>a1</span>: </span>A </span>=> </span>Option</span>[</span>String</span>],
</span>        </span>a2</span>: </span>A </span>=> </span>Option</span>[</span>String</span>]
</span>    ): </span>A </span>=> </span>Option</span>[</span>String</span>] = </span>???
</span>end Combiner
</span></code></pre>
Declaring the instance in an object (later we will group more Combiner</code> instances together) we get:</p>
object</span> Combiner</span>:
</span>  </span>def </span>myCombiner</span>[</span>A</span>] = </span>new </span>Combiner</span>[</span>A </span>=> </span>Option</span>[</span>String</span>]]:
</span>    </span>override def </span>zero</span>: </span>A </span>=> </span>Option</span>[</span>String</span>] = </span>???
</span>    </span>override def </span>combine</span>(
</span>        </span>a1</span>: </span>A </span>=> </span>Option</span>[</span>String</span>],
</span>        </span>a2</span>: </span>A </span>=> </span>Option</span>[</span>String</span>]
</span>    ): </span>A </span>=> </span>Option</span>[</span>String</span>] = </span>???
</span>end Combiner
</span></code></pre>
To implement zero</code> we can have a look at the fold</code> usage above. For the combine</code> method we can have a look at our original combine</code> function:</p>
object</span> Combiner</span>:
</span>  </span>def </span>myCombiner</span>[</span>A</span>] = </span>new </span>Combiner</span>[</span>A </span>=> </span>Option</span>[</span>String</span>]]:
</span>    </span>override def </span>zero</span>: </span>A </span>=> </span>Option</span>[</span>String</span>] =
</span>      </span>_ </span>=> </span>None
</span>    </span>override def </span>combine</span>(
</span>        </span>a1</span>: </span>A </span>=> </span>Option</span>[</span>String</span>],
</span>        </span>a2</span>: </span>A </span>=> </span>Option</span>[</span>String</span>]
</span>    ): </span>A </span>=> </span>Option</span>[</span>String</span>] =
</span>      </span>a </span>=>
</span>        (a1(a), a2(a)) </span>match
</span>          </span>case </span>(Some(</span>s1</span>), Some(</span>s2</span>)) </span>=> </span>Some(s1 + s2)
</span>          </span>case </span>(None, Some(</span>s2</span>)) </span>=> </span>Some(s2)
</span>          </span>case </span>(Some(</span>s1</span>), None) </span>=> </span>Some(s1)
</span>          </span>case </span>(None, None) </span>=> </span>None
</span>end Combiner
</span></code></pre>
This Combiner</code> we can then use to implement our original combine</code> function:</p>
import</span> Combiner.*
</span>def </span>combine</span>[</span>A</span>](
</span>    </span>f1</span>: </span>A </span>=> </span>Option</span>[</span>String</span>],
</span>    </span>f2</span>: </span>A </span>=> </span>Option</span>[</span>String</span>]
</span>): </span>A </span>=> </span>Option</span>[</span>String</span>] =
</span>  myCombiner.combine(f1, f2)
</span></code></pre>
At this point, our solution works again and we can remove our combine</code> function entirely. Our `fold</code>` then becomes:</p>
  </span>val </span>combined </span>=
</span>    wordShouts.fold(</span>_ </span>=> </span>None)(myCombiner.combine)
</span></code></pre>
Or:</p>
  </span>val </span>combined </span>=
</span>    wordShouts.fold(myCombiner.zero)(myCombiner.combine)
</span></code></pre>
Since the Combiner</code> type has all the behaviour required for fold</code> ideally we would write:</p>
val </span>combined </span>= wordShouts.fold(myCombiner)
</span></code></pre>
Which we can do using an extension method:</p>
extension[</span>A</span>] (as: </span>List</span>[</span>A</span>])
</span>  </span>def </span>foldWith</span>(</span>c</span>: </span>Combiner</span>[</span>A</span>]): </span>A </span>=
</span>    as.fold(c.zero)(c.combine)
</span>
</span>val </span>combined </span>= wordShouts.foldWith(myCombiner)
</span></code></pre>
Note: using fold</code> as a name for the extension method sadly does not seem to work so I renamed it to foldWith</code>. I did delve deeper into this on why this is.</p>
Combine all the things!</h2>
At this point, you might be wondering, "Why go through all this trouble?". The answer lies in the fact that the two functions we defined in Combiner</code> are precisely the arguments we provide to a fold</code>. A fold represents the operation of combining elements within a collection while accounting for cases where the collection has no elements. This is something we do frequently. In functional programming, this type is commonly referred to by its mathematical name: a monoid.</p>
If we rename our definition of Combiner</code> to Monoid</code>, then this is precisely how a Monoid is defined:</p>
trait</span> Monoid</span>[</span>A</span>]:
</span>  </span>def </span>zero</span>: </span>A
</span>  </span>def </span>combine</span>(</span>b1</span>: </span>A</span>, </span>b2</span>: </span>A</span>): </span>A
</span></code></pre>
Let's stick with Combiner</code> for now and I'll revisit monoids further down in this post.</p>
Let's have a closer look at our current instance of Combiner</code>:</p>
  </span>def </span>myCombiner</span>[</span>A</span>] = </span>new </span>Combiner</span>[</span>A </span>=> </span>Option</span>[</span>String</span>]]:
</span>    </span>override def </span>zero</span>: </span>A </span>=> </span>Option</span>[</span>String</span>] =
</span>      </span>_ </span>=> </span>None
</span>    </span>override def </span>combine</span>(
</span>        </span>a1</span>: </span>A </span>=> </span>Option</span>[</span>String</span>],
</span>        </span>a2</span>: </span>A </span>=> </span>Option</span>[</span>String</span>]
</span>    ): </span>A </span>=> </span>Option</span>[</span>String</span>] =
</span>      </span>a </span>=>
</span>        (a1(a), a2(a)) </span>match
</span>          </span>case </span>(Some(</span>s1</span>), Some(</span>s2</span>)) </span>=> </span>Some(s1 + s2)
</span>          </span>case </span>(None, Some(</span>s2</span>))     </span>=> </span>Some(s2)
</span>          </span>case </span>(Some(</span>s1</span>), None)     </span>=> </span>Some(s1)
</span>          </span>case </span>(None, None)         </span>=> </span>None
</span></code></pre>
The code accomplishes several tasks:</p>
1. The pattern matching on the Option</code> type essentially combines Options, which is not directly related to combining functions.</p>
2. The addition of String</code>s, s1 + s2, can also be regarded as 'combining'.</p>
3. The Combiner</code> is generic in its argument, but its return type is specific to Option[String]</code>.</p>
Currently, our Combiner</code> instance appears to be combining functions, Options, and Strings simultaneously. Let's attempt to separate each of these into its own Combiner:</p>
  </span>def </span>stringCombiner </span>= </span>new </span>Combiner</span>[</span>String</span>]:
</span>    </span>override def </span>zero</span>: </span>String </span>= </span>???
</span>    </span>override def </span>combine</span>(</span>a1</span>: </span>String</span>, </span>a2</span>: </span>String</span>): </span>String </span>= </span>???
</span>    
</span>  </span>def </span>optionCombiner</span>[</span>A</span>] = </span>new </span>Combiner</span>[</span>Option</span>[</span>A</span>]]:
</span>    </span>override def </span>zero</span>: </span>Option</span>[</span>A</span>] = </span>???
</span>    </span>override def </span>combine</span>(</span>a1</span>: </span>Option</span>[</span>A</span>], </span>a2</span>: </span>Option</span>[</span>A</span>]): </span>Option</span>[</span>A</span>] = </span>???
</span>    
</span>  </span>def </span>functionCombiner</span>[</span>A</span>, </span>B</span>] = </span>new </span>Combiner</span>[</span>A </span>=> </span>B</span>]:
</span>    </span>override def </span>zero</span>: </span>A </span>=> </span>B </span>= </span>???
</span>    </span>override def </span>combine</span>(</span>f1</span>: </span>A </span>=> </span>B</span>, </span>f2</span>: </span>A </span>=> </span>B</span>): </span>A </span>=> </span>B </span>= </span>???
</span></code></pre>
Since we started with combining functions, let's start with functionCombiner</code>:</p>
def </span>functionCombiner</span>[</span>A</span>, </span>B</span>] =
</span>  </span>new </span>Combiner</span>[</span>A </span>=> </span>B</span>]:
</span>    </span>override def </span>zero</span>: </span>A </span>=> </span>B </span>= </span>a </span>=> ???
</span>    </span>override def </span>combine</span>(</span>f1</span>: </span>A </span>=> </span>B</span>, </span>f2</span>: </span>A </span>=> </span>B</span>): </span>A </span>=> </span>B </span>=
</span>      </span>a </span>=>
</span>        </span>val </span>b1 </span>= f1(a)
</span>        </span>val </span>b2 </span>= f2(a)
</span>        </span>??? </span>// combine b1 and b2
</span></code></pre>
We need a way to combine B</code>s, otherwise we cannot possibly continu. Do we have a way of combining Bs? Certainly, if pass one:</p>
def </span>functionCombiner</span>[</span>A</span>, </span>B</span>](</span>bc</span>: </span>Combiner</span>[</span>B</span>]) =
</span>  </span>new </span>Combiner</span>[</span>A </span>=> </span>B</span>]:
</span>    </span>override def </span>zero</span>: </span>A </span>=> </span>B </span>= </span>a </span>=></span> bc.zero
</span>    </span>override def </span>combine</span>(</span>f1</span>: </span>A </span>=> </span>B</span>, </span>f2</span>: </span>A </span>=> </span>B</span>): </span>A </span>=> </span>B </span>=
</span>      </span>a </span>=>
</span>        </span>val </span>b1 </span>= f1(a)
</span>        </span>val </span>b2 </span>= f2(a)
</span>        bc.combine(b1, b2)
</span>    end combine
</span>end functionCombiner
</span></code></pre>
In our myCombiner</code> B</code> is an Option[String]</code>:</p>
def </span>myCombiner</span>[</span>A</span>] = </span>new </span>Combiner</span>[</span>A </span>=> </span>Option</span>[</span>String</span>]]: ...
</span></code></pre>
To implement our combiner, we need a way of combining Options. Let's start with Option[String]</code> first:</p>
  </span>def </span>optionStringCombiner </span>= </span>new </span>Combiner</span>[</span>Option</span>[</span>String</span>]]:
</span>    </span>override def </span>zero</span>: </span>Option</span>[</span>String</span>] = None
</span>    </span>override def </span>combine</span>(
</span>        </span>a1</span>: </span>Option</span>[</span>String</span>],
</span>        </span>a2</span>: </span>Option</span>[</span>String</span>]
</span>    ): </span>Option</span>[</span>String</span>] =
</span>      (a1, a2) </span>match
</span>        </span>case </span>(Some(</span>s1</span>), Some(</span>s2</span>)) </span>=> </span>Some(s1 + s2)
</span>        </span>case </span>(None, Some(</span>s2</span>))     </span>=> </span>Some(s2)
</span>        </span>case </span>(Some(</span>s1</span>), None)     </span>=> </span>Some(s1)
</span>        </span>case </span>(None, None)         </span>=> </span>None
</span></code></pre>
Here, similar to what we did for the functionCombiner</code>, we can generalize by passing a Combiner</code> for a generic parameter:</p>
def </span>optionCombiner</span>[</span>A</span>](</span>ac</span>: </span>Combiner</span>[</span>A</span>]) =
</span>  </span>new </span>Combiner</span>[</span>Option</span>[</span>A</span>]]:
</span>    </span>override def </span>zero</span>: </span>Option</span>[</span>A</span>] = None
</span>    </span>override def </span>combine</span>(
</span>        </span>maybeA1</span>: </span>Option</span>[</span>A</span>],
</span>        </span>maybeA2</span>: </span>Option</span>[</span>A</span>]
</span>    ): </span>Option</span>[</span>A</span>] =
</span>      (maybeA1, maybeA2) </span>match
</span>        </span>case </span>(Some(</span>a1</span>), Some(</span>a2</span>)) </span>=> </span>Some(ac.combine(a1, a2))
</span>        </span>case </span>(None, Some(</span>a2</span>))     </span>=> </span>Some(a2)
</span>        </span>case </span>(Some(</span>a1</span>), None)     </span>=> </span>Some(a1)
</span>        </span>case </span>(None, None)         </span>=> </span>None
</span></code></pre>
The final piece of the puzzle involves combining strings. The stringCombiner</code> is easy compared to the other combiners we have already implemented:</p>
  </span>def </span>stringCombiner </span>= </span>new </span>Combiner</span>[</span>String</span>]:
</span>    </span>override def </span>zero</span>: </span>String </span>= ""
</span>    </span>override def </span>combine</span>(</span>a1</span>: </span>String</span>, </span>a2</span>: </span>String</span>): </span>String </span>= a1 + a2
</span></code></pre>
If we now define the optionsStringCombiner</code> in terms of the optionCombiner</code> and stringCombiner</code> we get:</p>
def </span>optionStringCombiner </span>= optionCombiner(stringCombiner)
</span></code></pre>
Our original myCombiner</code>, of type Combiner[A => Option[String]]</code> becomes:</p>
def </span>myCombiner</span>[</span>A</span>] =
</span>  functionCombiner[</span>A</span>, </span>Option</span>[</span>String</span>]](
</span>    optionCombiner(
</span>      stringCombiner
</span>    )
</span>  )
</span></code></pre>
To recap what we have done:</p>


We defined a trait called Combiner</code> to combine elements.</p>
</li>

We created an instance of this class that enables us to combine 'word shouts'. We modelled shouting words as functions: Int => Option[String]</code>, meaning that given a number, we may or may not shout a word.</p>
</li>

We defined this instance using three more atomic instances: one that knows how to combine Strings, one that knows how to combine Options, and one that knows how to combine functions.</p>
</li>

We also defined an extension method for the List</code> class that takes this Combiner</code> instance and performs the actual combining.</p>
</li>
</ul>
All together:</p>
// Commenting the Scala 3 version / Scala CLI directive
</span>//> using scala 3.3.1
</span>
</span>trait</span> Combiner</span>[</span>A</span>]:
</span>  </span>def </span>zero</span>: </span>A
</span>  </span>def </span>combine</span>(</span>a1</span>: </span>A</span>, </span>a2</span>: </span>A</span>): </span>A
</span>
</span>object</span> Combiner</span>:
</span>  </span>def </span>myCombiner</span>[</span>A</span>] =
</span>    functionCombiner[</span>A</span>, </span>Option</span>[</span>String</span>]](
</span>      optionCombiner(
</span>        stringCombiner
</span>      )
</span>    )
</span>
</span>  </span>def </span>stringCombiner </span>= </span>new </span>Combiner</span>[</span>String</span>]:
</span>    </span>override def </span>zero</span>: </span>String </span>= ""
</span>    </span>override def </span>combine</span>(</span>a1</span>: </span>String</span>, </span>a2</span>: </span>String</span>): </span>String </span>=
</span>      a1 + a2
</span>
</span>  </span>def </span>optionCombiner</span>[</span>A</span>](</span>ac</span>: </span>Combiner</span>[</span>A</span>]) =
</span>    </span>new </span>Combiner</span>[</span>Option</span>[</span>A</span>]]:
</span>      </span>override def </span>zero</span>: </span>Option</span>[</span>A</span>] = None
</span>      </span>override def </span>combine</span>(
</span>          </span>maybeA1</span>: </span>Option</span>[</span>A</span>],
</span>          </span>maybeA2</span>: </span>Option</span>[</span>A</span>]
</span>      ): </span>Option</span>[</span>A</span>] =
</span>        (maybeA1, maybeA2) </span>match
</span>          </span>case </span>(Some(</span>a1</span>), Some(</span>a2</span>)) </span>=>
</span>            Some(ac.combine(a1, a2))
</span>          </span>case </span>(None, Some(</span>a2</span>)) </span>=> </span>Some(a2)
</span>          </span>case </span>(Some(</span>a1</span>), None) </span>=> </span>Some(a1)
</span>          </span>case </span>(None, None)     </span>=> </span>None
</span>
</span>  </span>def </span>functionCombiner</span>[</span>A</span>, </span>B</span>](</span>bc</span>: </span>Combiner</span>[</span>B</span>]) =
</span>    </span>new </span>Combiner</span>[</span>A </span>=> </span>B</span>]:
</span>      </span>override def </span>zero</span>: </span>A </span>=> </span>B </span>= </span>a </span>=></span> bc.zero
</span>      </span>override def </span>combine</span>(</span>f1</span>: </span>A </span>=> </span>B</span>, </span>f2</span>: </span>A </span>=> </span>B</span>): </span>A </span>=> </span>B </span>=
</span>        </span>a </span>=>
</span>          </span>val </span>b1 </span>= f1(a)
</span>          </span>val </span>b2 </span>= f2(a)
</span>          bc.combine(b1, b2)
</span>      end combine
</span>  end functionCombiner
</span>
</span>end Combiner
</span>
</span>import</span> Combiner.*
</span>
</span>val </span>fizzbuzzAt</span>: </span>Int </span>=> </span>String </span>=
</span>  extension (word: </span>String</span>)
</span>    </span>def </span>every</span>(</span>n</span>: </span>Int</span>): </span>Int </span>=> </span>Option</span>[</span>String</span>] = </span>i </span>=>
</span>      </span>if</span> i % n == </span>0</span> then Some(word) </span>else </span>None
</span>
</span>  extension [</span>A</span>](as: </span>List</span>[</span>A</span>])
</span>    </span>def </span>foldWith</span>(</span>c</span>: </span>Combiner</span>[</span>A</span>]): </span>A </span>=
</span>      as.fold(c.zero)(c.combine)
</span>
</span>  </span>val </span>wordShouts </span>= List(
</span>    "</span>Fizz</span>".every(</span>3</span>),
</span>    "</span>Buzz</span>".every(</span>5</span>)
</span>  )
</span>  </span>val </span>combined </span>= wordShouts.foldWith(myCombiner)
</span>  </span>val </span>fizzbuzz</span>: </span>Int </span>=> </span>String </span>= </span>i </span>=>
</span>    combined(i).getOrElse(i.toString)
</span>  fizzbuzz
</span>end fizzbuzzAt
</span>
</span>def </span>fizzbuzz</span>(</span>n</span>: </span>Int</span>): </span>List</span>[</span>String</span>] =
</span>  LazyList
</span>    .from(</span>1</span>)
</span>    .map(fizzbuzzAt)
</span>    .take(n)
</span>    .toList
</span>end fizzbuzz
</span>
</span>@</span>main </span>def </span>fizzbuzz</span>(): </span>Unit </span>=
</span>  fizzbuzz(</span>20</span>).foreach(</span>fb </span>=></span> print(fb + "</span>,</span>"))
</span>end fizzbuzz
</span></code></pre>
Contextual abstraction using given instances and using clauses</h2>
Scala 2's implicits enabled removing all the explicit wiring of our Combiner</code>s. In Scala 3 this is now done using given</code> instances and using</code> clauses. All our Combiner instances can be declared with the given</code> keyword, and wherever we need an instance of Combiner</code> to be available we use the using</code> keyword.</p>
Here is the complete implementation; afterwards, I will highlight the most important parts.</p>
// Commenting the Scala 3 version / Scala CLI directive
</span>//> using scala 3.3.1
</span>
</span>trait</span> Combiner</span>[</span>A</span>]:
</span>  </span>def </span>zero</span>: </span>A
</span>  </span>def </span>combine</span>(</span>a1</span>: </span>A</span>, </span>a2</span>: </span>A</span>): </span>A
</span>
</span>object</span> Combiner</span>:
</span>
</span>  given stringCombiner: </span>Combiner</span>[</span>String</span>] </span>with
</span>    </span>override def </span>zero</span>: </span>String </span>= ""
</span>    </span>override def </span>combine</span>(</span>a1</span>: </span>String</span>, </span>a2</span>: </span>String</span>): </span>String </span>=
</span>      a1 + a2
</span>
</span>  given optionCombiner[</span>A</span>](using ac: </span>Combiner</span>[</span>A</span>]): </span>Combiner</span>[</span>Option</span>[</span>A</span>]] </span>with
</span>      </span>override def </span>zero</span>: </span>Option</span>[</span>A</span>] = None
</span>      </span>override def </span>combine</span>(
</span>          </span>maybeA1</span>: </span>Option</span>[</span>A</span>],
</span>          </span>maybeA2</span>: </span>Option</span>[</span>A</span>]
</span>      ): </span>Option</span>[</span>A</span>] =
</span>        (maybeA1, maybeA2) </span>match
</span>          </span>case </span>(Some(</span>a1</span>), Some(</span>a2</span>)) </span>=>
</span>            Some(ac.combine(a1, a2))
</span>          </span>case </span>(None, Some(</span>a2</span>)) </span>=> </span>Some(a2)
</span>          </span>case </span>(Some(</span>a1</span>), None) </span>=> </span>Some(a1)
</span>          </span>case </span>(None, None)     </span>=> </span>None
</span>
</span>  given functionCombiner[</span>A</span>, </span>B</span>] (using
</span>                                cb: </span>Combiner</span>[</span>B</span>]
</span>                               ): </span>Combiner</span>[</span>A </span>=> </span>B</span>] </span>with
</span>      </span>override def </span>zero</span>: </span>A </span>=> </span>B </span>= </span>a </span>=></span> cb.zero
</span>      </span>override def </span>combine</span>(</span>f1</span>: </span>A </span>=> </span>B</span>, </span>f2</span>: </span>A </span>=> </span>B</span>): </span>A </span>=> </span>B </span>=
</span>        </span>a </span>=>
</span>          </span>val </span>b1 </span>= f1(a)
</span>          </span>val </span>b2 </span>= f2(a)
</span>          cb.combine(b1, b2)
</span>      end combine
</span>  end functionCombiner
</span>end Combiner
</span>
</span>import</span> Combiner.given
</span>
</span>val </span>fizzbuzzAt</span>: </span>Int </span>=> </span>String </span>=
</span>  extension (word: </span>String</span>)
</span>    </span>def </span>every</span>(</span>n</span>: </span>Int</span>): </span>Int </span>=> </span>Option</span>[</span>String</span>] = </span>i </span>=>
</span>      </span>if</span> i % n == </span>0</span> then Some(word) </span>else </span>None
</span>
</span>  extension [</span>A</span>](as: </span>List</span>[</span>A</span>])
</span>    </span>def </span>foldWith</span>(using </span>c</span>: </span>Combiner</span>[</span>A</span>]): </span>A </span>=
</span>      as.fold(c.zero)(c.combine)
</span>
</span>  </span>val </span>wordShouts </span>= List(
</span>    "</span>Fizz</span>".every(</span>3</span>),
</span>    "</span>Buzz</span>".every(</span>5</span>)
</span>  )
</span>  </span>val </span>combined </span>= wordShouts.foldWith
</span>  </span>val </span>fizzbuzz</span>: </span>Int </span>=> </span>String </span>= </span>i </span>=>
</span>    combined(i).getOrElse(i.toString)
</span>  fizzbuzz
</span>end fizzbuzzAt
</span>
</span>def </span>fizzbuzz</span>(</span>n</span>: </span>Int</span>): </span>List</span>[</span>String</span>] =
</span>  LazyList
</span>    .from(</span>1</span>)
</span>    .map(fizzbuzzAt)
</span>    .take(n)
</span>    .toList
</span>end fizzbuzz
</span>
</span>@</span>main </span>def </span>fizzbuzz</span>(): </span>Unit </span>=
</span>  fizzbuzz(</span>20</span>).foreach(</span>fb </span>=></span> print(fb + "</span>,</span>"))
</span>end fizzbuzz
</span></code></pre>
Highlights:</p>

The Combiner</code> object contains all given instances of Combiner</code> :</li>
</ul>

</span>object</span> Combiner</span>:
</span>  given stringCombiner: </span>Combiner</span>[</span>String</span>] </span>with
</span>  ...
</span>  given optionCombiner[</span>A</span>](using ac: </span>Combiner</span>[</span>A</span>]): </span>Combiner</span>[</span>Option</span>[</span>A</span>]] </span>with
</span>  ...
</span>  given functionCombiner[</span>A</span>, </span>B</span>] (using cb: </span>Combiner</span>[</span>B</span>]): </span>Combiner</span>[</span>A </span>=> </span>B</span>] </span>with
</span>  ...
</span>end Combiner
</span></code></pre>

given instances must be explicitly imported ('import Combiner.*</code>' does not</em> import them!):</li>
</ul>
import</span> Combiner.given
</span></code></pre>

All elements can be folded into a single element, if a Combiner</code> instance for A is given:</li>
</ul>
extension [</span>A</span>](as: </span>List</span>[</span>A</span>])
</span>  </span>def </span>foldWith</span>(using </span>c</span>: </span>Combiner</span>[</span>A</span>]): </span>A </span>=
</span>    as.fold(c.zero)(c.combine)
</span></code></pre>


This fold needs a Combiner</code> for Int => Option[String]</code>:</p>


functionCombiner</code>'s type matches but needs a Combiner</code> for Option[String]</code></p>
</li>

optionCombiner</code>'s type matches but needs a Combiner</code> for String</code></p>
</li>

stringCombiner</code>'s type matches and does not need anything more</p>
</li>
</ul>
</li>
</ul>
As such a 'complete' function combiner instance is given and will be used to fold all shouts into a single function:</p>
val </span>combined </span>= wordShouts.foldWith
</span></code></pre>
Reuse with cats</h2>
in Scala 3 type classes are traits with one or more parameters whose implementations are provided as given</code>instances. So Combiner</code> is now a type class. As I mentioned earlier, the Combiner</code> type class is known in category theory as a Monoid</code> (which does come with some 'laws' which allow these structures to be well suited for parallelization but this is out of the scope of this article and for details I'll refer to the references at the end):</p>
trait</span> Monoid</span>[</span>A</span>]:
</span>  </span>def </span>zero</span>: </span>A
</span>  </span>def </span>combine</span>(</span>b1</span>: </span>A</span>, </span>b2</span>: </span>A</span>): </span>A
</span></code></pre>
The cats</em> library</a> also defines this type class.</p>
Let's now try to reuse the Monoid</code> type class from cats.</p>
Note the changes below:</p>


The cats lib dependency is declared and can be used: //> using lib org.typelevel::cats-core:2.10.0</code></p>
</li>

The cats Monoid</code> type class is now used instead of Combiner</code></p>
</li>

The zero</code> function is renamed to empty</code> to match cats'</em> names.</p>
</li>

The Combiner</code> object is renamed to CombinerInstances</code></p>
</li>

The foldWith</code> extension method is replaced with the Monoid.combineAll</code> method on (a superclass of) List</code> so. This method looks for a monoid that can combine the elements in the list of type List[Int => Option[String]]</code>. This line is where most of the 'action' happens.</p>
</li>
</ul>
// Commenting the Scala 3 version / Scala CLI directive
</span>//> using scala 3.3.1
</span>//> using lib org.typelevel::cats-core:2.10.0
</span>import</span> cats.Monoid
</span>
</span>object</span> CombinerInstances</span>:
</span>
</span>  given stringCombiner: </span>Monoid</span>[</span>String</span>] </span>with
</span>    </span>override def </span>empty</span>: </span>String </span>= ""
</span>    </span>override def </span>combine</span>(</span>a1</span>: </span>String</span>, </span>a2</span>: </span>String</span>): </span>String </span>=
</span>      a1 + a2
</span>
</span>  given optionCombiner[</span>A</span>](using ac: </span>Monoid</span>[</span>A</span>]): </span>Monoid</span>[</span>Option</span>[</span>A</span>]] </span>with
</span>      </span>override def </span>empty</span>: </span>Option</span>[</span>A</span>] = None
</span>      </span>override def </span>combine</span>(
</span>          </span>maybeA1</span>: </span>Option</span>[</span>A</span>],
</span>          </span>maybeA2</span>: </span>Option</span>[</span>A</span>]
</span>      ): </span>Option</span>[</span>A</span>] =
</span>        (maybeA1, maybeA2) </span>match
</span>          </span>case </span>(Some(</span>a1</span>), Some(</span>a2</span>)) </span>=>
</span>            Some(ac.combine(a1, a2))
</span>          </span>case </span>(None, Some(</span>a2</span>)) </span>=> </span>Some(a2)
</span>          </span>case </span>(Some(</span>a1</span>), None) </span>=> </span>Some(a1)
</span>          </span>case </span>(None, None)     </span>=> </span>None
</span>
</span>  given functionCombiner[</span>A</span>, </span>B</span>] (using
</span>                                cb: </span>Monoid</span>[</span>B</span>]
</span>                               ): </span>Monoid</span>[</span>A </span>=> </span>B</span>] </span>with
</span>      </span>override def </span>empty</span>: </span>A </span>=> </span>B </span>= </span>_ </span>=></span> cb.empty
</span>      </span>override def </span>combine</span>(</span>f1</span>: </span>A </span>=> </span>B</span>, </span>f2</span>: </span>A </span>=> </span>B</span>): </span>A </span>=> </span>B </span>=
</span>        </span>a </span>=>
</span>          </span>val </span>b1 </span>= f1(a)
</span>          </span>val </span>b2 </span>= f2(a)
</span>          cb.combine(b1, b2)
</span>      end combine
</span>  end functionCombiner
</span>
</span>end CombinerInstances
</span>
</span>import</span> CombinerInstances.given
</span>
</span>val </span>fizzbuzzAt</span>: </span>Int </span>=> </span>String </span>=
</span>  extension (word: </span>String</span>)
</span>    </span>def </span>every</span>(</span>n</span>: </span>Int</span>): </span>Int </span>=> </span>Option</span>[</span>String</span>] = </span>i </span>=>
</span>      </span>if</span> i % n == </span>0</span> then Some(word) </span>else </span>None
</span>
</span>  </span>val </span>wordShouts </span>= List(
</span>    "</span>Fizz</span>".every(</span>3</span>),
</span>    "</span>Buzz</span>".every(</span>5</span>)
</span>  )
</span>  </span>val </span>combined </span>= Monoid.combineAll(wordShouts)
</span>  </span>val </span>fizzbuzz</span>: </span>Int </span>=> </span>String </span>= </span>i </span>=>
</span>    combined(i).getOrElse(i.toString)
</span>  fizzbuzz
</span>end fizzbuzzAt
</span>
</span>def </span>fizzbuzz</span>(</span>n</span>: </span>Int</span>): </span>List</span>[</span>String</span>] =
</span>  LazyList
</span>    .from(</span>1</span>)
</span>    .map(fizzbuzzAt)
</span>    .take(n)
</span>    .toList
</span>end fizzbuzz
</span>
</span>@</span>main </span>def </span>fizzbuzz</span>(): </span>Unit </span>=
</span>  fizzbuzz(</span>20</span>).foreach(</span>fb </span>=></span> print(fb + "</span>,</span>"))
</span>end fizzbuzz
</span></code></pre>
It turns out that the instances we defined ourselves are quite common, and cats also provides these monoid instances. For example, the monoid instance we defined for String</code> can be imported using:</p>
import</span> cats.instances.string.given
</span></code></pre>
Once this is done we do not need our instance in MonoidInstances</code> anymore. The same can be done for the Option and function instances. So in the end we can delete all of our custom instances including the CombinerInstances</code> object because it has become empty:</p>
// Commenting the Scala 3 version / Scala CLI directive
</span>//> using scala 3.3.1
</span>//> using lib org.typelevel::cats-core:2.10.0
</span>import</span> cats.Monoid
</span>
</span>import</span> cats.instances.string.given
</span>import</span> cats.instances.option.given
</span>import</span> cats.instances.function.given
</span>
</span>val </span>fizzbuzzAt</span>: </span>Int </span>=> </span>String </span>=
</span>  extension (word: </span>String</span>)
</span>    </span>def </span>every</span>(</span>n</span>: </span>Int</span>): </span>Int </span>=> </span>Option</span>[</span>String</span>] = </span>i </span>=>
</span>      </span>if</span> i % n == </span>0</span> then Some(word) </span>else </span>None
</span>
</span>  </span>val </span>wordShouts </span>= List(
</span>    "</span>Fizz</span>".every(</span>3</span>),
</span>    "</span>Buzz</span>".every(</span>5</span>)
</span>  )
</span>  </span>val </span>combined </span>= Monoid.combineAll(wordShouts)
</span>  </span>val </span>fizzbuzz</span>: </span>Int </span>=> </span>String </span>= </span>i </span>=>
</span>    combined(i).getOrElse(i.toString)
</span>  fizzbuzz
</span>end fizzbuzzAt
</span>
</span>def </span>fizzbuzz</span>(</span>n</span>: </span>Int</span>): </span>List</span>[</span>String</span>] =
</span>  LazyList
</span>    .from(</span>1</span>)
</span>    .map(fizzbuzzAt)
</span>    .take(n)
</span>    .toList
</span>end fizzbuzz
</span>
</span>@</span>main </span>def </span>fizzbuzz</span>(): </span>Unit </span>=
</span>  fizzbuzz(</span>20</span>).foreach(</span>fb </span>=></span> print(fb + "</span>,</span>"))
</span>end fizzbuzz
</span></code></pre>
This is the final version of Fizzbuzz in this article. As a side bar, note how we ended with 10 lines less than what we started with when rolling our own monoids manually.</p>
Conclusion</h2>
In conclusion, this article demonstrates how monoids emerge as a reusable design pattern when reducing list-like structures to a single value. By building upon the FizzBuzz example, we explored the process of defining and assembling reusable monoid instances, and eventually transitioned to using the Cats library for simplification and reuse.</p>
Finally, here are some references if you would like to delve deeper into Monoids or functional programming in Scala:</p>


The Scala red book</a> (note there is also a second edition for Scala 3</a>)</p>
</li>

FP Tower</a> has a very elegant and natural way of introducing Monoids in its course materials. As far as courses go this is one of the most engaging courses I ever took online. (Not free. Scala 2 at the time of writing.)</p>
</li>

Monoid documentation of the cats library</a></p>
</li>

Another explanation of what a Monoid is using FizzBuzz on reddit</a></p>
</li>
</ul>
HanLHo. - Fractional Architect & Software Product Engineer - scala3

FizzBuzz fun: Exploring Functional Programming Design Patterns : Monoids

Simplifying if-complexity in FizzBuzz

FizzBuzz fun in Scala: Combining functions

Fizzbuzz fun in Scala: A straightforward implementation

FizzBuzz Functional Fun in Scala 3
