trackler 2.2.1.138 → 2.2.1.139

data/tracks/fsharp/exercises/robot-simulator/RobotSimulatorTest.fs

@@ -9,121 +9,121 @@ open RobotSimulator
 
 [<Fact>]
 let ``Robots are created with a position and direction`` () =
-    let robot = create North (0, 0)
-    let expected = create North (0, 0)
+    let robot = create Direction.North (0, 0)
+    let expected = create Direction.North (0, 0)
     robot |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Negative positions are allowed`` () =
-    let robot = create South (-1, -1)
-    let expected = create South (-1, -1)
+    let robot = create Direction.South (-1, -1)
+    let expected = create Direction.South (-1, -1)
     robot |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``turnRight does not change the position`` () =
-    let robot = create North (0, 0)
+    let robot = create Direction.North (0, 0)
     let sut = turnRight robot
     sut.position |> should equal (0, 0)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``turnRight changes the direction from north to east`` () =
-    let robot = create North (0, 0)
+    let robot = create Direction.North (0, 0)
     let sut = turnRight robot
-    sut.direction |> should equal East
+    sut.direction |> should equal Direction.East
 
 [<Fact(Skip = "Remove to run test")>]
 let ``turnRight changes the direction from east to south`` () =
-    let robot = create East (0, 0)
+    let robot = create Direction.East (0, 0)
     let sut = turnRight robot
-    sut.direction |> should equal South
+    sut.direction |> should equal Direction.South
 
 [<Fact(Skip = "Remove to run test")>]
 let ``turnRight changes the direction from south to west`` () =
-    let robot = create South (0, 0)
+    let robot = create Direction.South (0, 0)
     let sut = turnRight robot
-    sut.direction |> should equal West
+    sut.direction |> should equal Direction.West
 
 [<Fact(Skip = "Remove to run test")>]
 let ``turnRight changes the direction from west to north`` () =
-    let robot = create West (0, 0)
+    let robot = create Direction.West (0, 0)
     let sut = turnRight robot
-    sut.direction |> should equal North
+    sut.direction |> should equal Direction.North
 
 [<Fact(Skip = "Remove to run test")>]
 let ``turnLeft does not change the position`` () =
-    let robot = create North (0, 0)
+    let robot = create Direction.North (0, 0)
     let sut = turnLeft robot
     sut.position |> should equal (0, 0)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``turnLeft changes the direction from north to west`` () =
-    let robot = create North (0, 0)
+    let robot = create Direction.North (0, 0)
     let sut = turnLeft robot
-    sut.direction |> should equal West
+    sut.direction |> should equal Direction.West
 
 [<Fact(Skip = "Remove to run test")>]
 let ``turnLeft changes the direction from west to south`` () =
-    let robot = create West (0, 0)
+    let robot = create Direction.West (0, 0)
     let sut = turnLeft robot
-    sut.direction |> should equal South
+    sut.direction |> should equal Direction.South
 
 [<Fact(Skip = "Remove to run test")>]
 let ``turnLeft changes the direction from south to east`` () =
-    let robot = create South (0, 0)
+    let robot = create Direction.South (0, 0)
     let sut = turnLeft robot
-    sut.direction |> should equal East
+    sut.direction |> should equal Direction.East
 
 [<Fact(Skip = "Remove to run test")>]
 let ``turnLeft changes the direction from east to north`` () =
-    let robot = create East (0, 0)
+    let robot = create Direction.East (0, 0)
     let sut = turnLeft robot
-    sut.direction |> should equal North
+    sut.direction |> should equal Direction.North
 
 [<Fact(Skip = "Remove to run test")>]
 let ``advance does not change the direction`` () =
-    let robot = create North (0, 0)
+    let robot = create Direction.North (0, 0)
     let sut = advance robot
-    sut.direction |> should equal North
+    sut.direction |> should equal Direction.North
 
 [<Fact(Skip = "Remove to run test")>]
 let ``advance increases the y coordinate one when facing north`` () =
