Hi all,

I'm quite new to F# so I want some comments on my "first application". I want to write a program that plays Yahtzee. Well, in the end it should solve it, i.e. determines the best play possible for each situation.

This is a very first draft of the program. Please give a lot of comments, especially:

• What is the right data structure for my board (score card)
• I created the roll_dice function to create a random number. If I use it though it will be evaluated only once instead of five times:
  let roll = (List.init 5 (fun i -> roll_dice)
  How do I have to change the roll function that this will work. Or do I need a completely different approach when using random number.
  The same "problem" occurs later in the code:
  let r = ([2; 1; 1; 2; 2], []) // let r = roll
  every iteration should come up with new values
• How to best handle the board. I used a non mutable version in the write_score function. This seems function-programming-like for my. But I use the mutable version later in the for loop. Is this the way how to do these kind of things?
• Are there any good guidelines as how to name types, functions and variables? one-letter vs. camelcase vs. underscores?
• How to format my code better to enhance readability, when to use match instead of if.then.else

Thank you for all comments,

Dashiel

#light

open List
open Seq

/// The .NET random object
let rnd = new System.Random()

/// The possible values for a row
type value =
| Value of int
| Empty
| Stroke

/// The different row types (1s, 2s, Full House, ...)
type row_type =
| Num of int
| FullHouse

/// The list of all row_types available in the game
let all_row_types = [
Num 1;
Num 2;
FullHouse]

/// A throw represents 5 dices plus the fixed dices for the next roll
type throw =
int list * int list

/// Rolls a single dice
let roll_dice =
(rnd.Next(1, 6))

/// Rolls all dices
let roll =
(List.init 5 (fun i -> (rnd.Next(1, 6))) , ([] : int list))
// (fun i -> roll_dice) preferred, but does not work

/// counts occurence of x in list l
let rec count x list =
match list with
| [] -> 0
| head::tail -> (count x tail) + if head = x then 1 else 0

/// Evaluates the points for a roll (r) and a rowtype (t)
let evaluate_points r t =
match t with
| Num n ->
fold (fun s x -> if x = n then s+n else s) 0 (fst r)
| FullHouse ->
let r1 = (fst r)
let a = hd r1
let b = hd (Seq.filter (fun y -> y<>a) r1)
if (count a r1) = 5 ||
(count a r1) = 3 && (count b r1) = 2 ||
(count a r1) = 2 && (count b r1) = 3 then 25 else 0

/// Evaluates the points for a roll and all possible rows
let evaluate_roll (board: (row_type * value) list) r =
board
|> filter (fun (t, s) -> s = Empty)
|> map (fun (t, s) -> (t, evaluate_points r t))

/// creates a new board with an additional entry for roll r and rowtype t
let write_score board r t =
let scores = evaluate_roll board r |> to_list
board
|> map (fun (rowtype, value) -> if rowtype = t
then (rowtype, Value (assoc t scores))
else (rowtype, value))

/// The board of the game with all results

let mutable board =
all_row_types
|> map (fun f -> (f, Empty))
|> to_list

print_any board
printfn ""
printfn ""

// ok, now "play"

for i in [1..3] do
let r = ([2; 1; 1; 2; 2], []) // let r = roll

let possibilities = (evaluate_roll board r) |> to_list
let choose = fold1 (fun (t, v) (t2, v2) -> if t>t2 then (t,v) else (t2, v2)) possibilities

board <- (write_score board r (fst choose)) |> to_list

print_any r
printfn ""
print_any possibilities
printfn ""
print_any choose
printfn ""
print_any board
printfn ""
printfn ""

Output:

[(Num 1, Empty); (Num 2, Empty); (FullHouse, Empty)]

([2; 1; 1; 2; 2], [])
[(Num 1, 2); (Num 2, 6); (FullHouse, 25)]
(FullHouse, 25)
[(Num 1, Empty); (Num 2, Empty); (FullHouse, Value 25)]

([2; 1; 1; 2; 2], [])
[(Num 1, 2); (Num 2, 6)]
(Num 2, 6)
[(Num 1, Empty); (Num 2, Value 6); (FullHouse, Value 25)]

([2; 1; 1; 2; 2], [])
[(Num 1, 2)]
(Num 1, 2)
[(Num 1, Value 2); (Num 2, Value 6); (FullHouse, Value 25)]