lifeGame.pen

import Core'List
import Core'Number
import Core'String

type Context {
  random \() number
}

type cellTuple {
  first boolean
  second boolean
  third boolean
}

NewContext = \(random \() number) Context {
  Context{random: random}
}

Step = \(rs [[boolean]]) [[boolean]] | error {
  stepRows(
    if [f, ..._] = rs {
      if l = List'Last([any ...rs], none) as [boolean] {
        [[boolean] l, ...rs, f()]
      } else {
        error("too few rows")
      }
    } else {
      error("too few rows")
    }?,
  )
}

stepRows = \(rs [[boolean]]) [[boolean]] | error {
  # TODO Use a generalized if-list expression.
  if [r1, ...rs] = rs {
    if [r2, ...rs] = rs {
      if [r3, ...rs] = rs {
        r = stepRow(r1(), r2(), r3())?
        rs = stepRows([[boolean] r2(), r3(), ...rs])?

        [[boolean] r, ...rs]
      } else {
        [[boolean]]
      }
    } else {
      error("too few rows")
    }
  } else {
    error("too few rows")
  }
}

stepRow = \(upper [boolean], current [boolean], lower [boolean]) [boolean] | error {
  stepColumns(loopRow(upper)?, loopRow(current)?, loopRow(lower)?)
}

loopRow = \(cs [boolean]) [boolean] | error {
  if [f, ..._] = cs {
    if l = List'Last([any ...cs], none) as boolean {
      [boolean l, ...cs, f()]
    } else {
      error("too few columns")
    }
  } else {
    error("too few columns")
  }
}

stepColumns = \(upper [boolean], current [boolean], lower [boolean]) [boolean] | error {
  if u = cellTuple(upper) as cellTuple {
    if c = cellTuple(current) as cellTuple {
      if l = cellTuple(lower) as cellTuple {
        n = Number'Sum(
          [number
            if b() { 1 } else { 0 }
            for b in [boolean
              u.first,
              u.second,
              u.third,
              c.first,
              c.third,
              l.first,
              l.second,
              l.third,
            ]
          ],
        )
        bs = stepColumns(tail(upper), tail(current), tail(lower))?

        [boolean c.second & 2 <= n & n <= 3 | !c.second & n == 3, ...bs]
      } else {
        error("wrong row length")
      }
    } else {
      error("wrong row length")
    }
  } else {
    [boolean]
  }
}

tail = \(cs [boolean]) [boolean] {
  if [_, ...cs] = cs {
    cs
  } else {
    [boolean]
  }
}

cellTuple = \(cs [boolean]) cellTuple | none {
  # TODO Use a generalized if-list expression.
  if [c1, ...cs] = cs {
    if [c2, ...cs] = cs {
      if [c3, ...cs] = cs {
        cellTuple{first: c1(), second: c2(), third: c3()}
      } else {
        none
      }
    } else {
      none
    }
  } else {
    none
  }
}

Initialize = \(ctx Context, rows number, columns number) [[boolean]] {
  [[boolean]
    [boolean ctx.random() < 1 / 3 for _ in Number'Sequence(columns)]
    for _ in Number'Sequence(rows)
  ]
}

Render = \(rs [[boolean]]) string {
  String'Join(
    [string
      String'Concatenate([string if x() { "o" } else { "." } for x in r()])
      for r in rs
    ],
    "\n",
  )
    + "\n"
}