-    let robot = create North (0, 0)
+    let robot = create Direction.North (0, 0)
     let sut = advance robot
     sut.position |> should equal (0, 1)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``advance decreases the y coordinate by one when facing south`` () =
-    let robot = create South (0, 0)
+    let robot = create Direction.South (0, 0)
     let sut = advance robot
     sut.position |> should equal (0, -1)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``advance increases the x coordinate by one when facing east`` () =
-    let robot = create East (0, 0)
+    let robot = create Direction.East (0, 0)
     let sut = advance robot
     sut.position |> should equal (1, 0)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``advance decreases the x coordinate by one when facing west`` () =
-    let robot = create West (0, 0)
+    let robot = create Direction.West (0, 0)
     let sut = advance robot
     sut.position |> should equal (-1, 0)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Instructions to move west and north`` () =
-    let robot = create North (0, 0)
-    let expected = create West (-4, 1)
+    let robot = create Direction.North (0, 0)
+    let expected = create Direction.West (-4, 1)
     instructions "LAAARALA" robot |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Instructions to move west and south`` () =
-    let robot = create East (2, -7)
-    let expected = create South (-3, -8)
+    let robot = create Direction.East (2, -7)
+    let expected = create Direction.South (-3, -8)
     instructions "RRAAAAALA" robot |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Instructions to move east and north`` () =
-    let robot = create South (8, 4)
-    let expected = create North (11, 5)
+    let robot = create Direction.South (8, 4)
+    let expected = create Direction.North (11, 5)
     instructions "LAAARRRALLLL" robot |> should equal expected
 

data/tracks/fsharp/exercises/sublist/Example.fs

@@ -1,6 +1,6 @@
 module Sublist
 
-type Sublist = Equal | Sublist | Superlist | Unequal
+type SublistType = Equal | Sublist | Superlist | Unequal
 
 let rec isSublist xs ys lx ly = 
     let rec helper xs' ys' =

data/tracks/fsharp/exercises/sublist/Sublist.fs

@@ -1,5 +1,5 @@
 module Sublist
 
-type Sublist = Equal | Sublist | Superlist | Unequal
+type SublistType = Equal | Sublist | Superlist | Unequal
 
 let sublist xs ys = failwith "You need to implement this function."

data/tracks/fsharp/exercises/sublist/SublistTest.fs

@@ -11,101 +11,101 @@ open Sublist
 let ``Empty lists`` () =
     let listOne = []
     let listTwo = []
-    sublist listOne listTwo |> should equal Equal
+    sublist listOne listTwo |> should equal SublistType.Equal
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Empty list within non empty list`` () =
     let listOne = []
     let listTwo = [1; 2; 3]
-    sublist listOne listTwo |> should equal Sublist
+    sublist listOne listTwo |> should equal SublistType.Sublist
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Non empty list contains empty list`` () =
     let listOne = [1; 2; 3]
     let listTwo = []
-    sublist listOne listTwo |> should equal Superlist
+    sublist listOne listTwo |> should equal SublistType.Superlist
 
 [<Fact(Skip = "Remove to run test")>]
 let ``List equals itself`` () =
     let listOne = [1; 2; 3]
     let listTwo = [1; 2; 3]
-    sublist listOne listTwo |> should equal Equal
+    sublist listOne listTwo |> should equal SublistType.Equal
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Different lists`` () =
     let listOne = [1; 2; 3]
     let listTwo = [2; 3; 4]
-    sublist listOne listTwo |> should equal Unequal
+    sublist listOne listTwo |> should equal SublistType.Unequal
 
 [<Fact(Skip = "Remove to run test")>]
 let ``False start`` () =
     let listOne = [1; 2; 5]
     let listTwo = [0; 1; 2; 3; 1; 2; 5; 6]
-    sublist listOne listTwo |> should equal Sublist
+    sublist listOne listTwo |> should equal SublistType.Sublist
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Consecutive`` () =
     let listOne = [1; 1; 2]
     let listTwo = [0; 1; 1; 1; 2; 1; 2]
