trackler 2.2.1.43 → 2.2.1.44

data/tracks/sml/exercises/allergies/allergies.sml

@@ -1,17 +1,14 @@
 datatype allergen = Eggs
-                  | Peanuts
-                  | Shellfish
-                  | Strawberries
-                  | Tomatoes
-                  | Chocolate
-                  | Pollen
-                  | Cats
+                | Peanuts
+                | Shellfish
+                | Strawberries
+                | Tomatoes
+                | Chocolate
+                | Pollen
+                | Cats
 
-(* given a code generate a list of all allergens this code represents *)
-fun list (code: int): allergen list =
-  raise Fail "'list' has not been implemented"
+fun allergicTo (score: int) (a: allergen) : bool =
+  raise Fail "'allergicTo' is not implemented"
 
-(* given a code and an allergen return true or false
-   whether the specified allergen is represented by the code *)
-fun allergic_to (code: int) (a: allergen): bool =
-  raise Fail "'allergic_to' has not been implemented"
+fun list (score: int): allergen list =
+  raise Fail "'list' is not implemented"

data/tracks/sml/exercises/allergies/example.sml

@@ -25,12 +25,12 @@ fun valueOf a =
       | Cats         => 7
 
 (* allergic_to = fn : int -> allergen -> bool
-   Given a code (integer) and an allergen returns true if the person
-   represented by the code is allergic to the specified allergen
+   Given a score (integer) and an allergen returns true if the person
+   represented by the score is allergic to the specified allergen
 *)
-fun allergic_to code a =
-    let fun testAllergy code n =
-            let val codeWord = Word.fromInt(code)
+fun allergicTo score a =
+    let fun testAllergy score n =
+            let val codeWord = Word.fromInt(score)
                 val nWord    = Word.fromInt(n)
                 val oneWord  = Word.fromInt(1)
             in  (* ((code >> n) & 1) == 1 *)
@@ -40,12 +40,12 @@ fun allergic_to code a =
                 )
             end
     in
-        testAllergy code (valueOf a)
+        testAllergy score (valueOf a)
     end
 
 (* allergies = fn: int -> allergen list
-   Given a code that represents a person's allergies
+   Given a score that represents a person's allergies
    return a list of all allergens that they are allergic to
 *)
-fun list code =
-    List.filter (allergic_to code) [Eggs, Peanuts, Shellfish, Strawberries, Tomatoes, Chocolate, Pollen, Cats]
+fun list score =
+    List.filter (allergicTo score) [Eggs, Peanuts, Shellfish, Strawberries, Tomatoes, Chocolate, Pollen, Cats]

data/tracks/sml/exercises/allergies/test.sml

@@ -1,132 +1,68 @@
+(* version 1.0.0 *)
+
+use "testlib.sml";
 use "allergies.sml";
 
