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).
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
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.
'collect' allows you to use Pattern Matching, to filter and map items.
The for-comprehension is highly important syntatic enhancement in functional programming languages.
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!
Pattern matching in Scala lets you quickly identify what you are looking for in a data, and also extract it.
(1 to n)syntax produces a "Range" which is a representation of a sequence of numbers.
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:
.viewsyntax creates a structure that mirrors another structure, until "forced" by an eager operation like .toList, .foreach, .forall, .count.