{"id":962,"date":"2010-04-24T19:04:36","date_gmt":"2010-04-24T19:04:36","guid":{"rendered":"http:\/\/www.navision-blog.de\/2010\/04\/24\/solving-kata-yahtzee-with-fsharp-and-naturalspec\/"},"modified":"2010-04-24T19:04:36","modified_gmt":"2010-04-24T19:04:36","slug":"solving-kata-yahtzee-with-fsharp-and-naturalspec","status":"publish","type":"post","link":"http:\/\/www.navision-blog.de\/blog\/2010\/04\/24\/solving-kata-yahtzee-with-fsharp-and-naturalspec\/","title":{"rendered":"Solving KataYahtzee with F# and NaturalSpec"},"content":{"rendered":"

Today I\u2019m starting a new blog post series about solving code katas in F#<\/a> and with the help of my NaturalSpec<\/a> project. A code kata is a programming exercise which helps to improve your skills through practice and repetition. In this series we want to use the Test Driven Development TDD<\/a> approach which means in the context of NaturalSpec that we have to write our specs before we implement the algorithm.<\/p>\n

Problem Description<\/h4>\n
\n

\u201cThe game of yahtzee is a simple dice game. Each round, each player rolls five six sided dice. The player may choose to reroll some or all of the dice up to three times (including the original roll). The player then places the roll at a category, such as ones, twos, sixes, pair, two pairs etc. If the roll is compatible with the score, the player gets a score for this roll according to the rules. If the roll is not compatible, the player gets a score of zero for this roll. <\/p>\n

The kata consists of creating the rules to score a roll in any of a predefined category. Given a roll and a category, the final solution should output the score for this roll placed in this category.\u201d<\/p>\n

[codingdojo.org<\/a>]<\/p>\n<\/blockquote>\n

Category 1 \u2013 Ones, Twos, Threes, Fours, Fives, Sixes<\/h5>\n
\n

\u201cOnes, Twos, Threes, Fours, Fives, Sixes: The player scores the sum of the dice that reads one, two, three, four, five or six, respectively. For example, 1, 1, 2, 4, 4 placed on "fours" gives 8 points.\u201d<\/p>\n<\/blockquote>\n

After reading this category description we could come up with the following spec:<\/p>\n

\n

module<\/span> Yahtzee.Specs<\/p>\n

 <\/p>\n

open<\/span> NaturalSpec<\/p>\n

 <\/p>\n

let<\/span> placed_on category list =<\/p>\n

    printMethod category<\/p>\n

    calcValue category list<\/p>\n

 <\/p>\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 1,1,2,4,4 placed on "fours" gives 8 points.“ () =   <\/p>\n

    Given (1, 1, 2, 4, 4)<\/p>\n

      |> When (placed_on Fours)<\/p>\n

      |> It should equal 8<\/p>\n

      |> Verify<\/p>\n<\/p><\/div>\n

Since we really want to implement six different categories we should also add some more scenarios like this one:<\/p>\n

\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 1,1,6,4,6 placed on "sixes" gives 12 points.“ ()=   <\/p>\n

    Given (1, 1, 6, 4, 6)<\/p>\n

      |> When (placed_on Sixes)<\/p>\n

      |> It should equal 12<\/p>\n

      |> Verify<\/p>\n

 <\/p>\n

\/\/ …<\/p>\n<\/p><\/div>\n

Now we have some specs but they will all fail since we don\u2019t have anything implemented yet. So we have to come up with a model of dice rolls and categories. As the specs suggests we model the dice roll as a tuple of ints and the category as a discriminated union<\/a>:<\/p>\n

\n

module<\/span> Yahtzee.Model<\/p>\n

 <\/p>\n

type<\/span> Roll = int * int * int * int * int<\/p>\n

 <\/p>\n

type<\/span> Category =<\/p>\n

| Ones<\/p>\n

| Twos<\/p>\n

| Threes<\/p>\n

| Fours<\/p>\n

| Fives<\/p>\n

| Sixes   <\/p>\n<\/p><\/div>\n

The tuple is a natural choice for the dice roll, but for easier calculation we add a helper function which converts it into a list. This allows use to use the standard list functions and therefore summing the values becomes trivial:<\/p>\n

\n

let<\/span> toList (roll:Roll) =<\/p>\n

    let<\/span> a,b,c,d,e = roll<\/p>\n

    [a;b;c;d;e]<\/p>\n

 <\/p>\n

let<\/span> sumNumber number =<\/p>\n

    Seq.filter ((=) number)<\/p>\n

      >> Seq.sum<\/p>\n

 <\/p>\n

let<\/span> calcValue category roll =<\/p>\n

    let<\/span> list = toList roll<\/p>\n

    match<\/span> category with<\/span><\/p>\n

    | Ones   -><\/span> sumNumber 1 list<\/p>\n

    | Twos   -><\/span> sumNumber 2 list<\/p>\n

    | Threes -><\/span> sumNumber 3 list<\/p>\n

    | Fours  -><\/span> sumNumber 4 list<\/p>\n

    | Fives  -><\/span> sumNumber 5 list<\/p>\n

    | Sixes  -><\/span> sumNumber 6 list<\/p>\n<\/p><\/div>\n

Now we can run our scenarios with any NUnit runner. I\u2019m using the default NUnit<\/a> GUI runner here, which gives me a picture like this:<\/p>\n

\"Both<\/p>\n

Category 2 \u2013 Pair<\/h5>\n
\n

\u201cPair: The player scores the sum of the two highest matching dice. For example, 3, 3, 3, 4, 4 placed on "pair" gives 8.\u201d<\/p>\n<\/blockquote>\n

The kata description gives us some new scenarios. As seen above we should specify them before writing the code.<\/p>\n

\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 3,3,3,4,4 placed on "pair" gives 8.“ () =   <\/p>\n

    Given (3, 3, 3, 4, 4)<\/p>\n

      |> When (placed_on Pair)<\/p>\n

      |> It should equal 8<\/p>\n

      |> Verify<\/p>\n

 <\/p>\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 5,3,5,4,4 placed on "pair" gives 10.“ () =   <\/p>\n

    Given (5, 3, 5, 4, 4)<\/p>\n

      |> When (placed_on Pair)<\/p>\n

      |> It should equal 10<\/p>\n

      |> Verify    <\/p>\n

 <\/p>\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 1,2,3,4,5 placed on "pair" gives 0.“ () =   <\/p>\n

    Given (1, 2, 3, 4, 5)<\/p>\n

      |> When (placed_on Pair)<\/p>\n

      |> It should equal 0<\/p>\n

      |> Verify      <\/p>\n<\/p><\/div>\n

Since we use a new category we now have to extend our model and the calcValue<\/strong> function:<\/p>\n

\n

type<\/span> Category =<\/p>\n

| Ones<\/p>\n

  \/\/ …<\/span><\/p>\n

| Sixes<\/p>\n

| Pair<\/p>\n

 <\/p>\n

\/\/ …<\/span><\/p>\n

<\/span><\/p>\n

let<\/span> sumAsPair list number =<\/p>\n

    let<\/span> numberCount = <\/p>\n

        list <\/p>\n

          |> Seq.filter ((=) number) <\/p>\n

          |> Seq.length<\/p>\n

 <\/p>\n

    if<\/span> numberCount >= 2 then<\/span> 2 * number else<\/span> 0<\/p>\n

 <\/p>\n

let<\/span> calcValue category roll =<\/p>\n

    let<\/span> list = toList roll<\/p>\n

    match<\/span> category with<\/span><\/p>\n

    | Ones   -><\/span> sumNumber 1 list<\/p>\n

        \/\/ …<\/span><\/p>\n

    | Sixes  -><\/span> sumNumber 6 list<\/p>\n

    | Pair   -><\/span> <\/p>\n

        [1..6]<\/p>\n

          |> Seq.map (sumAsPair list)<\/p>\n

          |> Seq.max   <\/p>\n<\/p><\/div>\n

Category 3 – Two pairs<\/h5>\n
\n

\u201cTwo pairs: If there are two pairs of dice with the same number, the player scores the sum of these dice. If not, the player scores 0. For example, 1, 1, 2, 3, 3 placed on "two pairs" gives 8.\u201d<\/p>\n<\/blockquote>\n

<\/strong> <\/p>\n

\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 1,1,2,3,3 placed on "two pair" gives 8.“ () =   <\/p>\n

    Given (1, 1, 2, 3, 3)<\/p>\n

      |> When (placed_on TwoPair)<\/p>\n

      |> It should equal 8<\/p>\n

      |> Verify<\/p>\n

 <\/p>\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 1,6,6,3,3 placed on "two pair" gives 18.“ () =   <\/p>\n

    Given (1, 6, 6, 3, 3)<\/p>\n

      |> When (placed_on TwoPair)<\/p>\n

      |> It should equal 18<\/p>\n

      |> Verify<\/p>\n

 <\/p>\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 1,1,2,4,3 placed on "two pair" gives 0.“ () =   <\/p>\n

    Given (1, 1, 2, 4, 3)<\/p>\n

      |> When (placed_on TwoPair)<\/p>\n

      |> It should equal 0<\/p>\n

      |> Verify  <\/p>\n<\/p><\/div>\n

Implementing this category is a little bit tricky but with the help of our Pair function and some more standard sequence combinators we can get our spec green:<\/p>\n

\n

type<\/span> Category =<\/p>\n

| Ones<\/p>\n

  \/\/ …<\/span><\/p>\n

| TwoPair<\/p>\n

 <\/p>\n

let<\/span> allPairs =<\/p>\n

    [for<\/span> i in<\/span> 1..6 do<\/span><\/p>\n

       for<\/span> j in<\/span> 1..6 -><\/span> i,j]<\/p>\n

 <\/p>\n

let<\/span> calcValue category roll =<\/p>\n

    \/\/ …<\/span><\/p>\n

    | TwoPair   -><\/span> <\/p>\n

        allPairs<\/p>\n

          |> Seq.filter (fun<\/span> (a,b) -><\/span> a <> b)<\/p>\n

          |> Seq.map (fun<\/span> (a,b) -><\/span> <\/p>\n

                let<\/span> a’ = sumAsPair list a<\/p>\n

                let<\/span> b’ = sumAsPair list b<\/p>\n

                if<\/span> a’ = 0 || b’ = 0 then<\/span> 0 else<\/span> a’ + b’)<\/p>\n

          |> Seq.max     <\/p>\n<\/p><\/div>\n

Category 4 – Three of a kind<\/h5>\n
\n

\u201cThree of a kind: If there are three dice with the same number, the player scores the sum of these dice. Otherwise, the player scores 0. For example, 3, 3, 3, 4, 5 places on "three of a kind" gives 9.\u201d<\/p>\n<\/blockquote>\n

\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 3,3,3,4,5 placed on "three of a kind" gives 9“()=   <\/p>\n

    Given (3, 3, 3, 4, 5)<\/p>\n

      |> When (placed_on ThreeOfAKind)<\/p>\n

      |> It should equal 9<\/p>\n

      |> Verify<\/p>\n

 <\/p>\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 3,4,3,4,5 placed on "three of a kind" gives 0“()=   <\/p>\n

    Given (3, 4, 3, 4, 5)<\/p>\n

      |> When (placed_on ThreeOfAKind)<\/p>\n

      |> It should equal 0<\/p>\n

      |> Verify <\/p>\n<\/p><\/div>\n

Now it is time to refactor our code. The sumAsPair<\/b> function should be extended to a sumAsTuple function:<\/p>\n

\n

type<\/span> Category =<\/p>\n

| Ones<\/p>\n

  \/\/ …<\/span><\/p>\n

| ThreeOfAKind<\/p>\n

 <\/p>\n

let<\/span> sumAsTuple value list number =<\/p>\n

    let<\/span> numberCount = <\/p>\n

        list <\/p>\n

          |> Seq.filter ((=) number) <\/p>\n

          |> Seq.length<\/p>\n

 <\/p>\n

let<\/span> takeBestTuple value list =<\/p>\n

    [1..6]<\/p>\n

        |> Seq.map (sumAsTuple value list)<\/p>\n

        |> Seq.max  <\/p>\n

    if<\/span> numberCount >= value then<\/span> value * number else<\/span> 0<\/p>\n

 <\/p>\n

let<\/span> calcValue category roll =<\/p>\n

      \/\/ …<\/span><\/p>\n

    | Pair   -><\/span> takeBestTuple 2 list<\/p>\n

    | TwoPair   -><\/span> <\/p>\n

        allPairs<\/p>\n

          |> Seq.filter (fun<\/span> (a,b) -><\/span> a <> b)<\/p>\n

          |> Seq.map (fun<\/span> (a,b) -><\/span> <\/p>\n

                let<\/span> a’ = sumAsTuple 2 list a<\/p>\n

                let<\/span> b’ = sumAsTuple 2 list b<\/p>\n

                if<\/span> a’ = 0 || b’ = 0 then<\/span> 0 else<\/span> a’ + b’)<\/p>\n

          |> Seq.max<\/p>\n

    | ThreeOfAKind \u2013><\/span> takeBestTuple 3 list<\/p>\n<\/p><\/div>\n

Category 5 – Four of a kind<\/h5>\n
\n

\u201cFour of a kind: If there are four dice with the same number, the player scores the sum of these dice. Otherwise, the player scores 0. For example, 2, 2, 2, 2, 5 places on "four of a kind" gives 8.\u201d<\/p>\n<\/blockquote>\n

\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 2,2,2,2,5 placed on "four of a kind" gives 8“ ()=   <\/p>\n

    Given (2, 2, 2, 2, 5)<\/p>\n

      |> When (placed_on FourOfAKind)<\/p>\n

      |> It should equal 8<\/p>\n

      |> Verify<\/p>\n

 <\/p>\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 2,6,2,2,5 placed on "four of a kind" gives 0“ ()=   <\/p>\n

    Given (2, 6, 2, 2, 5)<\/p>\n

      |> When (placed_on FourOfAKind)<\/p>\n

      |> It should equal 0<\/p>\n

      |> Verify   <\/p>\n<\/p><\/div>\n

With the help of the takeBestTuple function this becomes trivial:<\/p>\n

type<\/span> Category =<\/p>\n

| Ones<\/p>\n

  \/\/ …<\/span><\/p>\n

| FourOfAKind<\/p>\n

 <\/p>\n

let<\/span> calcValue category roll =<\/p>\n

      \/\/ …<\/span><\/p>\n

    | FourOfAKind  -><\/span> takeBestTuple 4 list<\/p>\n

 <\/p>\n

Category 6 \u2013 Small straight<\/h5>\n
\n

\u201cSmall straight: If the dice read 1,2,3,4,5, the player scores 15 (the sum of all the dice), otherwise 0.\u201d<\/p>\n<\/blockquote>\n

\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 1,2,3,4,5 placed on "Small Straight" gives 15“()=   <\/p>\n

    Given (1,2,3,4,5)<\/p>\n

      |> When (placed_on SmallStraight)<\/p>\n

      |> It should equal 15<\/p>\n

      |> Verify<\/p>\n

 <\/p>\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 1,2,5,4,3 placed on "Small Straight" gives 15“()=   <\/p>\n

    Given (1,2,5,4,3)<\/p>\n

      |> When (placed_on SmallStraight)<\/p>\n

      |> It should equal 15<\/p>\n

      |> Verify<\/p>\n

 <\/p>\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 1,2,6,4,3 placed on "Small Straight" gives 0“()=   <\/p>\n

    Given (1,2,6,4,3)<\/p>\n

      |> When (placed_on SmallStraight)<\/p>\n

      |> It should equal 0<\/p>\n

      |> Verify  <\/p>\n<\/p><\/div>\n

As in all the above scenarios we don\u2019t assume any specific order in our rolls but for this category it is easier to test if the data is sorted:<\/p>\n

\n

type<\/span> Category =<\/p>\n

| Ones<\/p>\n

  \/\/ …<\/span><\/p>\n

| SmallStraight<\/p>\n

 <\/p>\n

let<\/span> calcValue category roll =<\/p>\n

      \/\/ …<\/span><\/p>\n

    | SmallStraight -><\/span> <\/p>\n

        match<\/span> list |> List.sort with<\/span><\/p>\n

        | [1;2;3;4;5] -><\/span> 15<\/p>\n

        | _ -><\/span> 0<\/p>\n<\/p><\/div>\n

Category 7 \u2013 Large straight<\/h5>\n
\n

\u201cLarge straight: If the dice read 2,3,4,5,6, the player scores 20 (the sum of all the dice), otherwise 0.\u201d<\/p>\n<\/blockquote>\n

\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 2,3,4,5,6 placed on "Large Straight" gives 20“()=   <\/p>\n

    Given (2,3,4,5,6)<\/p>\n

      |> When (placed_on LargeStraight)<\/p>\n

      |> It should equal 20<\/p>\n

      |> Verify<\/p>\n

 <\/p>\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 6,2,5,4,3 placed on "Large Straight" gives 20“()=   <\/p>\n

    Given (6,2,5,4,3)<\/p>\n

      |> When (placed_on LargeStraight)<\/p>\n

      |> It should equal 20<\/p>\n

      |> Verify<\/p>\n

 <\/p>\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 1,2,6,4,3 placed on "Large Straight" gives 0“()=   <\/p>\n

    Given (1,2,6,4,3)<\/p>\n

      |> When (placed_on LargeStraight)<\/p>\n

      |> It should equal 0<\/p>\n

      |> Verify  <\/p>\n<\/p><\/div>\n

Of course the implementation is exactly the same as for the small straight:<\/p>\n

\n

type<\/span> Category =<\/p>\n

| Ones<\/p>\n

  \/\/ …<\/span><\/p>\n

| LargeStraight<\/p>\n

 <\/p>\n

let<\/span> calcValue category roll =<\/p>\n

      \/\/ …<\/span><\/p>\n

    | LargeStraight -><\/span> <\/p>\n

        match<\/span> list |> List.sort with<\/span><\/p>\n

        | [2;3;4;5;6] -><\/span> 20<\/p>\n

        | _ -><\/span> 0<\/p>\n<\/p><\/div>\n

Category 8 \u2013 Full house<\/h5>\n
\n

\u201cFull house: If the dice are two of a kind and three of a kind, the player scores the sum of all the dice. For example, 1,1,2,2,2 placed on "full house" gives 8. 4,4,4,4,4 is not "full house".\u201d<\/p>\n<\/blockquote>\n

\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 1,1,2,2,2 placed on "full house" gives 8.“ () =   <\/p>\n

    Given (1,1,2,2,2)<\/p>\n

      |> When (placed_on FullHouse)<\/p>\n

      |> It should equal 8<\/p>\n

      |> Verify<\/p>\n

 <\/p>\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 4,4,4,4,4 placed on "full house" gives 0.“ () =   <\/p>\n

    Given (4,4,4,4,4)<\/p>\n

      |> When (placed_on FullHouse)<\/p>\n

      |> It should equal 0<\/p>\n

      |> Verify<\/p>\n

 <\/p>\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 1,1,2,3,2 placed on "full house" gives 0.“ () =   <\/p>\n

    Given (1,1,2,3,2)<\/p>\n

      |> When (placed_on FullHouse)<\/p>\n

      |> It should equal 0<\/p>\n

      |> Verify <\/p>\n<\/p><\/div>\n

Implementing the FullHouse category is easy if we reuse our solutions to the Two pairs category:<\/p>\n

\n

type<\/span> Category =<\/p>\n

| Ones<\/p>\n

  \/\/ …<\/span><\/p>\n

| FullHouse<\/p>\n

 <\/p>\n

let<\/span> takeBestCombo value1 value2 list =<\/p>\n

    allPairs<\/p>\n

        |> Seq.filter (fun<\/span> (a,b) -><\/span> a <> b)<\/p>\n

        |> Seq.map (fun<\/span> (a,b) -><\/span> <\/p>\n

            let<\/span> a’ = sumAsTuple value1 list a<\/p>\n

            let<\/span> b’ = sumAsTuple value2 list b<\/p>\n

            if<\/span> a’ = 0 || b’ = 0 then<\/span> 0 else<\/span> a’ + b’)<\/p>\n

        |> Seq.max<\/p>\n

 <\/p>\n

let<\/span> calcValue category roll =<\/p>\n

      \/\/ …<\/span><\/p>\n

    | TwoPair   -><\/span> takeBestCombo 2 2 list<\/p>\n

      \/\/ …<\/span><\/p>\n

    | FullHouse   -><\/span> takeBestCombo 2 3 list<\/p>\n<\/p><\/div>\n

Category 9 \u2013 Yahtzee<\/h5>\n
\n

\u201cYahtzee: If all dice are the have the same number, the player scores 50 points, otherwise 0.\u201d<\/p>\n<\/blockquote>\n

Here we can use NaturalSpec’s ScenarioTemplates in order to specify all Yahtzees:<\/p>\n

\n

[<ScenarioTemplate(1)>]<\/p>\n

[<ScenarioTemplate(2)>]<\/p>\n

[<ScenarioTemplate(3)>]<\/p>\n

[<ScenarioTemplate(4)>]<\/p>\n

[<ScenarioTemplate(5)>]<\/p>\n

[<ScenarioTemplate(6)>]<\/p>\n

let<\/span> “Given n,n,n,n,n placed on "Yahtzee" gives 50.“ n =   <\/p>\n

    Given (n,n,n,n,n)<\/p>\n

      |> When (placed_on Yahtzee)<\/p>\n

      |> It should equal 50<\/p>\n

      |> Verify<\/p>\n

 <\/p>\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 1,1,1,2,1 placed on "Yahtzee" gives 50.“ () =   <\/p>\n

    Given (1,1,1,2,1)<\/p>\n

      |> When (placed_on Yahtzee)<\/p>\n

      |> It should equal 0<\/p>\n

      |> Verify<\/p>\n<\/p><\/div>\n

The implementation is pretty easy:<\/p>\n

\n

type<\/span> Category =<\/p>\n

| Ones<\/p>\n

  \/\/ …<\/span><\/p>\n

| Yahtzee<\/p>\n

 <\/p>\n

let<\/span> calcValue category roll =<\/p>\n

      \/\/ …<\/span><\/p>\n

    | Yahtzee -><\/span> <\/p>\n

        let<\/span> a,b,c,d,e = roll<\/p>\n

        if<\/span> a = b && a = c && a = d && a = e then<\/span> 50 else<\/span> 0 <\/p>\n<\/p><\/div>\n

Category 10 \u2013 Chance<\/h5>\n
\n

\u201cChance: The player gets the sum of all dice, no matter what they read.\u201d<\/p>\n<\/blockquote>\n

\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 1,1,1,2,1 placed on "Chance" gives 6.“ () =   <\/p>\n

    Given (1,1,1,2,1)<\/p>\n

      |> When (placed_on Chance)<\/p>\n

      |> It should equal 6<\/p>\n

      |> Verify<\/p>\n

 <\/p>\n

[<Scenario>]     <\/p>\n

let<\/span> “Given 1,6,1,2,1 placed on "Chance" gives 11.“ () =   <\/p>\n

    Given (1,6,1,2,1)<\/p>\n

      |> When (placed_on Chance)<\/p>\n

      |> It should equal 11<\/p>\n

      |> Verify<\/p>\n<\/p><\/div>\n

This seems to be the easiest category as we only have to sum the values:<\/p>\n

\n

type<\/span> Category =<\/p>\n

| Ones<\/p>\n

  \/\/ …<\/span><\/p>\n

| Chance<\/p>\n

 <\/p>\n

let<\/span> calcValue category roll =<\/p>\n

      \/\/ …<\/span><\/p>\n

    | Chance -><\/span> List.sum list<\/p>\n<\/p><\/div>\n

Conclusion<\/h5>\n

We used a lot of F#\u2019s sequence combinators, pattern matching and discriminated unions in this kata. I think this shows that F# is very well suited for such a problem and with NaturalSpec we can easily use a TDD\/BDD approach.<\/p>\n

The complete source code can be found in the NaturalSpec repository<\/a>.<\/p>\n

If you want to know more about a specific part of the kata or NaturalSpec feel free to contact me.<\/p>\n","protected":false},"excerpt":{"rendered":"

Today I\u2019m starting a new blog post series about solving code katas in F# and with the help of my NaturalSpec project. A code kata is a programming exercise which helps to improve your skills through practice and repetition. In this series we want to use the Test Driven Development TDD approach which means in […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[448,8,586],"tags":[533,548,664,667,587,666,219,531],"_links":{"self":[{"href":"http:\/\/www.navision-blog.de\/blog\/wp-json\/wp\/v2\/posts\/962"}],"collection":[{"href":"http:\/\/www.navision-blog.de\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/www.navision-blog.de\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/www.navision-blog.de\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/www.navision-blog.de\/blog\/wp-json\/wp\/v2\/comments?post=962"}],"version-history":[{"count":0,"href":"http:\/\/www.navision-blog.de\/blog\/wp-json\/wp\/v2\/posts\/962\/revisions"}],"wp:attachment":[{"href":"http:\/\/www.navision-blog.de\/blog\/wp-json\/wp\/v2\/media?parent=962"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.navision-blog.de\/blog\/wp-json\/wp\/v2\/categories?post=962"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.navision-blog.de\/blog\/wp-json\/wp\/v2\/tags?post=962"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}