-    sublist listOne listTwo |> should equal Sublist
+    sublist listOne listTwo |> should equal SublistType.Sublist
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Sublist at start`` () =
     let listOne = [0; 1; 2]
     let listTwo = [0; 1; 2; 3; 4; 5]
-    sublist listOne listTwo |> should equal Sublist
+    sublist listOne listTwo |> should equal SublistType.Sublist
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Sublist in middle`` () =
     let listOne = [2; 3; 4]
     let listTwo = [0; 1; 2; 3; 4; 5]
-    sublist listOne listTwo |> should equal Sublist
+    sublist listOne listTwo |> should equal SublistType.Sublist
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Sublist at end`` () =
     let listOne = [3; 4; 5]
     let listTwo = [0; 1; 2; 3; 4; 5]
-    sublist listOne listTwo |> should equal Sublist
+    sublist listOne listTwo |> should equal SublistType.Sublist
 
 [<Fact(Skip = "Remove to run test")>]
 let ``At start of superlist`` () =
     let listOne = [0; 1; 2; 3; 4; 5]
     let listTwo = [0; 1; 2]
-    sublist listOne listTwo |> should equal Superlist
+    sublist listOne listTwo |> should equal SublistType.Superlist
 
 [<Fact(Skip = "Remove to run test")>]
 let ``In middle of superlist`` () =
     let listOne = [0; 1; 2; 3; 4; 5]
     let listTwo = [2; 3]
-    sublist listOne listTwo |> should equal Superlist
+    sublist listOne listTwo |> should equal SublistType.Superlist
 
 [<Fact(Skip = "Remove to run test")>]
 let ``At end of superlist`` () =
     let listOne = [0; 1; 2; 3; 4; 5]
     let listTwo = [3; 4; 5]
-    sublist listOne listTwo |> should equal Superlist
+    sublist listOne listTwo |> should equal SublistType.Superlist
 
 [<Fact(Skip = "Remove to run test")>]
 let ``First list missing element from second list`` () =
     let listOne = [1; 3]
     let listTwo = [1; 2; 3]
-    sublist listOne listTwo |> should equal Unequal
+    sublist listOne listTwo |> should equal SublistType.Unequal
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second list missing element from first list`` () =
     let listOne = [1; 2; 3]
     let listTwo = [1; 3]
-    sublist listOne listTwo |> should equal Unequal
+    sublist listOne listTwo |> should equal SublistType.Unequal
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Order matters to a list`` () =
     let listOne = [1; 2; 3]
     let listTwo = [3; 2; 1]
-    sublist listOne listTwo |> should equal Unequal
+    sublist listOne listTwo |> should equal SublistType.Unequal
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Same digits but different numbers`` () =
     let listOne = [1; 0; 1]
     let listTwo = [10; 1]
-    sublist listOne listTwo |> should equal Unequal
+    sublist listOne listTwo |> should equal SublistType.Unequal
 

data/tracks/fsharp/exercises/word-search/WordSearchTest.fs

@@ -18,28 +18,28 @@ let ``Should accept an initial game grid and a target search word`` () =
 let ``Should locate one word written left to right`` () =
     let grid = ["clojurermt"]
     let wordsToSearchFor = ["clojure"]
-    let expected = [("clojure", Some (((1, 1), (7, 1))))] |> Map.ofList
+    let expected = [("clojure", Some ((1, 1), (7, 1)))] |> Map.ofList
     search grid wordsToSearchFor |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Should locate the same word written left to right in a different position`` () =
     let grid = ["mtclojurer"]
     let wordsToSearchFor = ["clojure"]
-    let expected = [("clojure", Some (((3, 1), (9, 1))))] |> Map.ofList
+    let expected = [("clojure", Some ((3, 1), (9, 1)))] |> Map.ofList
     search grid wordsToSearchFor |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Should locate a different left to right word`` () =
     let grid = ["coffeelplx"]
     let wordsToSearchFor = ["coffee"]
-    let expected = [("coffee", Some (((1, 1), (6, 1))))] |> Map.ofList
+    let expected = [("coffee", Some ((1, 1), (6, 1)))] |> Map.ofList
     search grid wordsToSearchFor |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Should locate that different left to right word in a different position`` () =
     let grid = ["xcoffeezlp"]
     let wordsToSearchFor = ["coffee"]
