# Scala algorithm: Game of Life

Published

## Algorithm goal

The Game of Life, also known as Conway's Game of Life, is a simulation of a system where cells die out if there is overpopulation, and die out if there is underpopulation.

This simulation is represented in a 2D grid and a variety of patterns can emerge from it; best to refer to the Wikipedia article to learn more about it.

The task here is is to implement the Game of Life in Scala.

## Test cases in Scala

``````assert(startUnbounded.neighbours.size == 9)
assert(Set(startUnbounded).nextGeneration.isEmpty)
assert(Set(startUnbounded, startUnbounded.east).nextGeneration.isEmpty)
assert(
Set(
startUnbounded,
startUnbounded.east,
startUnbounded.east.east
).nextGeneration == Set(
startUnbounded.east,
startUnbounded.south.east,
startUnbounded.north.east
)
)
assert(Set(startBounded).nextGeneration.isEmpty)
assert((Set(startBounded) ++ startBounded.east).nextGeneration.isEmpty)
assert(
(Set.empty ++ startBounded.east ++ startBounded.east.flatMap(
_.south
)).size == 2
)
assert(
(Set(startBounded) ++ startBounded.east ++
startBounded.east.flatMap(_.east)).nextGeneration ==
Set.empty ++ startBounded.east ++ startBounded.east.flatMap(_.south)
)
``````

## Algorithm in Scala

57 lines of Scala (compatible versions 2.13 & 3.0).

## Explanation

While more concise solutions are possible, this solution here focuses on readability.

We represent the set of live cells as a Scala set, and use a Type Class to represent the neighbours of a generic cell. The key of the algorithm is described generically, not specific to any particular representation, in the class RichGameCellS and GameCell. (this is Â© from www.scala-algorithms.com)

We then build out, by composition, a generic TwoDimensionalCell, which is unbounded in dimensions. This could enable us to represent an infinitely big grid, however if we want to limit this grid to something we could render, then we should bound it; so by composition, we create another class BoundedGrid which represents a grid, and contains methods that derive from TwoDimensionalCell.

## Scala concepts & Hints

1. ### Class Inside Class

A great aspect of Scala is being able to declare classes in other classes. This allows one to reduce repetition and for example refer to values of the outer class effortlessly.

``````final case class CountryCounter[T](countryMap: Array[Array[T]]) {

private case class Position(x: Int, y: Int) {
def valueOf: T = countryMap(y)(x)
}

}
``````
2. ### Collect

'collect' allows you to use Pattern Matching, to filter and map items.

``````assert("Hello World".collect {
case character if Character.isUpperCase(character) => character.toLower
} == "hw")
``````
3. ### For-comprehension

The for-comprehension is highly important syntatic enhancement in functional programming languages.

``````val Multiplier = 10

val result: List[Int] = for {
num <- List(1, 2, 3)
anotherNum <-
List(num * Multiplier - 1, num * Multiplier, num * Multiplier + 1)
} yield anotherNum + 1

assert(result == List(10, 11, 12, 20, 21, 22, 30, 31, 32))
``````
4. ### Option Type

The 'Option' type is used to describe a computation that either has a result or does not. In Scala, you can 'chain' Option processing, combine with lists and other data structures. For example, you can also turn a pattern-match into a function that return an Option, and vice-versa!

``````assert(Option(1).flatMap(x => Option(x + 2)) == Option(3))

assert(Option(1).flatMap(x => None) == None)
``````
5. ### Pattern Matching

Pattern matching in Scala lets you quickly identify what you are looking for in a data, and also extract it.

``````assert("Hello World".collect {
case character if Character.isUpperCase(character) => character.toLower
} == "hw")
``````
6. ### Range

The `(1 to n)` syntax produces a "Range" which is a representation of a sequence of numbers.

``````assert((1 to 5).toString == "Range 1 to 5")

assert((1 to 5).reverse.toString() == "Range 5 to 1 by -1")

assert((1 to 5).toList == List(1, 2, 3, 4, 5))
``````
7. ### Type Class

Type classes are one of Scala's most important super-powers: they enable you to add new behaviour to existing classes, without modifying those classes. In many languages, to add a behaviour to a class, you would typically extend it with an interface, and then implement methods against this interface.This, however, does not scale: especially when you have older libraries, you would be forced to make them depend on a new interface, and have to re-build everything.

Type classes are used heavily in Apple's SwiftUI as "extensions" to enable powerful abstraction capabilities.

Type classes enable you to do things like this:

``````import Ordering.Implicits._

type CommonType = (Int, String, Option[String])

val a: CommonType = (1, "X", None)

val b: CommonType = (2, "A", Some("B"))

assert(a < b, "We can order tuples using Scala-provided type classes")
``````
8. ### View

The `.view` syntax creates a structure that mirrors another structure, until "forced" by an eager operation like .toList, .foreach, .forall, .count.

# Scala Algorithms: The most comprehensive library of algorithms in standard pure-functional Scala

## How our 100 algorithms look

1. A description/goal of the algorithm.
2. An explanation with both Scala and logical parts.
3. A proof or a derivation, where appropriate.
4. Links to Scala concepts used in this specific algorithm, also unit-tested.
5. An implementation in pure-functional immutable Scala, with efficiency in mind (for most algorithms, this is for paid subscribers only).
6. Unit tests, with a button to run them immediately in our in-browser IDE.

### Study our 100 Scala Algorithms: 6 fully free, 100 published & 0 upcoming

Fully unit-tested, with explanations and relevant concepts; new algorithms published about once a week.

### Explore the 22 most useful Scala concepts

To save you going through various tutorials, we cherry-picked the most useful Scala concepts in a consistent form.

## Subscribe to Scala Algorithms

Maximize your Scala with disciplined and consistently unit-tested solutions to 100+ algorithms.

Use it from improving your day-to-day data structures and Scala; all the way to interviewing.