Compact game of life implementation I am learning F# and implemented Conway's Game of Life as an exercise (There are also other implementations on CodeReview). I have tried to forget all my object-oriented background and practice "functional thinking".

Any feedback is welcome, especially related to alternative (more functional) solutions.

open System

[&lt;EntryPoint&gt;]
let main argv = 

    let rows = 30
    let columns = 30    
    let size = rows*columns

    let combine listX listY = [
        for x in listX do
        for y in listY do
        yield x, y ]

    let createRandomBoard =
        let rnd = new Random(10)
        [1..size] 
        |&gt; List.map (fun x -&gt; if rnd.NextDouble() &lt; 0.2 then 1 else 0) 
        |&gt; List.toArray

    let board = createRandomBoard

    let toBoardLine (line : int[]) : string =
        line |&gt; Array.fold (fun agg i -&gt; agg + (if i = 1 then "X" else ".")) ""        

    let drawBoard () =
        [0..rows-1] 
        |&gt; List.iter (fun y -&gt; printfn "%A" (board.[y*rows..y*rows+columns-1] |&gt; toBoardLine))               

    let indexToCoordinates index = (index % columns + 1, index / columns + 1)
    let coordinatesToIndex (x, y) = (y - 1) * columns + (x - 1)

    let getLivingNeighboursCount idx =
        let x, y = indexToCoordinates idx
        let (minX, maxX) = (if x = 1 then columns else x - 1), (if x = columns then 1 else x + 1)
        let (minY, maxY) = (if y = 1 then rows else y - 1), (if y = rows then 1 else y + 1)
        combine [minX; x; maxX] [minY; y; maxY]
        |&gt; List.filter (fun com -&gt; com &lt;&gt; (x,y))
        |&gt; List.map coordinatesToIndex 
        |&gt; List.map (fun x -&gt; board.[x]) 
        |&gt; List.sum

    let indexToNewState idx =
        let state = board.[idx]
        let livingNeigbours = getLivingNeighboursCount idx
        (if livingNeigbours = 3 || (livingNeigbours = 2 &amp;&amp; state = 1) then 1 else 0)

    let updateState () =
        [0..size-1]
        |&gt; List.iter (fun idx -&gt; (Array.set board idx (indexToNewState idx)))

    while true do
        Console.Clear();
        updateState ()
        drawBoard ()
        System.Threading.Thread.Sleep(200);

    Console.ReadLine()
    0
Some remarks :


your combine function is in fact List.zip, you might want to explore the Array and List sections of the standard library, they are full of very useful functions that will speed-up your development.
createRandomBoard is not a function and thus will always be the same array (arrays being mutable, you might come across some unwanted side effects if you use it twice in the same code). It could be rewritten using Array.init :

let createRandomBoard () =
   let rnd = new Random(10)
   Array.init size (fun _ -&gt; if rnd.NextDouble() &lt; 0.2 then 1 else 0)

you are using '0' and '1' to model your two states, why not booleans ? It would eliminate the need for some tests.
Array.set ar ind x can be rewritten as ar.[ind] &lt;- x (but, as Foggy Finder said, you would lose some type inference if ar has not been identified as an array before)
forms such as :

[1..n] |&gt; List.iter f


are indeed functional but inefficient and, I believe, not as readable as using a loop. F# is especially powerful because it is a hybrid language (and not a purely functional one) : don't hesitate to leverage arrays and loops when it makes sense.