-    let expected = [("coffee", Some (((2, 1), (7, 1))))] |> Map.ofList
+    let expected = [("coffee", Some ((2, 1), (7, 1)))] |> Map.ofList
     search grid wordsToSearchFor |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
@@ -48,7 +48,7 @@ let ``Should locate a left to right word in two line grid`` () =
         [ "jefblpepre";
           "tclojurerm" ]
     let wordsToSearchFor = ["clojure"]
-    let expected = [("clojure", Some (((2, 2), (8, 2))))] |> Map.ofList
+    let expected = [("clojure", Some ((2, 2), (8, 2)))] |> Map.ofList
     search grid wordsToSearchFor |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
@@ -58,7 +58,7 @@ let ``Should locate a left to right word in three line grid`` () =
           "jefblpepre";
           "clojurermt" ]
     let wordsToSearchFor = ["clojure"]
-    let expected = [("clojure", Some (((1, 3), (7, 3))))] |> Map.ofList
+    let expected = [("clojure", Some ((1, 3), (7, 3)))] |> Map.ofList
     search grid wordsToSearchFor |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
@@ -75,7 +75,7 @@ let ``Should locate a left to right word in ten line grid`` () =
           "jalaycalmp";
           "clojurermt" ]
     let wordsToSearchFor = ["clojure"]
-    let expected = [("clojure", Some (((1, 10), (7, 10))))] |> Map.ofList
+    let expected = [("clojure", Some ((1, 10), (7, 10)))] |> Map.ofList
     search grid wordsToSearchFor |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
@@ -92,7 +92,7 @@ let ``Should locate that left to right word in a different position in a ten lin
           "clojurermt";
           "jalaycalmp" ]
     let wordsToSearchFor = ["clojure"]
-    let expected = [("clojure", Some (((1, 9), (7, 9))))] |> Map.ofList
+    let expected = [("clojure", Some ((1, 9), (7, 9)))] |> Map.ofList
     search grid wordsToSearchFor |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
@@ -109,7 +109,7 @@ let ``Should locate a different left to right word in a ten line grid`` () =
           "clojurermt";
           "jalaycalmp" ]
     let wordsToSearchFor = ["fortran"]
-    let expected = [("fortran", Some (((1, 7), (7, 7))))] |> Map.ofList
+    let expected = [("fortran", Some ((1, 7), (7, 7)))] |> Map.ofList
     search grid wordsToSearchFor |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
@@ -127,8 +127,8 @@ let ``Should locate multiple words`` () =
           "clojurermt" ]
     let wordsToSearchFor = ["fortran"; "clojure"]
     let expected = 
-        [ ("clojure", Some (((1, 10), (7, 10))));
-          ("fortran", Some (((1, 7), (7, 7)))) ]
+        [ ("clojure", Some ((1, 10), (7, 10)));
+          ("fortran", Some ((1, 7), (7, 7))) ]
         |> Map.ofList
     search grid wordsToSearchFor |> should equal expected
 
@@ -136,7 +136,7 @@ let ``Should locate multiple words`` () =
 let ``Should locate a single word written right to left`` () =
     let grid = ["rixilelhrs"]
     let wordsToSearchFor = ["elixir"]
-    let expected = [("elixir", Some (((6, 1), (1, 1))))] |> Map.ofList
+    let expected = [("elixir", Some ((6, 1), (1, 1)))] |> Map.ofList
     search grid wordsToSearchFor |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
@@ -154,8 +154,8 @@ let ``Should locate multiple words written in different horizontal directions``
           "clojurermt" ]
     let wordsToSearchFor = ["elixir"; "clojure"]
     let expected = 
-        [ ("clojure", Some (((1, 10), (7, 10))));
-          ("elixir", Some (((6, 5), (1, 5)))) ]
+        [ ("clojure", Some ((1, 10), (7, 10)));
+          ("elixir", Some ((6, 5), (1, 5))) ]
         |> Map.ofList
     search grid wordsToSearchFor |> should equal expected
 
