Modelling dice rolls in F# - f#

Question

I am doing some Monte Carlo simulations on dice rolls using F# and I am using integers to represent a single roll of a dice and a list of integers to represent a list of dice rolls. I would like to be able to model the dice roll instead of integers as a type. I am only using 6 sided dice and I would like a type that has some of the characteristics of a Alias / Synonym type and some of the properties of either a Discriminated Union or a Enum.
These are what I would like to see on my type
I would like the type to behave like an integer so I can max / min / sum / fold on the lists.
I would like the type to be able to be assigned as an integer value.
I would like the type to be constrained to 1-6 so that there can be no dice roll of a zero and no dice roll of a seven.
I have tried the combination of types listed above and all seem to have some draw backs (which might be my usage and understanding rather than the Types themselves).
This is just a trivial example of something I am doing for fun (not profit) but would like to see an answer as I could imagine using this in more serious data modelling.

Answer 1

As one of the options you could create your own numeric type as described in this post by Tomas Petricek:
http://tomasp.net/blog/fsharp-custom-numeric.aspx/index.html

Answer 2

It seems like a Discriminated Union with some static methods can handle everything you want
open System
type D6 =
| One | Two | Three | Four | Five | Six
member self.Value =
match self with
| One -> 1 | Two -> 2 | Three -> 3
| Four -> 4 | Five -> 5 | Six -> 6
override self.ToString() =
match self with
| One -> "One" | Two -> "Two" | Three -> "Three"
| Four -> "Four" | Five -> "Five" | Six -> "Six"
static member Create (num:int) =
match num with
| 1 -> One | 2 -> Two | 3 -> Three
| 4 -> Four | 5 -> Five | 6 -> Six
| _ -> failwithf "Could not create D6, %d is not in range 1-6" num
static member inline Roll() = Random().Next(1,7) |> D6.Create
Calling D6.Roll() will generate single random roll
> D6.Roll();; val it : D6 = Four
> D6.Roll();; val it : D6 = Six
> D6.Roll();; val it : D6 = Two
> D6.Roll();; val it : D6 = Five
You can create static members and operators that make it easy to compose your D6s together
static member inline Add (a:D6) (b:D6) = a.Value + b.Value
static member inline (+) (a , b ) = D6.Add a b
static member inline Subtract (a:D6) (b:D6) = a.Value - b.Value
static member inline (-) (a , b ) = D6.Subtract a b
And static members that make it easy to create them from a list of input
static member FromList (numls: int list ) =
numls |> List.map D6.Create
Comparison works out the box with this type
D6.One > D6.Two;;
val it : bool = false
D6.One < D6.Two;;
val it : bool = true
Infinite sequences make it easy to generate randomized input
let rollGen =
let rnd = Random()
let rec gen() = seq { yield rnd.Next(1,7)
yield! gen() }
gen()
> rollGen;;
val rollGen : seq<int>
Which can be mapped over to create an infinite random sequence of D6
let d6Gen = rollGen |> Seq.map D6.Create
> d6Gen;;
val d6Gen : seq<D6>
If you want to pull a static list of input values that you can reuse out of the random infinite sequence you need to use functions like
let rollList num = rollGen |> Seq.take num |> List.ofSeq
let d6List num = d6Gen |> Seq.take num |> List.ofSeq ;;
let _20rolls = rollList 20 ;;
> val _20rolls : int list =
[3; 4; 2; 3; 5; 6; 4; 6; 6; 6; 5; 3; 4; 3; 2; 1; 2; 5; 3; 6]*)
let _30d6 = d6List 30 ;;
> val _30d6 : D6 list =
[Two; Six; One; Three; Two; Three; One; One; Six; Six; Four; Four; Three;
Four; One; Five; Three; Four; Four; Four; Three; Two; Six; Four; One; Three;
One; Five; Two; Two]
Gist of just the code