GOTO - programming with the stars (F#)

Anden session i dag under parolen "Programming with the stars" var F# og Mark Seesmann. Det viste sig, at "programming with the stars" var et spor, hvor "the stars" skulle løse det samme problem allesammen - hver med deres favoritsprog. Opgaven var i al sin enkelthed at tage et input til Minesweeper-programmet med placering af bomber i et 4x4 grid og give som output værdierne for de enkelte celler afhængigt af bombernes placering.

Input:

. * . .
* . . .
. . . .
. . * .

Output:

2 * 1 0
* 2 1 0
1 2 1 1
0 1 * 1

Dette var dermed også opgaven for den tidligere session med Java.

Mark startede med at spørge om, hvor mange der kendte til F#. Et par tøvende hænder viste sig rundt omkring i lokalet. Derfor spurgte han hvor mange, der var kommet for at få en introduktion af sproget og lære mere om det. Stort set samtlige rakte hånden op. Desværre blev dette ikke ført til dørs, for niveauet var i hvert fald for mig alt for højt til at jeg kunne lære noget - udover at få inspiration til at kigge nærmere på det. Marks "sidekick" var nemlig ikke en "menig" tilhører i lokalet - det var søreme en F#-ekspert, der i øvrigt stod for en F#-usergroup i London. Det skal siges at Mark forsøgte bravt at holde partneren i ørene og løbende forklare de syrede constructs han brugte - men det var lidt svært for ham.

Anyways.

Jeg skal huske at sige, at Mark og partner havde snydt lidt og forberedt noget hjemmefra, men når det så er sagt, så blev jeg nærmest bjergtaget over forskellene i løsningerne. Nu er der jo mange måder at løse problemet på, men det var mit klare indtryk, at grunden til forskellene i løsningerne for det imperative sprog og for det funktionelle sprog skyldtes netop forskellene i sprog og ikke så meget forskellene i de personer, der kodede skidtet. Jeg skal være den første til at erkende, at den imperative løsning nok havde bevæget sig ud af en uheldig, kompleks tangent, men det var tydeligt for mig, at dette spor skulle illustrere tankerne om "right tool for the job". For hvis det eneste værktøj man har i kassen er et imperativt, OO-sprog, så bliver måske løsningerne også derefter. Den imperative løsning endte hurtigt med et sandt virvar af klasser, enums og lignende, hvorimod den funktionsorienterede løsning fokuserede på data og udregningerne af det og ikke meget mere. Den samlede funktionsorientede løsning var vel på 20 liniers kode, hvorimod den imperative brugte mindst det samme alene på klasseerklæringer og lignende.

Som sagt var det for mig en inspiration til at kigge meget nærmere på F#, også er det jo heldigt, at Marks sidekick fortalte os om et website han havde lavet, der hedder www.tryfsharp.org . Denne URI er hermed poppet op på toppen af min "Read it later"-kø .

Opdateret: Marks kode findes nu på https://gist.github.com/2776707

let input = "**..
....
.*..
...."
 
let compute (board : string) =
    let board = board.Split([| "\n" |], System.StringSplitOptions.RemoveEmptyEntries)
    let count (x, y) =
 
        [-1, -1; 0, -1;  1, -1;
         -1,  0;         1,  0;
         -1,  1; 0,  1;  1,  1]
         |> List.map (fun (x', y') -> x + x', y + y')
         |> List.filter (fun (x, y) -> x >= 0 && x < board.[0].Length && y >= 0 && y < board.Length)
         |> List.sumBy (fun (x, y) ->
            if board.[y].[x] = '*'
            then 1
            else 0
         )
 
    board
    |> Array.mapi (fun y line ->
        line.ToCharArray() |> Array.mapi (fun x c ->
            match c with
            | '*' -> '*'
            | '.' -> '0' + char (count(x, y))
            | _ -> invalidArg "c" "Boo hiss!"
        )
    )
    |> Array.map (fun chars -> System.String(chars))
    |> Array.reduce (sprintf "%s\n%s")