Conway's Game of Life in functional Scala with lazy eval

conway.scala

type Position = (Int, Int)
type State = Set[Position]

def gameOfLife(state: State): Stream[State] =
  if (state.isEmpty) Stream.empty
  else state #:: gameOfLife(nextFrom(state))

def nextFrom(state: State) = {
  for {
    field <- getFieldsFromState(state)
    result <- applyRules(field, state)
  } yield result
}

def applyRules(pos: Position, state: State) = {
  getNeighbourCount(pos, state) match {
    case x if !state.contains(pos) && x == 3 => Some(pos)          // dead field with 3 living neighbours
    case x if state.contains(pos) && x == 2 || x == 3 => Some(pos) // live to see next iteration
    case _ => None                                                 // too many or no neighbours or dead already
  }
}

def getNeighbourCount(pos: Position, state: State) = (expand(pos) - pos).intersect(state).size

def getFieldsFromState(state: State) = state flatMap expand

//def expand(pos: Position) = (for {
//  x <- pos._1 - 1 until pos._1 + 2
//  y <- pos._2 - 1 until pos._2 + 2
//} yield (x, y)).toSet

def expand(p: Position) = Set(
  (p._1 - 1, p._2 - 1), (p._1, p._2 - 1), (p._1 + 1, p._2 - 1),
  (p._1 - 1, p._2),          p,           (p._1 + 1, p._2),
  (p._1 - 1, p._2 + 1), (p._1, p._2 + 1), (p._1 + 1, p._2 + 1)
)

val glider = Set(
  (-1, -1), (0, -1), (1, -1),
  (-1, 0),
  (0, 1)
)

val blinker = Set(
  (0, -1),
  (0, 0),
  (0, 1)
)

val gol = gameOfLife(glider)

def draw(state: State) = {
  val minx = state.foldLeft(Int.MaxValue)((acc, pos) => if (pos._1 < acc) pos._1 else acc)
  val miny = state.foldLeft(Int.MaxValue)((acc, pos) => if (pos._2 < acc) pos._2 else acc)
  val maxx = state.foldLeft(Int.MinValue)((acc, pos) => if (pos._1 > acc) pos._1 else acc)
  val maxy = state.foldLeft(Int.MinValue)((acc, pos) => if (pos._2 > acc) pos._2 else acc)

  (for {
    y <- miny - 2 until maxy + 3
    x <- minx - 2 until maxx + 3
  } yield (x, y)).foreach(pos => {
    if (state.contains(pos)) print("#")
    else print(".")
    if (pos._1 == maxx + 2) print("\n")
  })
}

println("Starting position: glider")
val start = System.currentTimeMillis()

//gol.take(10000).foreach(draw)
val last = gol.take(10000).takeRight(1)

val time = System.currentTimeMillis() - start

draw(last.head)

println(s"Elapsed time: $time ms, per iteration: ${time.toFloat/10000} ms")

Nice observation on behalf of my C++ buddy - Moore neighborhood defines 8 constant neighbour cell addresses, so during expand exploratory function that creates a set of all neighbours + expanded cell in the middle declaring this structure statically instead of using syntactical sugar of iterators in form of for x <- a until b yields nice perfomance gain - namely from 1250ms for 10k iterations to 800ms for 10k iterations on my PC. Revision 3 adds changes this (expand function).

Just to make benchmark more accurate we now force lazy stream to evaluate last element of 10k iterations with takeRight method instead of foreach(draw) to avoid stdout overhead.

Benchmark time is now: Elapsed time: 540 ms, per iteration: 0.054 ms

My C++ version: https://gist.github.com/MLaszczewski/30fae56a7c291e673cd8be822171d639
http://cpp.sh/72jbm
10000 Iterations in 49.917000 milliseconds - 0.004992 milliseconds per iteration.
Not optimized, but 10 times faster than scala :)