@@ -174,9 +174,9 @@ let ``Should locate words written top to bottom`` () =
           "clojurermt" ]
     let wordsToSearchFor = ["clojure"; "elixir"; "ecmascript"]
     let expected = 
-        [ ("clojure", Some (((1, 10), (7, 10))));
-          ("elixir", Some (((6, 5), (1, 5))));
-          ("ecmascript", Some (((10, 1), (10, 10)))) ]
+        [ ("clojure", Some ((1, 10), (7, 10)));
+          ("elixir", Some ((6, 5), (1, 5)));
+          ("ecmascript", Some ((10, 1), (10, 10))) ]
         |> Map.ofList
     search grid wordsToSearchFor |> should equal expected
 
@@ -195,10 +195,10 @@ let ``Should locate words written bottom to top`` () =
           "clojurermt" ]
     let wordsToSearchFor = ["clojure"; "elixir"; "ecmascript"; "rust"]
     let expected = 
-        [ ("clojure", Some (((1, 10), (7, 10))));
-          ("elixir", Some (((6, 5), (1, 5))));
-          ("ecmascript", Some (((10, 1), (10, 10))));
-          ("rust", Some (((9, 5), (9, 2)))) ]
+        [ ("clojure", Some ((1, 10), (7, 10)));
+          ("elixir", Some ((6, 5), (1, 5)));
+          ("ecmascript", Some ((10, 1), (10, 10)));
+          ("rust", Some ((9, 5), (9, 2))) ]
         |> Map.ofList
     search grid wordsToSearchFor |> should equal expected
 
@@ -217,11 +217,11 @@ let ``Should locate words written top left to bottom right`` () =
           "clojurermt" ]
     let wordsToSearchFor = ["clojure"; "elixir"; "ecmascript"; "rust"; "java"]
     let expected = 
-        [ ("clojure", Some (((1, 10), (7, 10))));
-          ("elixir", Some (((6, 5), (1, 5))));
-          ("ecmascript", Some (((10, 1), (10, 10))));
-          ("rust", Some (((9, 5), (9, 2))));
-          ("java", Some (((1, 1), (4, 4)))) ]
+        [ ("clojure", Some ((1, 10), (7, 10)));
+          ("elixir", Some ((6, 5), (1, 5)));
+          ("ecmascript", Some ((10, 1), (10, 10)));
+          ("rust", Some ((9, 5), (9, 2)));
+          ("java", Some ((1, 1), (4, 4))) ]
         |> Map.ofList
     search grid wordsToSearchFor |> should equal expected
 
@@ -240,12 +240,12 @@ let ``Should locate words written bottom right to top left`` () =
           "clojurermt" ]
     let wordsToSearchFor = ["clojure"; "elixir"; "ecmascript"; "rust"; "java"; "lua"]
     let expected = 
-        [ ("clojure", Some (((1, 10), (7, 10))));
-          ("elixir", Some (((6, 5), (1, 5))));
-          ("ecmascript", Some (((10, 1), (10, 10))));
-          ("rust", Some (((9, 5), (9, 2))));
-          ("java", Some (((1, 1), (4, 4))));
-          ("lua", Some (((8, 9), (6, 7)))) ]
+        [ ("clojure", Some ((1, 10), (7, 10)));
+          ("elixir", Some ((6, 5), (1, 5)));
+          ("ecmascript", Some ((10, 1), (10, 10)));
+          ("rust", Some ((9, 5), (9, 2)));
+          ("java", Some ((1, 1), (4, 4)));
+          ("lua", Some ((8, 9), (6, 7))) ]
         |> Map.ofList
     search grid wordsToSearchFor |> should equal expected
 
@@ -264,13 +264,13 @@ let ``Should locate words written bottom left to top right`` () =
           "clojurermt" ]
     let wordsToSearchFor = ["clojure"; "elixir"; "ecmascript"; "rust"; "java"; "lua"; "lisp"]
     let expected = 
