trackler 2.2.1.44 → 2.2.1.45

data/tracks/sml/exercises/binary/README.md

@@ -7,10 +7,12 @@ string, your program should produce a decimal output. The
 program should handle invalid inputs.
 
 ## Note
+
 - Implement the conversion yourself.
   Do not use something else to perform the conversion for you.
 
 ## About Binary (Base-2)
+
 Decimal is a base-10 system.
 
 A number 23 in base 10 notation can be understood
@@ -28,19 +30,35 @@ Binary is similar, but uses powers of 2 rather than powers of 10.
 
 So: `101 => 1*2^2 + 0*2^1 + 1*2^0 => 1*4 + 0*2 + 1*1 => 4 + 1 => 5 base 10`.
 
-## Running the tests
+## Loading your exercise implementation in PolyML
+
+```
+$ poly --use {exercise}.sml
+```
 
-Even though there are multiple implementations, we encourage to use Poly/ML.
+Or:
 
 ```
-$ poly -q < test_{ exercise }.sml
+$ poly
+> use "{exercise}.sml";
 ```
 
-If you want to start an interactive session:
+**Note:** You have to replace {exercise}.
+
+## Running the tests
+
 ```
-$ poly --use test_{ exercise }.sml
+$ poly -q --use test.sml
 ```
 
