Every implementation of FizzBuzz in this series, at its core, has relied on an infinitely counting lazy list. This modelling is logical, as the game can theoretically be played indefinitely. In this post, we will explore the possibility of defining a single function operating on this running number and, as a bonus, utilize Scala 3's extension methods to enhance code clarity.
LazyList
.from(1)
...
.take(n)
.toList
What we are looking for is:
LazyList
.from(1)
.map(i: Int => ???)
.take(n)
.toList
Let's define a method and its signature:
LazyList
.from(1)
.map(fizzbuzzAt)
.take(n)
.toList
def fizzbuzzAt(n: Int): String = ???
Note from the first article in this series an implementation of fizzbuzzAt using if statements could be:
@main def fizzbuzz(): Unit =
def fizzbuzzAt(n: Int): String =
if n % 15 == 0 then "FizzBuzz"
else if n % 5 == 0 then "Buzz"
else if n % 3 == 0 then "Fizz"
else
n.toString
end fizzbuzzAt
def fizzbuzz(n: Int): List[String] =
LazyList
.from(1)
.map(fizzbuzzAt)
.take(n)
.toList
end fizzbuzz
fizzbuzz(20).foreach(fb => print(fb + ","))
end fizzbuzz
Now we want to simplify the if expression and make it easier to implement e.g. other 'shouts', say Bazz every 2 times. For this article, we want to be looking into a solution using functions.
A quite natural function to decide whether Fizz should be shouted is one taking an integer as input and returning maybe a String ("Fizz"):
val fizz: Int => Option[String] = ???
Our fizzbuzzAt could then look like:
def fizzbuzzAt(n: Int): String =
val fizz: Int => Option[String] = i =>
if i % 3 == 0 then Some("Fizz") else None
val buzz: Int => Option[String] =
i => if i % 5 == 0 then Some("Buzz") else None
val combined: Int => Option[String] = ???
val fizzbuzz: Int => String = ???
fizzbuzz(n)
end fizzbuzzAt
So we need to combine 2 functions of the same signature Int => Option[String]:
def combine[A](f1: A => Option[String], f2: A => Option[String]): A => Option[String] =
a =>
(f1(a), f2(a)) match
case (Some(s1), Some(s2)) => Some(s1 + s2)
case (None, Some(s2)) => Some(s2)
case (Some(s1), None) => Some(s1)
case (None, None) => None
We generalized a little in the argument, the return type we keep at String as we need to operate on it. (In a next blog post we will also generalize this more but we leave it as this for now.)
fizzbuzz needs to turn the combined function Int => Option[String] into a function Int => String. For the FizzBuzz game, turning Option[String] into a String given an integer can be done like:
val fizzbuzz: Int => String = i =>
combined(i).getOrElse(i.toString)
fizzbuzzAt then becomes:
def fizzbuzzAt(n: Int): String =
val fizz: Int => Option[String] = i =>
if i % 3 == 0 then Some("Fizz") else None
val buzz: Int => Option[String] = i =>
if i % 5 == 0 then Some("Buzz") else None
val combined: Int => Option[String] =
combine(fizz, buzz)
val fizzbuzz: Int => String = i =>
combined(i).getOrElse(i.toString)
fizzbuzz(n)
end fizzbuzzAt
Let's transform fizzbuzzAt into a function as well:
val fizzbuzzAt: Int => String =
val fizz: Int => Option[String] = i =>
if i % 3 == 0 then Some("Fizz") else None
val buzz: Int => Option[String] = i =>
if i % 5 == 0 then Some("Buzz") else None
val combined: Int => Option[String] =
combine(fizz, buzz)
val fizzbuzz: Int => String = i =>
combined(i).getOrElse(i.toString)
fizzbuzz
end fizzbuzzAt
Let's eliminate the duplication in the fizz and buzz functions:
val fizzbuzzAt: Int => String =
extension (word: String)
def every(n: Int): Int => Option[String] = i =>
if i % n == 0 then Some(word) else None
val fizz = "Fizz".every(3)
val buzz = "Buzz".every(5)
val combined: Int => Option[String] =
combine(fizz, buzz)
val fizzbuzz: Int => String = i =>
combined(i).getOrElse(i.toString)
fizzbuzz
end fizzbuzzAt
Here we make use of a Scala 3 extension method to make the function definition clearer and, I would argue, more easily reusable with less chance of errors.
Putting all word shouts into a list allows for easier extension in a single place:
val fizzbuzzAt: Int => String =
extension (word: String)
def every(n: Int): Int => Option[String] = i => if i % n == 0 then Some(word) else None
val wordShouts = List(
"Fizz".every(3),
"Buzz".every(5),
"Bazz".every(2)
)
val combined = wordShouts.reduce(combine)
val fizzbuzz: Int => String = i =>
combined(i).getOrElse(i.toString)
fizzbuzz
end fizzbuzzAt
If we want to account for empty wordShouts we can instead resort to a fold:
val combined = words.fold(_ => None)(combine)
We defined the 'zero' function to accept any integer and return None. I will expand on this in a next blog post and leave the reduce function in the final version of this article:
@main def fizzbuzz(): Unit =
def combine[A](f1: A => Option[String], f2: A => Option[String]): A => Option[String] =
a =>
(f1(a), f2(a)) match
case (Some(s1), Some(s2)) => Some(s1 + s2)
case (None, Some(s2)) => Some(s2)
case (Some(s1), None) => Some(s1)
case (None, None) => None
val fizzbuzzAt: Int => String =
extension (word: String)
def every(n: Int): Int => Option[String] = i =>
if i % n == 0 then Some(word) else None
val wordShouts = List(
"Fizz".every(3),
"Buzz".every(5)
)
val combined = wordShouts.reduce(combine)
val fizzbuzz: Int => String = i =>
combined(i).getOrElse(i.toString)
fizzbuzz
end fizzbuzzAt
def fizzbuzz(n: Int): List[String] =
LazyList
.from(1)
.map(fizzbuzzAt)
.take(n)
.toList
end fizzbuzz
fizzbuzz(20).foreach(fb => print(fb + ","))
end fizzbuzz
This prints:
1,2,Fizz,4,Buzz,Fizz,7,8,Fizz,Buzz,11,Fizz,13,14,FizzBuzz,16,17,Fizz,19,Buzz,
In conclusion, this article demonstrated how to create a single function for the FizzBuzz game using Scala, combining functions and making use of Scala 3's extension methods for clarity and reduced potential for errors. This approach allows for easier testing and extension of the game with additional word shouts, showcasing the power and flexibility of functional programming and Scala.