anchor.diff:          let lessThan3ofakind = Seq.groupBy id
                                  >> Seq.map (fun (x,s) -> x, s |> Seq.length)
                                  >> Seq.forall (fun (_,c) -> c < 3)
  +        // Using Common.AtLeastDistinct causes a stack overflow exception o.O
           Gen.listOfLength 6 NonScoringDie.Gen
           |> Arb.fromGen
           |> Arb.filter (fun r -> (r |> distinct4) && (r |> lessThan3ofakind))
  
positive.code:     [<InlineData(4)>]
      [<InlineData(5)>]
      [<InlineData(6)>]
      let ``Six of a kind should return 4 times the three of a kind points.`` n =
          let expected = (n |> ZonkKata.Roll.ThreeOfAKindPoints) * 4
          let actual = n |> ZonkKata.Roll.SixOfAKindPoints
          test <@ expected = actual @>
  
      [<Fact>]
      let ``A roll with three of a kind of twos and no more points should return 200 points.`` () =
          let expected = 200
          let actual = [2; 2; 2; 3; 4; 6] |> ZonkKata.Roll.CalculatePoints
          test <@ expected = actual @>
  
      [<Fact>]
      let ``A with three of a kind of twos and a one should return 300 points.`` () =
          let expected = 300
          let actual = [2; 2; 2; 1; 3; 4] |> ZonkKata.Roll.CalculatePoints
          test <@ expected = actual @>
  
      [<ThreeOfAKindWithNoMorePointsProperty>]
      let ``Three of a kind of die N and no more points should return three of a kind points for N.`` ((n : int), (roll : int list)) =
          let expected = n |> ZonkKata.Roll.ThreeOfAKindPoints
          let actual = roll |> ZonkKata.Roll.CalculatePoints
          test <@ expected = actual @>
  
      [<ThreeOfAKindWithExtraPointsProperty>]
      let ``Three of a kind of dice N which contain an extra one or five should return more than three of a kind point for N.`` ((n : int), (roll : int list)) =
          let expected = n |> ZonkKata.Roll.ThreeOfAKindPoints
          let actual = roll |> ZonkKata.Roll.CalculatePoints
          test <@ expected < actual @>
  
      [<ThreeOfAKindWithAnotherThreeOfAKindProperty>]
      let ``Three of a kind with another three of a kind should return the sum of the two three of a kind points.`` ((n : int, m : int, roll : int list)) =
          let expected = (n |> ZonkKata.Roll.ThreeOfAKindPoints) + (m |> ZonkKata.Roll.ThreeOfAKindPoints)
          let actual = roll |> ZonkKata.Roll.CalculatePoints
          test <@ expected = actual @>
  
      [<Fact>]
      let ``Four of a kind of ones should return 2000 points.`` () =
          let expected = 2000
          let actual = [1; 1; 1; 1; 2; 3] |> ZonkKata.Roll.CalculatePoints
          test <@ expected = actual @>
  
      [<FourOfAKindWithNoExtraPointsProperty>]
      let ``Four of a kind with no extra points should return two times the three of a kind points.`` (n : int, roll : int list) =
          let expected = 2 * (n |> ZonkKata.Roll.ThreeOfAKindPoints)
          let actual = roll |> ZonkKata.Roll.CalculatePoints
          test <@ expected = actual @>
  
      [<FourOfAKindWithExtraPointsProperty>]
      let ``Four of a kind with extra points should return more than the four of a kind points.`` (n : int, roll : int list) =
          let expected = n |> ZonkKata.Roll.FourOfAKindPoints
          let actual = roll |> ZonkKata.Roll.CalculatePoints
          test <@ expected < actual @>
  
      [<FiveOfAKindWithNoExtraPointsProperty>]
      let ``Five of a kind with no extra points should return three times the three of a kind points.`` (n : int, roll : int list) =
          let expected = 3 * (n |> ZonkKata.Roll.ThreeOfAKindPoints)
          let actual = roll |> ZonkKata.Roll.CalculatePoints
          test <@ expected = actual @>
  
      [<FiveOfAKindWithExtraPointsProperty>]
      let ``Five of a kind with extra points should return more than the five of a kind points.`` (n : int, roll : int list) =
          let expected = n |> ZonkKata.Roll.FiveOfAKindPoints
          let actual = roll |> ZonkKata.Roll.CalculatePoints
          test <@ expected < actual @>
  
      [<Theory>]
      [<InlineData(1)>]
      [<InlineData(2)>]
      [<InlineData(3)>]
      [<InlineData(4)>]
      [<InlineData(5)>]
      [<InlineData(6)>]
      let ``Six of a kind should return four times the three of a kind points.`` (n : int) =
          let expected = 4 * (n |> ZonkKata.Roll.ThreeOfAKindPoints)
          let actual = [n; n; n; n; n; n] |> ZonkKata.Roll.CalculatePoints
  