+## Feedback, Issues, Pull Requests
+
+The [exercism/sml](https://github.com/exercism/sml) repository on
+GitHub is the home for all of the Standard ML exercises.
+
+If you have feedback about an exercise, or want to help implementing a new
+one, head over there and create an issue. We'll do our best to help you!
+
 ## Source
 
 All of Computer Science [http://www.wolframalpha.com/input/?i=binary&a=*C.binary-_*MathWorld-](http://www.wolframalpha.com/input/?i=binary&a=*C.binary-_*MathWorld-)

data/tracks/sml/exercises/binary/binary.sml

@@ -0,0 +1,2 @@
+fun decimal (binary: string): int option =
+  raise Fail "'decimal' is not implemented"

data/tracks/sml/exercises/binary/example.sml

@@ -1,27 +1,16 @@
-exception NonBinaryDigitFound
-exception EmptyBinaryStringFound
-
-(* accepts a binary string and converts it to the decimal equivalant *)
-fun binaryToDecimal n = let
+fun decimal n = let
     val digits = List.map (fn c => (ord c) - 48) (explode n)
     val len = List.length digits
-    fun validateBinaryDigits []      = true
-      | validateBinaryDigits (d::ds) = if d <> 0 andalso d <> 1 then false
-                                       else validateBinaryDigits ds
+
+    fun validate []      = true
+      | validate (d::ds) = if d <> 0 andalso d <> 1 then false
+                           else validate ds
     fun even n = (n mod 2) = 0
-    fun expt a b = let
-        fun loop x 0 acc = acc
-          | loop x 1 acc = x * acc
-          | loop x n acc = if (even n) then loop (x * x) (n div 2) acc
-                           else             loop (x * x) ((n - 1) div 2) (x * acc)
-    in
-        loop a b 1
-    end
-    fun f' []      mult acc = acc 
-      | f' (x::xs) mult acc = f' xs (mult - 1) (acc + (x * (expt 2 mult)))
+    fun int_pow a b = Real.toInt IEEEReal.TO_NEAREST (Math.pow (Real.fromInt(a), Real.fromInt(b)))
+    fun f' []      mult acc = acc
+      | f' (x::xs) mult acc = f' xs (mult - 1) (acc + (x * (int_pow 2 mult)))
 in
-    if len = 0 then raise EmptyBinaryStringFound
-    else if (validateBinaryDigits digits) then f' digits (len - 1) 0
-    else raise NonBinaryDigitFound
+    if len = 0 orelse not(validate digits) then NONE
+    else SOME (f' digits (len - 1) 0)
 end
 

data/tracks/sml/exercises/binary/test.sml

@@ -1,32 +1,57 @@
+(* version 1.0.0 *)
+
+use "testlib.sml";
 use "example.sml";
 
-val test_cases = [
-    ("0",          0),
-    ("01",         1),
-    ("10",         2),
-    ("11",         3),
-    ("100",        4),
-    ("1111",      15),
-    ("10000000", 128)
-];
-
-val error_test_cases = [
-    ("",     EmptyBinaryStringFound),
-    ("200",  NonBinaryDigitFound),
-    ("a62b", NonBinaryDigitFound)
-];
-
-fun run_tests [] = []
-  | run_tests ((bin_string,expected)::ts) =
-       (binaryToDecimal bin_string = expected) :: run_tests ts
-
-fun run_error_tests [] = []
-  | run_error_tests ((bin_string,expected: exn)::ts) =
-       (binaryToDecimal bin_string handle expected => 1) :: run_error_tests ts
-
-val allNormalTestsPass =
-    List.foldl (fn (x,y) => x andalso y) true (run_tests test_cases)
-val allErrorTestsPass =
-    (List.foldl (fn (x,y) => x + y) 0 (run_error_tests error_test_cases)) = length error_test_cases
-val allTestsPass = allNormalTestsPass andalso allErrorTestsPass
-    
+infixr |>
+fun x |> f = f x
+
+val testsuite =
+  describe "binary" [
+    test "binary 0 is decimal 0"
+      (fn _ => decimal ("0") |> Expect.equalTo (SOME 0)),
+
+    test "binary 1 is decimal 1"
+      (fn _ => decimal ("1") |> Expect.equalTo (SOME 1)),
+
+    test "binary 10 is decimal 2"
+      (fn _ => decimal ("10") |> Expect.equalTo (SOME 2)),
+
+    test "binary 11 is decimal 3"
+      (fn _ => decimal ("11") |> Expect.equalTo (SOME 3)),
+
+    test "binary 100 is decimal 4"
+      (fn _ => decimal ("100") |> Expect.equalTo (SOME 4)),
+
+    test "binary 1001 is decimal 9"
+      (fn _ => decimal ("1001") |> Expect.equalTo (SOME 9)),
+
+    test "binary 11010 is decimal 26"
+      (fn _ => decimal ("11010") |> Expect.equalTo (SOME 26)),
+
+    test "binary 10001101000 is decimal 1128"
+      (fn _ => decimal ("10001101000") |> Expect.equalTo (SOME 1128)),
+
+    test "binary ignores leading zeros"
+      (fn _ => decimal ("000011111") |> Expect.equalTo (SOME 31)),
+
+    test "2 is not a valid binary digit"
+      (fn _ => decimal ("2") |> Expect.equalTo NONE),
+
+    test "a number containing a non-binary digit is invalid"
+      (fn _ => decimal ("01201") |> Expect.equalTo NONE),
+
+    test "a number with trailing non-binary characters is invalid"
+      (fn _ => decimal ("10nope") |> Expect.equalTo NONE),
+
+    test "a number with leading non-binary characters is invalid"
+      (fn _ => decimal ("nope10") |> Expect.equalTo NONE),
+
+    test "a number with internal non-binary characters is invalid"
+      (fn _ => decimal ("10nope10") |> Expect.equalTo NONE),
+
+    test "a number and a word whitespace spearated is invalid"
+      (fn _ => decimal ("001 nope") |> Expect.equalTo NONE)
+  ]
+
+val _ = Test.run testsuite

data/tracks/sml/exercises/binary/testlib.sml

@@ -0,0 +1,159 @@
+structure Expect =
+struct
+  datatype expectation = Pass | Fail of string * string
+
+  local
+    fun failEq b a =
+      Fail ("Expected: " ^ b, "Got: " ^ a)
+    
+    fun failExn b a =
+      Fail ("Expected: " ^ b, "Raised: " ^ a)
+
+    fun exnName (e: exn): string = General.exnName e
+  in
+    fun truthy a =
+      if a
+      then Pass
+      else failEq "true" "false"
+
+    fun falsy a =
+      if a
+      then failEq "false" "true"
+      else Pass
+
+    fun equalTo b a = 
+      if a = b
+      then Pass
+      else failEq (PolyML.makestring b) (PolyML.makestring a)
+
+    fun nearTo b a =
+      if Real.== (a, b)
+      then Pass
+      else failEq (Real.toString b) (Real.toString a)
+
+    fun anyError f =
+      (
+        f ();
+        failExn "an exception" "Nothing"
+      ) handle _ => Pass
+
+    fun error e f =
+      (
+        f ();
+        failExn (exnName e) "Nothing"
+      ) handle e' => if exnMessage e' = exnMessage e
+                     then Pass
+                     else failExn (exnMessage e) (exnMessage e')
+  end
+end
+
+structure TermColor =
+struct
+  datatype color = Red | Green | Yellow | Normal
+
+  fun f Red    = "\027[31m"
+    | f Green  = "\027[32m"
+    | f Yellow = "\027[33m"
+    | f Normal = "\027[0m"
+
+  fun colorize color s = (f color) ^ s ^ (f Normal)
+
+  val redit = colorize Red
+
+  val greenit = colorize Green
+
+  val yellowit = colorize Yellow
+end
+
+structure Test =
+struct
+  datatype testnode = TestGroup of string * testnode list
+                    | Test of string * (unit -> Expect.expectation)
+
+  local
+    datatype evaluation = Success of string
+                        | Failure of string * string * string
+                        | Error of string * string
+
+    fun indent n s = (implode (List.tabulate (n, fn _ => #" "))) ^ s
+
+    fun fmt indentlvl ev =
+      let
+        val check = TermColor.greenit "\226\156\148 " (* ✔ *)
+        val cross = TermColor.redit "\226\156\150 "   (* ✖ *)
+        val indentlvl = indentlvl * 2
+      in
+      case ev of
+        Success descr => indent indentlvl (check ^ descr)
+      | Failure (descr, exp, got) =>
+          String.concatWith "\n" [indent indentlvl (cross ^ descr),
+                                  indent (indentlvl + 2) exp,
+                                  indent (indentlvl + 2) got]
+      | Error (descr, reason) =>
+          String.concatWith "\n" [indent indentlvl (cross ^ descr),
+                                  indent (indentlvl + 2) (TermColor.redit reason)]
+      end
+
+    fun eval (TestGroup _) = raise Fail "Only a 'Test' can be evaluated"
+      | eval (Test (descr, thunk)) =
+          (
+            case thunk () of
+              Expect.Pass   => ((1, 0, 0), Success descr)
+            | Expect.Fail (s, s') => ((0, 1, 0), Failure (descr, s, s'))
+          )
+          handle e => ((0, 0, 1), Error (descr, "Unexpected error: " ^ exnMessage e))
+
+    fun flatten depth testnode =
+      let
+        fun sum (x, y, z) (a, b, c) = (x + a, y + b, z + c)
+
+        fun aux (t, (counter, acc)) =
+          let
+            val (counter', texts) = flatten (depth + 1) t
+          in
+            (sum counter' counter, texts :: acc)
+          end
+      in
+        case testnode of
+          TestGroup (descr, ts) =>
+            let
+              val (counter, texts) = foldr aux ((0, 0, 0), []) ts
+            in
+              (counter, (indent (depth * 2) descr) :: List.concat texts)
+            end
+        | Test _ =>
+            let
+              val (counter, evaluation) = eval testnode
+            in
+              (counter, [fmt depth evaluation])
+            end
+      end
+    
+    fun println s = print (s ^ "\n")
+  in
+    fun run suite =
+      let
+        val ((succeeded, failed, errored), texts) = flatten 0 suite
+
+        val summary = String.concatWith ", " [
+          TermColor.greenit ((Int.toString succeeded) ^ " passed"),
+          TermColor.redit ((Int.toString failed) ^ " failed"),
+          TermColor.redit ((Int.toString errored) ^ " errored"),
+          (Int.toString (succeeded + failed + errored)) ^ " total"
+        ]
+        
+        val status = if failed = 0 andalso errored = 0
+                     then OS.Process.success
+                     else OS.Process.failure
+
+      in
+        List.app println texts;
+        println "";
+        println ("Tests: " ^ summary);
+        OS.Process.exit status
+      end
+  end
+end
+
+fun describe description tests = Test.TestGroup (description, tests)
+fun test description thunk = Test.Test (description, thunk)

data/tracks/sml/exercises/flatten-array/HINTS.md

@@ -0,0 +1,8 @@
+## Hints
+
+You can think of this data structure as a [`Rose Tree`](https://en.wikipedia.org/wiki/Rose_tree). You are given a data type `'a tree` that represents this data structure.
+
+**Notes**
+- For this exercise `Empty` represents `null`
+- The nested list is represented by `List [...]`.
+- The input example is represented by `List [Elem 1, List [Elem 2, Elem 3, Empty, Elem 4], List [Empty], Elem 5]`

data/tracks/sml/exercises/flatten-array/README.md

@@ -3,27 +3,52 @@
 Take a nested list and return a single flattened list with all values except nil/null.
 
 The challenge is to write a function that accepts an arbitrarily-deep nested list-like structure and returns a flattened structure without any nil/null values.
- 
+
 For Example
 
 input: [1,[2,3,null,4],[null],5]
 
 output: [1,2,3,4,5]
 
+## Hints
 
-## Running the tests
+You can think of this data structure as a [`Rose Tree`](https://en.wikipedia.org/wiki/Rose_tree). You are given a data type `'a tree` that represents this data structure.
+
+**Notes**
+- For this exercise `Empty` represents `null`
+- The nested list is represented by `List [...]`.
+- The input example is represented by `List [Elem 1, List [Elem 2, Elem 3, Empty, Elem 4], List [Empty], Elem 5]`
+
+
+## Loading your exercise implementation in PolyML
+
+```
+$ poly --use {exercise}.sml
+```
 
-Even though there are multiple implementations, we encourage to use Poly/ML.
+Or:
 
 ```
-$ poly -q < test_{ exercise }.sml
+$ poly
+> use "{exercise}.sml";
 ```
 
-If you want to start an interactive session:
+**Note:** You have to replace {exercise}.
+
+## Running the tests
+
 ```
-$ poly --use test_{ exercise }.sml
+$ poly -q --use test.sml
 ```
 
+## Feedback, Issues, Pull Requests
+
+The [exercism/sml](https://github.com/exercism/sml) repository on
+GitHub is the home for all of the Standard ML exercises.
+
+If you have feedback about an exercise, or want to help implementing a new
+one, head over there and create an issue. We'll do our best to help you!
+
 ## Source
 
 Interview Question [https://reference.wolfram.com/language/ref/Flatten.html](https://reference.wolfram.com/language/ref/Flatten.html)

data/tracks/sml/exercises/flatten-array/example.sml

@@ -1,6 +1,5 @@
-datatype 'a nestedList =
-	  Elem of 'a
-	| List of 'a nestedList list
+datatype 'a tree = Empty | Elem of 'a | List of 'a tree list
 
-fun flatten (Elem x)  = [x]
+fun flatten Empty     = []
+  | flatten (Elem x)  = [x]
   | flatten (List xs) = List.concat (map flatten xs)

data/tracks/sml/exercises/flatten-array/flatten-array.sml

@@ -1,6 +1,5 @@
-datatype 'a nestedList =
-	  Elem of 'a
-	| List of 'a nestedList list
+(* Rose tree *)
+datatype 'a tree = Empty | Elem of 'a | List of 'a tree list
 
-fun flatten (xs: 'a nestedList): 'a list =
-  raise Fail "'flatten' has not been implemented"
+fun flatten (xs: 'a tree): 'a list =
+  raise Fail "'flatten' has not been implemented"

data/tracks/sml/exercises/flatten-array/test.sml

@@ -1,57 +1,81 @@
+(* version 1.1.0 *)
+
+use "testlib.sml";
 use "flatten-array.sml";
 
-val test_cases = [
-  {
-    description = "[1, [2, [], 3, [4, 5]]] flattens to [1,2,3,4,5]",
-    input = List [
-        Elem 1,
-        List [
-          Elem 2,
-          List [],
-          Elem 3,
-          List [Elem 4, Elem 5]
-        ]
-    ],
-    expected = [1, 2, 3, 4, 5]
-  },
-  {
-    description = "[1,2,3,4,5] flattens to [1,2,3,4,5]",
-    input = List [
-        Elem 1,
-        Elem 2,
-        Elem 3,
-        Elem 4,
-        Elem 5
-    ],
-    expected = [1, 2, 3, 4, 5]
-  },
-  {
-    description = "[] flattens to []",
-    input = List [],
-    expected = []
-  }
-];
-
-fun run_tests _ [] = []
-  | run_tests f (x :: xs) =
-      let
-        fun aux { description, input, expected } =
-          let
-            val output = f input
-            val is_correct = output = expected
-            val expl = description ^ ": " ^
-              (if is_correct then "PASSED" else "FAILED") ^ "\n"
-          in
-            (print (expl); is_correct)
-          end
+infixr |>
+fun x |> f = f x
+
+val testsuite =
+  describe "flatten-array" [
+    test "no nesting"
+      (fn _ => let
+        val nested = List [Elem 0, Elem 1, Elem 2]
+      in
+        flatten nested |> Expect.equalTo [0, 1, 2]
+      end),
+
+    test "flattens array with just integers present"
+      (fn _ => let
+        val nested = List [Elem 1,
+                           List [Elem 2, Elem 3, Elem 4, Elem 5, Elem 6, Elem 7],
+                           Elem 8]
+      in
+        flatten nested |> Expect.equalTo [1, 2, 3, 4, 5, 6, 7, 8]
+      end),
+
+    test "5 level nesting"
+      (fn _ => let
+        val nested = List [Elem 0,
+                           Elem 2,
+                           List [List [Elem 2, Elem 3],
+                                 Elem 8,
+                                 Elem 100,
+                                 Elem 4,
+                                 List [List [List [Elem 50]]]],
+                           Elem (~2)]
+      in
+        flatten nested |> Expect.equalTo [0, 2, 2, 3, 8, 100, 4, 50, ~2]
+      end),
+
+    test "6 level nesting"
+      (fn _ => let
+        val nested = List [Elem 1,
+                           List [Elem 2,
+                                 List [List [Elem 3]],
+                                 List [Elem 4, List [List [Elem 5]]],
+                                 Elem 6,
+                                 Elem 7],
+                           Elem 8]
+      in
+        flatten nested |> Expect.equalTo [1, 2, 3, 4, 5, 6, 7, 8]
+      end),
+
+    test "6 level nest list with Empty values"
+      (fn _ => let
+        val nested = List [Elem 0,
+                           Elem 2,
+                           List [List [Elem 2, Elem 3],
+                                 Elem 8,
+                                 List [List [Elem 100]],
+                                 Empty,
+                                 List [List [Empty]]],
+                           Elem (~2)]
       in
-        (aux x) :: run_tests f xs
-      end
+        flatten nested |> Expect.equalTo [0, 2, 2, 3, 8, 100, ~2]
+      end),
 
-val testResults = run_tests flatten test_cases;
-val passedTests = List.filter (fn x => x) testResults;
-val failedTests = List.filter (fn x => not x) testResults;
+    test "all values in nested list are Empty"
+      (fn _ => let
+         val nested = List [Empty,
+                            List [List [List [Empty]]],
+                            Empty,
+                            Empty,
+                            List [List [Empty, Empty], Empty],
+                            Empty]
+       in
+         flatten nested |> Expect.equalTo []
+       end)
+  ]
 
-if (List.length testResults) = (List.length passedTests)
-then (print "ALL TESTS PASSED")
-else (print (Int.toString (List.length failedTests) ^ " TEST(S) FAILED"));
+val _ = Test.run testsuite