-        [ ("clojure", Some (((1, 10), (7, 10))));
-          ("elixir", Some (((6, 5), (1, 5))));
-          ("ecmascript", Some (((10, 1), (10, 10))));
-          ("rust", Some (((9, 5), (9, 2))));
-          ("java", Some (((1, 1), (4, 4))));
-          ("lua", Some (((8, 9), (6, 7))));
-          ("lisp", Some (((3, 6), (6, 3)))) ]
+        [ ("clojure", Some ((1, 10), (7, 10)));
+          ("elixir", Some ((6, 5), (1, 5)));
+          ("ecmascript", Some ((10, 1), (10, 10)));
+          ("rust", Some ((9, 5), (9, 2)));
+          ("java", Some ((1, 1), (4, 4)));
+          ("lua", Some ((8, 9), (6, 7)));
+          ("lisp", Some ((3, 6), (6, 3))) ]
         |> Map.ofList
     search grid wordsToSearchFor |> should equal expected
 
@@ -289,14 +289,14 @@ let ``Should locate words written top right to bottom left`` () =
           "clojurermt" ]
     let wordsToSearchFor = ["clojure"; "elixir"; "ecmascript"; "rust"; "java"; "lua"; "lisp"; "ruby"]
     let expected = 
-        [ ("clojure", Some (((1, 10), (7, 10))));
-          ("elixir", Some (((6, 5), (1, 5))));
-          ("ecmascript", Some (((10, 1), (10, 10))));
-          ("rust", Some (((9, 5), (9, 2))));
-          ("java", Some (((1, 1), (4, 4))));
-          ("lua", Some (((8, 9), (6, 7))));
-          ("lisp", Some (((3, 6), (6, 3))));
-          ("ruby", Some (((8, 6), (5, 9)))) ]
+        [ ("clojure", Some ((1, 10), (7, 10)));
+          ("elixir", Some ((6, 5), (1, 5)));
+          ("ecmascript", Some ((10, 1), (10, 10)));
+          ("rust", Some ((9, 5), (9, 2)));
+          ("java", Some ((1, 1), (4, 4)));
+          ("lua", Some ((8, 9), (6, 7)));
+          ("lisp", Some ((3, 6), (6, 3)));
+          ("ruby", Some ((8, 6), (5, 9))) ]
         |> Map.ofList
     search grid wordsToSearchFor |> should equal expected
 
@@ -313,17 +313,16 @@ let ``Should fail to locate a word that is not in the puzzle`` () =
           "alxhpburyi";
           "jalaycalmp";
           "clojurermt" ]
-    let wordsToSearchFor = ["clojure"; "elixir"; "ecmascript"; "rust"; "java"; "lua"; "lisp"; "ruby";
- "haskell"]
+    let wordsToSearchFor = ["clojure"; "elixir"; "ecmascript"; "rust"; "java"; "lua"; "lisp"; "ruby"; "haskell"]
     let expected = 
-        [ ("clojure", Some (((1, 10), (7, 10))));
-          ("elixir", Some (((6, 5), (1, 5))));
-          ("ecmascript", Some (((10, 1), (10, 10))));
-          ("rust", Some (((9, 5), (9, 2))));
-          ("java", Some (((1, 1), (4, 4))));
-          ("lua", Some (((8, 9), (6, 7))));
-          ("lisp", Some (((3, 6), (6, 3))));
-          ("ruby", Some (((8, 6), (5, 9))));
+        [ ("clojure", Some ((1, 10), (7, 10)));
+          ("elixir", Some ((6, 5), (1, 5)));
+          ("ecmascript", Some ((10, 1), (10, 10)));
+          ("rust", Some ((9, 5), (9, 2)));
+          ("java", Some ((1, 1), (4, 4)));
+          ("lua", Some ((8, 9), (6, 7)));
+          ("lisp", Some ((3, 6), (6, 3)));
+          ("ruby", Some ((8, 6), (5, 9)));
           ("haskell", Option<((int * int) * (int * int))>.None) ]
         |> Map.ofList
     search grid wordsToSearchFor |> should equal expected