trackler 2.2.1.105 → 2.2.1.106

data/tracks/fsharp/exercises/complex-numbers/ComplexNumbersTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.2.0 of the canonical data.
+// This file was auto-generated based on version 1.3.0 of the canonical data.
 
 module ComplexNumbersTest
 
@@ -166,3 +166,9 @@ let ``Exponential of a purely real number`` () =
     real sut |> should (equalWithin 0.000000001) Math.E
     imaginary sut |> should (equalWithin 0.000000001) 0.0
 
+[<Fact(Skip = "Remove to run test")>]
+let ``Exponential of a number with real and imaginary part`` () =
+    let sut = exp (create (Math.Log(2.0)) Math.PI)
+    real sut |> should (equalWithin 0.000000001) -2.0
+    imaginary sut |> should (equalWithin 0.000000001) 0.0
+

data/tracks/fsharp/exercises/react/ReactTest.fs

@@ -12,7 +12,6 @@ let ``Input cells have a value`` () =
     let reactor = new Reactor()
     let input = reactor.createInputCell 10
     input.Value |> should equal 10
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``An input cell's value can be set`` () =
@@ -20,7 +19,6 @@ let ``An input cell's value can be set`` () =
     let input = reactor.createInputCell 4
     input.Value <- 20
     input.Value |> should equal 20
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Compute cells calculate initial value`` () =
@@ -28,7 +26,6 @@ let ``Compute cells calculate initial value`` () =
     let input = reactor.createInputCell 1
     let output = reactor.createComputeCell [input] (fun values -> values.[0] + 1)
     output.Value |> should equal 2
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Compute cells take inputs in the right order`` () =
@@ -37,7 +34,6 @@ let ``Compute cells take inputs in the right order`` () =
     let two = reactor.createInputCell 2
     let output = reactor.createComputeCell [one; two] (fun values -> values.[0] + values.[1] * 10)
     output.Value |> should equal 21
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Compute cells update value when dependencies are changed`` () =
@@ -46,7 +42,6 @@ let ``Compute cells update value when dependencies are changed`` () =
     let output = reactor.createComputeCell [input] (fun values -> values.[0] + 1)
     input.Value <- 3
     output.Value |> should equal 4
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Compute cells can depend on other compute cells`` () =
@@ -58,7 +53,6 @@ let ``Compute cells can depend on other compute cells`` () =
     output.Value |> should equal 32
     input.Value <- 3
     output.Value |> should equal 96
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Compute cells fire callbacks`` () =
@@ -70,7 +64,6 @@ let ``Compute cells fire callbacks`` () =
     output.Changed.AddHandler callback1Handler
     input.Value <- 3
     callback1 |> should equal [4]
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Callback cells only fire on change`` () =
@@ -84,7 +77,6 @@ let ``Callback cells only fire on change`` () =
     callback1 |> should equal List.empty<int>
     input.Value <- 4
     callback1 |> should equal [222]
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Callbacks can be added and removed`` () =
@@ -106,7 +98,6 @@ let ``Callbacks can be added and removed`` () =
     callback1 |> should equal [32]
     callback2 |> should equal [32; 42]
     callback3 |> should equal [42]
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Removing a callback multiple times doesn't interfere with other callbacks`` () =
@@ -125,7 +116,6 @@ let ``Removing a callback multiple times doesn't interfere with other callbacks`
     input.Value <- 2
     callback1 |> should equal List.empty<int>
     callback2 |> should equal [3]
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Callbacks should only be called once even if multiple dependencies change`` () =
@@ -140,7 +130,6 @@ let ``Callbacks should only be called once even if multiple dependencies change`
     output.Changed.AddHandler callback1Handler
     input.Value <- 4
     callback1 |> should equal [10]
-    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Callbacks should not be called if dependencies change but output value doesn't change`` () =
@@ -157,5 +146,4 @@ let ``Callbacks should not be called if dependencies change but output value doe
     input.Value <- 4
     input.Value <- 5
     callback1 |> should equal List.empty<int>
-    
 

data/tracks/fsharp/exercises/scale-generator/Example.fs

@@ -11,13 +11,17 @@ let intervals = [('m', 1); ('M', 2); ('A', 3)] |> Map.ofList
 
 let skipInterval interval scale = List.skip (Map.find interval intervals) scale 
 
-let pitches tonic pattern = 
+let pitches tonic intervals = 
     let scale = if List.contains tonic flatKeys then flatChromaticScale else chromaticScale
     let index = List.findIndex (fun pitch -> String.Equals(pitch, tonic, StringComparison.InvariantCultureIgnoreCase)) scale
     let shiftedScale = shift index scale
-    
-    pattern 
-    |> List.ofSeq
-    |> List.fold (fun (acc, remainder) item -> (List.head remainder :: acc, skipInterval item remainder)) ([], shiftedScale)
-    |> fst
-    |> List.rev
+
+    match intervals with
+    | None -> 
+        shiftedScale
+    | Some x ->
+        x
+        |> List.ofSeq
+        |> List.fold (fun (acc, remainder) item -> (List.head remainder :: acc, skipInterval item remainder)) ([], shiftedScale)
+        |> fst
+        |> List.rev

data/tracks/fsharp/exercises/scale-generator/ScaleGenerator.fs

@@ -1,3 +1,3 @@
 module ScaleGenerator
 
-let pitches tonic pattern = failwith "You need to implement this function."
+let pitches tonic intervals = failwith "You need to implement this function."

data/tracks/fsharp/exercises/scale-generator/ScaleGeneratorTest.fs

@@ -1,92 +1,77 @@
-// This file was created manually and its version is 1.0.0.
+// This file was auto-generated based on version 1.0.0 of the canonical data.
 
 module ScaleGeneratorTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open ScaleGenerator
 
 [<Fact>]
-let ``Major scale`` () =
-    let major = pitches "C" "MMmMMMm"
-    let expected = ["C"; "D"; "E"; "F"; "G"; "A"; "B"]
-    major |> should equal expected
+let ``Chromatic scale with sharps`` () =
+    pitches "C" None |> should equal ["C"; "C#"; "D"; "D#"; "E"; "F"; "F#"; "G"; "G#"; "A"; "A#"; "B"]
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Chromatic scale with flats`` () =
+    pitches "F" None |> should equal ["F"; "Gb"; "G"; "Ab"; "A"; "Bb"; "B"; "C"; "Db"; "D"; "Eb"; "E"]
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Simple major scale`` () =
+    pitches "C" (Some "MMmMMMm") |> should equal ["C"; "D"; "E"; "F"; "G"; "A"; "B"]
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Another major scale`` () =
-    let major = pitches "G" "MMmMMMm"
-    let expected = ["G"; "A"; "B"; "C"; "D"; "E"; "F#"]
-    major |> should equal expected
+let ``Major scale with sharps`` () =
+    pitches "G" (Some "MMmMMMm") |> should equal ["G"; "A"; "B"; "C"; "D"; "E"; "F#"]
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Minor scale`` () =
-    let minor = pitches "f#" "MmMMmMM"
-    let expected = ["F#"; "G#"; "A"; "B"; "C#"; "D"; "E"]
-    minor |> should equal expected
+let ``Major scale with flats`` () =
+    pitches "F" (Some "MMmMMMm") |> should equal ["F"; "G"; "A"; "Bb"; "C"; "D"; "E"]
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Another minor scale`` () =
-    let minor = pitches "bb" "MmMMmMM"
-    let expected = ["Bb"; "C"; "Db"; "Eb"; "F"; "Gb"; "Ab"]
-    minor |> should equal expected
-    
+let ``Minor scale with sharps`` () =
+    pitches "f#" (Some "MmMMmMM") |> should equal ["F#"; "G#"; "A"; "B"; "C#"; "D"; "E"]
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Minor scale with flats`` () =
+    pitches "bb" (Some "MmMMmMM") |> should equal ["Bb"; "C"; "Db"; "Eb"; "F"; "Gb"; "Ab"]
+
 [<Fact(Skip = "Remove to run test")>]
 let ``Dorian mode`` () =
-    let dorian = pitches "d" "MmMMMmM"
-    let expected = ["D"; "E"; "F"; "G"; "A"; "B"; "C"]
-    dorian |> should equal expected
+    pitches "d" (Some "MmMMMmM") |> should equal ["D"; "E"; "F"; "G"; "A"; "B"; "C"]
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Mixolydian mode`` () =
-    let mixolydian = pitches "Eb" "MMmMMmM"
-    let expected = ["Eb"; "F"; "G"; "Ab"; "Bb"; "C"; "Db"]
-    mixolydian |> should equal expected
+    pitches "Eb" (Some "MMmMMmM") |> should equal ["Eb"; "F"; "G"; "Ab"; "Bb"; "C"; "Db"]
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Lydian mode`` () =
-    let lydian = pitches "a" "MMMmMMm"
-    let expected = ["A"; "B"; "C#"; "D#"; "E"; "F#"; "G#"]
-    lydian |> should equal expected
+    pitches "a" (Some "MMMmMMm") |> should equal ["A"; "B"; "C#"; "D#"; "E"; "F#"; "G#"]
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Phrygian mode`` () =
-    let phrygian = pitches "e" "mMMMmMM"
-    let expected = ["E"; "F"; "G"; "A"; "B"; "C"; "D"]
-    phrygian |> should equal expected
+    pitches "e" (Some "mMMMmMM") |> should equal ["E"; "F"; "G"; "A"; "B"; "C"; "D"]
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Locrian mode`` () =
-    let locrian = pitches "g" "mMMmMMM"
-    let expected = ["G"; "Ab"; "Bb"; "C"; "Db"; "Eb"; "F"]
-    locrian |> should equal expected
+    pitches "g" (Some "mMMmMMM") |> should equal ["G"; "Ab"; "Bb"; "C"; "Db"; "Eb"; "F"]
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Harmonic minor`` () =
-    let harmonicMinor = pitches "d" "MmMMmAm"
-    let expected = ["D"; "E"; "F"; "G"; "A"; "Bb"; "Db"]
-    harmonicMinor |> should equal expected
+    pitches "d" (Some "MmMMmAm") |> should equal ["D"; "E"; "F"; "G"; "A"; "Bb"; "Db"]
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Octatonic`` () =
-    let octatonic = pitches "C" "MmMmMmMm"
-    let expected = ["C"; "D"; "D#"; "F"; "F#"; "G#"; "A"; "B"]
-    octatonic |> should equal expected
+    pitches "C" (Some "MmMmMmMm") |> should equal ["C"; "D"; "D#"; "F"; "F#"; "G#"; "A"; "B"]
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Hexatonic`` () =
-    let hexatonic = pitches "Db" "MMMMMM"
-    let expected = ["Db"; "Eb"; "F"; "G"; "A"; "B"]
-    hexatonic |> should equal expected
+    pitches "Db" (Some "MMMMMM") |> should equal ["Db"; "Eb"; "F"; "G"; "A"; "B"]
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Pentatonic`` () =
-    let pentatonic = pitches "A" "MMAMA"
-    let expected = ["A"; "B"; "C#"; "E"; "F#"]
-    pentatonic |> should equal expected
+    pitches "A" (Some "MMAMA") |> should equal ["A"; "B"; "C#"; "E"; "F#"]
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Enigmatic`` () =
-    let enigmatic = pitches "G" "mAMMMmm"
-    let expected = ["G"; "G#"; "B"; "C#"; "D#"; "F"; "F#"]
-    enigmatic |> should equal expected
+    pitches "G" (Some "mAMMMmm") |> should equal ["G"; "G#"; "B"; "C#"; "D#"; "F"; "F#"]
+

data/tracks/fsharp/generators/Common.fs

@@ -12,7 +12,7 @@ type TestMethod =
 
 type TestMethodBody = 
     { Arrange: string list  
-      Assert: string }
+      Assert: string list }
 
 type TestMethodBodyAssert = 
     { Sut: string

data/tracks/fsharp/generators/Exercise.fs

@@ -56,7 +56,7 @@ type GeneratorExercise() =
     abstract member RenderExpected : CanonicalDataCase * string * obj -> string
     abstract member RenderInput : CanonicalDataCase * string * obj -> string
     abstract member RenderArrange : CanonicalDataCase -> string list
-    abstract member RenderAssert : CanonicalDataCase -> string
+    abstract member RenderAssert : CanonicalDataCase -> string list
     abstract member RenderSut : CanonicalDataCase -> string
     abstract member RenderSutParameters : CanonicalDataCase -> string list
     abstract member RenderSutParameter : CanonicalDataCase * string * obj -> string
@@ -252,7 +252,8 @@ type GeneratorExercise() =
 
         canonicalDataCase
         |> this.ToTestMethodBodyAssert
-        |> renderPartialTemplate template    
+        |> renderPartialTemplate template
+        |> List.singleton
 
     default this.RenderSut canonicalDataCase = 
         let parameters = this.RenderSutParameters canonicalDataCase

data/tracks/fsharp/generators/Generators.fs

@@ -26,24 +26,23 @@ type Allergies() =
 
     let toAllergen (jToken: JToken) =  sprintf "Allergen.%s" (jToken.ToString() |> String.humanize)
 
-    override this.RenderTestMethodBody canonicalDataCase =
-        if (canonicalDataCase.Property = "allergicTo") then
-            let renderAssertion (jToken: JToken) =
-                let updatedInput =
-                    canonicalDataCase.Input
-                    |> Map.add "substance" (jToken.["substance"] |> toAllergen |> box)
-
-                { canonicalDataCase with 
-                    Input = updatedInput
-                    Expected = jToken.["result"].ToObject<bool>() |> box }
-                |> this.RenderAssert
-                |> indent 1
+    let renderAllergicToAssert canonicalDataCase (jToken: JToken) =
+        let substance = jToken.["substance"] |> toAllergen
+        let score = canonicalDataCase.Input.["score"] :?> int64
+        let sut = sprintf "allergicTo %d %s" score substance
+        let expected = jToken.Value<bool>("result") |> formatBool
+        
+        { Sut = sut; Expected = expected }
+        |> renderPartialTemplate "AssertEqual"
 
+    override __.RenderAssert canonicalDataCase =
+        match canonicalDataCase.Property with
+        | "allergicTo" ->
             canonicalDataCase.Expected :?> JArray
-            |> Seq.map renderAssertion
-            |> String.concat "\n"
-        else
-            base.RenderTestMethodBody canonicalDataCase
+            |> Seq.map (renderAllergicToAssert canonicalDataCase)
+            |> Seq.toList
+        | _ -> 
+            base.RenderAssert canonicalDataCase
 
     override __.RenderExpected (canonicalDataCase, key, value) =     
         if (canonicalDataCase.Property = "list") then
@@ -118,6 +117,60 @@ type BinarySearch() =
         | _ ->
             base.RenderValueWithoutIdentifier (canonicalDataCase, key, value)
 
+type BinarySearchTree() =
+    inherit GeneratorExercise()
+
+    let rec renderAssertions previousPaths (tree: JObject) =
+        let previousPath = previousPaths |> List.rev |> String.concat " |> "
+        let rootPath = List.length previousPaths = 1
+
+        let renderDataAssertions =
+            let dataPath = if rootPath then "data" else "Option.map data"
+            let data = tree.["data"]
+
+            match data.Type with
+            | JTokenType.Null -> 
+                let expected = if rootPath then failwith "Invalid data" else "None"
+                [ sprintf "%s |> %s |> should equal %s" previousPath dataPath expected ]
+            | _ -> 
+                let data = (data :?> JValue).ToObject<int>()
+                let expected = if rootPath then string data else sprintf "(Some %d)" data
+                [ sprintf "%s |> %s |> should equal %s" previousPath dataPath expected ]
+
+        let renderNodeAssertions nodeName (node: JToken) = 
+            let nodePath = if rootPath then nodeName else sprintf "Option.bind %s" nodeName
+
+            match node.Type with
+            | JTokenType.Null -> 
+                [ sprintf "%s |> %s |> should equal None" previousPath nodePath ]
+            | _ ->
+                renderAssertions (nodePath :: previousPaths) (node :?> JObject)            
+
+        [ renderDataAssertions
+          renderNodeAssertions "left" tree.["left"] 
+          renderNodeAssertions "right" tree.["right"] ]
+        |> List.concat
+
+    override __.RenderAssert canonicalDataCase = 
+        match canonicalDataCase.Property with
+        | "data" ->
+            canonicalDataCase.Expected :?> JObject
+            |> renderAssertions ["treeData"]
+        | _ -> base.RenderAssert canonicalDataCase
+
+    override __.RenderInput (_, _, value) = 
+        value :?> JArray
+        |> Seq.map string
+        |> formatList
+        |> sprintf "create %s"
+
+    override __.RenderExpected (canonicalDataCase, key, value) = 
+        match value with
+        | :? JArray as jArray -> jArray |> Seq.map string |> formatList
+        | _ -> base.RenderExpected (canonicalDataCase, key, value)
+
+    override this.PropertiesWithIdentifier canonicalDataCase = this.PropertiesUsedAsSutParameter canonicalDataCase
+
 type Bob() =
     inherit GeneratorExercise()
 
@@ -136,7 +189,7 @@ type Bowling() =
 
     override __.RenderSut _ ="score game"
 
-    override __.RenderSetup canonicalDataCase = 
+    override __.RenderSetup _ = 
         "let rollMany rolls game = List.fold (fun game pins -> roll pins game) game rolls"
 
     override __.RenderArrange canonicalDataCase =
@@ -180,7 +233,7 @@ type CircularBuffer() =
 
     override __.AdditionalNamespaces = [ "System" ]
 
-    override __.RenderAssert _ = ""
+    override __.RenderAssert _ = []
 
     member __.ExceptionCheck command = 
         sprintf "(fun () -> %s |> ignore) |> should throw typeof<Exception>" command 
@@ -273,10 +326,11 @@ type ComplexNumbers() =
 
     let renderNumber (input: JToken) =
         match string input with
-        | "e"  -> "Math.E"
-        | "pi" -> "Math.PI"
-        | int when int.IndexOf('.') = -1  -> sprintf "%s.0" int
-        | float -> float
+        | "e"     -> "Math.E"
+        | "pi"    -> "Math.PI"
+        | "ln(2)" -> "(Math.Log(2.0))"
+        | i when i.IndexOf('.') = -1  -> sprintf "%s.0" i
+        | float   -> float
     
     let renderComplexNumber (input: JArray) =
         sprintf "(create %s %s)" (renderNumber input.[0]) (renderNumber input.[1])
@@ -294,9 +348,8 @@ type ComplexNumbers() =
                 { Sut = sprintf "%s sut" testedFunction; Expected = expected }
                 |> renderPartialTemplate "AssertEqualWithin"
 
-            [ renderAssertion "real" (renderNumber jArray.[0]) 
-              renderAssertion "imaginary" (renderNumber jArray.[1]) |> indent 1 ]
-            |> String.concat "\n"
+            [ jArray.[0] |> renderNumber |> renderAssertion "real"
+              jArray.[1] |> renderNumber |> renderAssertion "imaginary" ]
         | _ ->
             base.RenderAssert(canonicalDataCase)
 
@@ -1012,10 +1065,7 @@ type React() =
         )
         |> Seq.toList
 
-    override __.RenderAssert _ = 
-        // skip this method 
-        // because for this task we have multiple assert statements
-        ""
+    override __.RenderAssert _ = []
 
     override this.RenderArrange canonicalDataCase =
         let initialVars = this.RenderCells canonicalDataCase
@@ -1157,6 +1207,22 @@ type Say() =
 
     override __.RenderInput (_, _, value) = sprintf "%sL" (string value)
 
+type ScaleGenerator() =
+    inherit GeneratorExercise()
+
+    override __.MapCanonicalDataCaseInput (canonicalDataCase, properties) =
+        let input = base.MapCanonicalDataCaseInput (canonicalDataCase, properties)
+        match Map.tryFind "intervals" input with
+        | Some _ -> input
+        | None   -> Map.add "intervals" null input
+
+    override __.RenderInput (canonicalDataCase, key, value) =
+        match key with 
+        | "intervals" -> value |> Option.ofObj |> formatValue |> parenthesizeOption
+        | _ -> base.RenderInput (canonicalDataCase, key, value)
+
+    override __.PropertiesUsedAsSutParameter _ = ["tonic"; "intervals"]
+
 type ScrabbleScore() =
     inherit GeneratorExercise()
 

data/tracks/fsharp/generators/Templates/_TestFunction.liquid

@@ -1,3 +1,3 @@
 [<Fact{% if Skip %}(Skip = "Remove to run test"){% endif %}>]
 let ``{{ Name }}`` () =
-{{ Body }}
+{{ Body }}

data/tracks/fsharp/generators/Templates/_TestFunctionBody.liquid

@@ -1,4 +1,6 @@
 {%- for arrange in Arrange -%}
 {{ arrange | indent }}
 {%- endfor -%}
-{{ Assert | indent }}
+{%- for assert in Assert -%}
+{{ assert | indent }}
+{%- endfor -%}

data/tracks/fsharp/generators/Templates/_TestMember.liquid

@@ -1,3 +1,3 @@
 [<Fact{% if Skip %}(Skip = "Remove to run test"){% endif %}>]
     member this.``{{ Name }}`` () =
-{{ Body }}
+{{ Body }}

data/tracks/fsharp/generators/Templates/_TestMemberBody.liquid

@@ -1,4 +1,6 @@
 {%- for arrange in Arrange -%}
 {{ arrange | indent | indent }}
 {%- endfor -%}
-{{ Assert | indent | indent }}
+{%- for assert in Assert -%}
+{{ assert | indent | indent }}
+{%- endfor -%}

data/tracks/go/exercises/simple-linked-list/linked_list_test.go

@@ -165,10 +165,9 @@ func BenchmarkNewList(b *testing.B) {
 }
 
 func BenchmarkListSize(b *testing.B) {
+	list := New(array1To10)
+	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		b.StopTimer()
-		list := New(array1To10)
-		b.StartTimer()
 		_ = list.Size()
 	}
 }
@@ -176,35 +175,40 @@ func BenchmarkListSize(b *testing.B) {
 func BenchmarkListPush(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		b.StopTimer()
-		list := New(array1To10)
+		list := New([]int{})
 		b.StartTimer()
-		list.Push(11)
+		for k := 0; k < 1000; k++ {
+			list.Push(k)
+		}
 	}
 }
 
 func BenchmarkListPop(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		b.StopTimer()
-		list := New(array1To10)
+		list := New([]int{})
+		for k := 0; k < 1000; k++ {
+			list.Push(k)
+		}
 		b.StartTimer()
-		_, _ = list.Pop()
+		for k := 0; k < 1000; k++ {
+			_, _ = list.Pop()
+		}
 	}
 }
 
 func BenchmarkListToArray(b *testing.B) {
+	list := New(array1To10)
+	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		b.StopTimer()
-		list := New(array1To10)
-		b.StartTimer()
 		_ = list.Array()
 	}
 }
 
 func BenchmarkListReverse(b *testing.B) {
+	list := New(array1To10)
+	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		b.StopTimer()
-		list := New(array1To10)
-		b.StartTimer()
 		_ = list.Reverse()
 	}
 }

data/tracks/haskell/config.json

@@ -314,6 +314,16 @@
       "topics": [
       ]
     },
+    {
+      "uuid": "f750e380-fe16-42c0-8b3d-8acd7e443a6e",
+      "slug": "protein-translation",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 3,
+      "topics": [
+        "Maybe"
+      ]
+    },
     {
       "uuid": "67c53230-82e8-4207-a811-abec27bef381",
       "slug": "anagram",

data/tracks/haskell/exercises/all-your-base/package.yaml

@@ -1,5 +1,5 @@
 name: all-your-base
-version: 2.1.0.6
+version: 2.3.0.7
 
 dependencies:
   - base

data/tracks/haskell/exercises/all-your-base/test/Tests.hs

@@ -104,7 +104,7 @@ cases = [ Case { description  = "single bit one to decimal"
                }
         , Case { description  = "input base is one"
                , inputBase    = 1
-               , inputDigits  = []
+               , inputDigits  = [0]
                , outputBase   = 10
                , outputDigits = Nothing
                }

data/tracks/haskell/exercises/bowling/package.yaml

@@ -1,5 +1,5 @@
 name: bowling
-version: 1.1.0.5
+version: 1.2.0.6
 
 dependencies:
   - base

data/tracks/haskell/exercises/bowling/test/Tests.hs

@@ -136,5 +136,13 @@ cases = [ Case { description = "should be able to score a game with all zeros"
                , rolls       = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3]
                , expected    = Left IncompleteGame
                }
+        , Case { description = "cannot roll after bonus roll for spare"
+               , rolls       = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 2, 2]
+               , expected    = Left $ InvalidRoll 21 2
+               }
+        , Case { description = "cannot roll after bonus rolls for strike"
+               , rolls       = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 3, 2, 2]
+               , expected    = Left $ InvalidRoll 21 2
+               }
         ]
 

data/tracks/haskell/exercises/complex-numbers/package.yaml

@@ -1,5 +1,5 @@
 name: complex-numbers
-version: 1.2.0.2
+version: 1.3.0.3
 
 dependencies:
   - base

data/tracks/haskell/exercises/diamond/examples/success-standard/src/Diamond.hs

@@ -9,8 +9,8 @@ oneRow :: Char -> (Int, Int) -> String
 oneRow c (0, y) = pad y ++ [c] ++ pad y
 oneRow c (x, y) = pad y ++ [c] ++ pad x ++ [c] ++ pad y
 
-diamond :: Char -> [String]
-diamond = (\x -> x ++ tail (reverse x)) . mkTop . subtract 64 . ord
+diamond :: Char -> Maybe [String]
+diamond = Just . (\x -> x ++ tail (reverse x)) . mkTop . subtract 64 . ord
   where rows x = zip (0 : take (x-1) [1, 3..]) [x-1, x-2..0]
         mkTop  = zipWith oneRow abc . rows
         abc    = map chr [65..90]

data/tracks/haskell/exercises/diamond/package.yaml

@@ -1,5 +1,5 @@
 name: diamond
-version: 1.1.0.2
+version: 1.1.0.3
 
 dependencies:
   - base