-val test_cases = {
-  list = [
-    {
-      description = "Code = 0 returns no allergies",
-      input = 0,
-      expected = []
-    },
-    {
-      description = "Code = 1 returns allergen list of [Eggs]",
-      input = 1,
-      expected = [Eggs]
-    },
-    {
-      description = "Code = 2 returns allergen list of [Peanuts]",
-      input = 2,
-      expected = [Peanuts]
-    },
-    {
-      description = "Code = 4 returns allergen list of [Shellfish]",
-      input = 4,
-      expected = [Shellfish]
-    },
-    {
-      description = "Code = 8 returns allergen list of [Strawberries]",
-      input = 8,
-      expected = [Strawberries]
-    },
-    {
-      description = "Code = 16 returns allergen list of [Tomatoes]",
-      input = 16,
-      expected = [Tomatoes]
-    },
-    {
-      description = "Code = 32 returns allergen list of [Chocolate]",
-      input = 32,
-      expected = [Chocolate]
-    },
-    {
-      description = "Code = 64 returns allergen list of [Pollen]",
-      input = 64,
-      expected = [Pollen]
-    },
-    {
-      description = "Code = 128 returns allergen list of [Cats]",
-      input = 128,
-      expected = [Cats]
-    },
-    {
-      description = "Code = 256 returns an empty allergen list",
-      input = 256,
-      expected = []
-    },
-    (* compound tests *)
-    {
-      description = "Code = 3 returns allergen list of [Eggs, Peanuts]",
-      input = 3,
-      expected = [Eggs, Peanuts]
-    },
-    {
-      description = "Code = 20 returns allergen list of [Shellfish, Tomatoes]",
-      input = 20,
-      expected = [Shellfish, Tomatoes]
-    },
-    {
-      description = "Code = 192 returns allergen list of [Pollen, Cats]",
-      input = 192,
-      expected = [Pollen, Cats]
-    },
-    {
-      description = "Code = 255 returns all allergens",
-      input = 255,
-      expected = [Eggs, Peanuts, Shellfish, Strawberries,Tomatoes, Chocolate, Pollen, Cats]
-    }
-  ],
-  allergic_to = [
-    {
-      description = "Code = 1 is allergic to Eggs",
-      input = 1,
-      allergen = Eggs,
-      expected = true
-    },
-    {
-      description = "Code = 1 is not allergic to Pollen",
-      input = 1,
-      allergen = Pollen,
-      expected = false
-    },
-    {
-      description = "Code = 2 is allergic to Peanuts",
-      input = 2,
-      allergen = Peanuts,
-      expected = true
-    },
-    {
-      description = "Code = 255 is allergic to Cats",
-      input = 255,
-      allergen = Cats,
-      expected = true
-    }
+infixr |>
+fun x |> f = f x
+
+val testsuite =
+  describe "allergies" [
+    describe "allergicTo" [
+      describe "no allergies means not allergic" [
+        test "is not allergic to Peanuts"
+          (fn _ => allergicTo 0 Peanuts |> Expect.falsy),
+
+        test "is not allergic to Cats"
+          (fn _ => allergicTo 0 Cats |> Expect.falsy),
+
+        test "is not allergic to Strawberries"
+          (fn _ => allergicTo 0 Strawberries |> Expect.falsy)
+      ],
+
+      test "is allergic to eggs"
+        (fn _ => allergicTo 1 Eggs |> Expect.truthy),
+
+      describe "allergic to eggs in addition to other stuff" [
+        test "is allergic to Eggs"
+          (fn _ => allergicTo 5 Eggs |> Expect.truthy),
+
+        test "is allergic to Shellfish"
+          (fn _ => allergicTo 5 Shellfish |> Expect.truthy),
+
+        test "is allergic to Strawberries"
+          (fn _ => allergicTo 5 Strawberries |> Expect.falsy)
+      ]
+    ],
+
+    describe "list" [
+      test "no allergies at all"
+        (fn _ => list (0) |> Expect.equalTo []),
+
+      test "allergic to just eggs"
+        (fn _ => list (1) |> Expect.equalTo [Eggs]),
+
+      test "allergic to just peanuts"
+        (fn _ => list (2) |> Expect.equalTo [Peanuts]),
+
+      test "allergic to just strawberries"
+        (fn _ => list (8) |> Expect.equalTo [Strawberries]),
+
+      test "allergic to eggs and peanuts"
+        (fn _ => list (3) |> Expect.equalTo [Eggs, Peanuts]),
+
+      test "allergic to more than eggs but not peanuts"
+        (fn _ => list (5) |> Expect.equalTo [Eggs, Shellfish]),
+
+      test "allergic to lots of stuff"
+        (fn _ => list (248) |> Expect.equalTo [Strawberries, Tomatoes, Chocolate, Pollen, Cats]),
+
+      test "allergic to everything"
+        (fn _ => list (255) |> Expect.equalTo [Eggs, Peanuts, Shellfish, Strawberries, Tomatoes, Chocolate, Pollen, Cats]),
+
+      test "ignore non allergen score parts"
+        (fn _ => list (509) |> Expect.equalTo [Eggs, Shellfish, Strawberries, Tomatoes, Chocolate, Pollen, Cats])
+    ]
   ]
-};
-
-fun run_tests _ [] = []
-  | run_tests f (x :: xs) =
-      let
-        fun aux { description, is_correct } =
-          let
-            val expl = description ^ ": " ^
-              (if is_correct then "PASSED" else "FAILED") ^ "\n"
-          in
-            (print (expl); is_correct)
-          end
-      in
-        (aux x) :: run_tests f xs
-      end
-
-fun evaluateList f { description, input, expected } =
-  { description = description, is_correct = (f input) = expected }
-
-fun evaluateAllergicTo f { description, input, allergen, expected } =
-  { description = description, is_correct = (f input allergen) = expected }
-
-val testResults = run_tests list (List.map (evaluateList list) (#list test_cases))
-  @ run_tests list (List.map (evaluateAllergicTo allergic_to) (#allergic_to test_cases));
-val passedTests = List.filter (fn x => x) testResults;
-val failedTests = List.filter (fn x => not x) testResults;
-
-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

data/tracks/sml/exercises/allergies/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/hamming/README.md

@@ -35,19 +35,35 @@ The Hamming distance is only defined for sequences of equal length. This means
 that based on the definition, each language could deal with getting sequences
 of equal length differently.
 
-## Running the tests
+## Loading your exercise implementation in PolyML
 
-Even though there are multiple implementations, we encourage to use Poly/ML.
+```
+$ poly --use {exercise}.sml
+```
+
+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
 
 The Calculating Point Mutations problem at Rosalind [http://rosalind.info/problems/hamm/](http://rosalind.info/problems/hamm/)