negative.code:         let actual = n |> ZonkKata.Roll.FiveOfAKindPoints
          test <@ expected = actual @>
  
      [<Fact>]
      let ``A roll with three of a kind of twos and no more points should return 200 points.`` () =
          let expected = 200
          let actual = [2; 2; 2; 3; 4; 6] |> ZonkKata.Roll.CalculatePoints
          test <@ expected = actual @>
  
      [<Fact>]
      let ``A with three of a kind of twos and a one should return 300 points.`` () =
          let expected = 300
          let actual = [2; 2; 2; 1; 3; 4] |> ZonkKata.Roll.CalculatePoints
          test <@ expected = actual @>
  
      [<ThreeOfAKindWithNoMorePointsProperty>]
      let ``Three of a kind of die N and no more points should return three of a kind points for N.`` ((n : int), (roll : int list)) =
          let expected = n |> ZonkKata.Roll.ThreeOfAKindPoints
          let actual = roll |> ZonkKata.Roll.CalculatePoints
          test <@ expected = actual @>
  
      [<ThreeOfAKindWithExtraPointsProperty>]
      let ``Three of a kind of dice N which contain an extra one or five should return more than three of a kind point for N.`` ((n : int), (roll : int list)) =
          let expected = n |> ZonkKata.Roll.ThreeOfAKindPoints
          let actual = roll |> ZonkKata.Roll.CalculatePoints
          test <@ expected < actual @>
  
      [<ThreeOfAKindWithAnotherThreeOfAKindProperty>]
      let ``Three of a kind with another three of a kind should return the sum of the two three of a kind points.`` ((n : int, m : int, roll : int list)) =
          let expected = (n |> ZonkKata.Roll.ThreeOfAKindPoints) + (m |> ZonkKata.Roll.ThreeOfAKindPoints)
          let actual = roll |> ZonkKata.Roll.CalculatePoints
          test <@ expected = actual @>
  
      [<Fact>]
      let ``Four of a kind of ones should return 2000 points.`` () =
          let expected = 2000
          let actual = [1; 1; 1; 1; 2; 3] |> ZonkKata.Roll.CalculatePoints
          test <@ expected = actual @>
  
      [<FourOfAKindWithNoExtraPointsProperty>]
      let ``Four of a kind with no extra points should return two times the three of a kind points.`` (n : int, roll : int list) =
          let expected = 2 * (n |> ZonkKata.Roll.ThreeOfAKindPoints)
          let actual = roll |> ZonkKata.Roll.CalculatePoints
          test <@ expected = actual @>
  
      [<FourOfAKindWithExtraPointsProperty>]
      let ``Four of a kind with extra points should return more than the four of a kind points.`` (n : int, roll : int list) =
          let expected = n |> ZonkKata.Roll.FourOfAKindPoints
          let actual = roll |> ZonkKata.Roll.CalculatePoints
          test <@ expected < actual @>
  
      [<FiveOfAKindWithNoExtraPointsProperty>]
      let ``Five of a kind with no extra points should return three times the three of a kind points.`` (n : int, roll : int list) =
          let expected = 3 * (n |> ZonkKata.Roll.ThreeOfAKindPoints)
          let actual = roll |> ZonkKata.Roll.CalculatePoints
          test <@ expected = actual @>
  
      [<FiveOfAKindWithExtraPointsProperty>]
      let ``Five of a kind with extra points should return more than the five of a kind points.`` (n : int, roll : int list) =
          let expected = n |> ZonkKata.Roll.FiveOfAKindPoints
          let actual = roll |> ZonkKata.Roll.CalculatePoints
          test <@ expected < actual @>
  
      [<Theory>]
      [<InlineData(1)>]
      [<InlineData(2)>]
  