trackler 2.2.1.44 → 2.2.1.45

data/tracks/sml/exercises/flatten-array/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/nth-prime/HINTS.md

@@ -0,0 +1,9 @@
+## Hints
+
+If the argument is not less than `1` raise the exception [`Domain`](http://sml-family.org/Basis/general.html#SIG:GENERAL.Domain:EXN).
+
+Some of these concepts may be helpful:
+
+- [Lazy evaluation](https://en.wikipedia.org/wiki/Lazy_evaluation)
+- Sieving (for instance [Sieve of Eratosthenes](https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes)
+- Primality by [trial division](https://en.wikipedia.org/wiki/Trial_divisio://en.wikipedia.org/wiki/Trial_division)

data/tracks/sml/exercises/nth-prime/README.md

@@ -8,19 +8,46 @@ the 6th prime is 13.
 If your language provides methods in the standard library to deal with prime
 numbers, pretend they don't exist and implement them yourself.
 
-## Running the tests
+## Hints
+
+If the argument is not less than `1` raise the exception [`Domain`](http://sml-family.org/Basis/general.html#SIG:GENERAL.Domain:EXN).
+
+Some of these concepts may be helpful:
+
+- [Lazy evaluation](https://en.wikipedia.org/wiki/Lazy_evaluation)
+- Sieving (for instance [Sieve of Eratosthenes](https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes)
+- Primality by [trial division](https://en.wikipedia.org/wiki/Trial_divisio://en.wikipedia.org/wiki/Trial_division)
 
-Even though there are multiple implementations, we encourage to use Poly/ML.
+
+## Loading your exercise implementation in PolyML
 
 ```
-$ poly -q < test_{ exercise }.sml
+$ poly --use {exercise}.sml
 ```
 
-If you want to start an interactive session:
+Or:
+
 ```
-$ poly --use test_{ exercise }.sml
+$ poly
+> use "{exercise}.sml";
 ```
 
+**Note:** You have to replace {exercise}.
+
+## Running the tests
+
+```
+$ 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
 
 A variation on Problem 7 at Project Euler [http://projecteuler.net/problem=7](http://projecteuler.net/problem=7)

data/tracks/sml/exercises/nth-prime/example.sml

@@ -1,47 +1,29 @@
-exception EmptyList
-datatype 'a lazylist = Nil | Cons of ('a * (unit -> 'a lazylist));
-fun next s = let
-    fun next' Nil = raise EmptyList
-      | next' (Cons(a,f)) = f()
-in
-    next' s
-end ;
+fun nthPrime n =
+  let
+    fun isPrime n =
+      if n = 2
+      then true
+      else if n < 2 orelse n mod 2 = 0
+           then false
+           else
+             let
+               fun loop i =
+                 if i * i > n
+                 then true
+                 else if n mod i = 0
+                      then false
+                      else loop (i + 2)
+             in
+               loop 3
+             end
 
-fun hd s = let
-    fun hd' Nil = raise EmptyList
-      | hd' (Cons(a, _)) = a
-in
-    hd' s
-end ;
-
-fun allPrimes n = let
-    fun isPrime n = let
-        fun factors n = let
-            fun factors' 0 acc = acc
-              | factors' c acc = if (n mod c) = 0
-                                 then factors' (c-1) (c :: acc)
-                                 else factors' (c-1) acc
-        in
-            factors' (n div 2) []
-        end
-    in
-        (List.length (factors n)) = 1
-    end
-
-    fun nextPrime n = let
-        val nextN = if (n mod 2) = 0 then n + 1 else n + 2
-    in
-        if isPrime nextN then nextN else nextPrime nextN
-    end
-
-in
-    Cons(n, fn () => (allPrimes (nextPrime n)))
-end ;
-
-fun nthPrime n = let
-    fun nthPrime' 0 s = hd s
-      | nthPrime' n s = nthPrime' (n-1) (next s)
-in
-    if n <= 0 then raise Domain
-    else nthPrime' (n-1) (allPrimes 2)
-end ;
+    fun loop i m =
+      case (i = n, isPrime m) of
+        (true , true)  => m
+      | (false, true)  => loop (i + 1) (m + 1)
+      | (_    , _   )  => loop i (m + 1)
+  in
+    if n < 1
+    then raise Domain
+    else loop 1 2
+  end

data/tracks/sml/exercises/nth-prime/nth-prime.sml

@@ -1,2 +1,2 @@
 fun nthPrime (n: int): int =
-  raise Fail "'nthPrime' has not been implemented"
+  raise Fail "'prime' is not implemented"

data/tracks/sml/exercises/nth-prime/test.sml

@@ -1,71 +1,27 @@
+(* version 1.0.0 *)
+
+use "testlib.sml";
 use "nth-prime.sml";
 
-val test_cases = [
-  {
-    description = "The first prime is 2",
-    input = 1,
-    expected = 2
-  },
-  {
-    description = "The second prime is 3",
-    input = 2,
-    expected = 3
-  },
-  {
-    description = "The ninth prime is 23",
-    input = 9,
-    expected = 23
-  },
-  {
-    description = "The one-hundredth prime is 541",
-    input = 100,
-    expected = 541
-  },
-  {
-    description = "The three-thousand and first prime is 27457",
-    input = 3001,
-    expected = 27457
-  }
-];
+infixr |>
+fun x |> f = f x
 
-val error_test_cases = [
-  {
-    description = "The 0th prime is not defined",
-    input = 0,
-    expected = Domain
-  },
-  {
-    description = "The -1st prime is not defined",
-    input = ~1,
-    expected = Domain
-  }
-];
+val testsuite =
+  describe "nth-prime" [
+    test "first prime"
+      (fn _ => nthPrime 1 |> Expect.equalTo 2),
 
-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
+    test "second prime"
+      (fn _ => nthPrime 2 |> Expect.equalTo 3),
 
-fun evaluateGoodTestCase f { description, input, expected } =
-  { description = description, is_correct = (f input) = expected }
+    test "sixth prime"
+      (fn _ => nthPrime 6 |> Expect.equalTo 13),
 
-fun evaluateErrorTestCase f { description, input, expected } =
-  { description = description, is_correct = (f input handle expected => 1) = 1 }
+    test "big prime"
+      (fn _ => nthPrime 10001 |> Expect.equalTo 104743),
 
-val testResults = run_tests nthPrime (List.map (evaluateGoodTestCase nthPrime) test_cases)
-  @ run_tests nthPrime (List.map (evaluateErrorTestCase nthPrime) error_test_cases);
-val passedTests = List.filter (fn x => x) testResults;
-val failedTests = List.filter (fn x => not x) testResults;
+    test "there is no zeroth prime"
+      (fn _ => (fn _ => nthPrime 0) |> Expect.error Domain)
+  ]
 
-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/nth-prime/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/raindrops/README.md

@@ -17,19 +17,35 @@ Convert a number to a string, the contents of which depend on the number's facto
 - 34 has four factors: 1, 2, 17, and 34.
   - In raindrop-speak, this would be "34".
 
-## 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
 
 A variation on a famous interview question intended to weed out potential candidates. [http://jumpstartlab.com](http://jumpstartlab.com)

data/tracks/typescript/config.json

@@ -373,6 +373,20 @@
         "Integers",
         "Logic"
       ]
+    },
+    {
+      "uuid": "cf2d545c-036e-0980-3ac2-64ad54c3867e37f4cfa",
+      "slug": "triangle",
+      "core": false,
+      "unlocked_by": "leap",
+      "difficulty": 3,
+      "topics": [
+        "Control-flow (loops)",
+        "Control-flow (conditionals)",
+        "Exception handling",
+        "Integers",
+        "Mathematics"
+      ]
     }
   ],
   "foregone": []

data/tracks/typescript/exercises/triangle/README.md

@@ -0,0 +1,55 @@
+# Triangle
+
+Determine if a triangle is equilateral, isosceles, or scalene.
+
+An _equilateral_ triangle has all three sides the same length.
+
+An _isosceles_ triangle has at least two sides the same length. (It is sometimes
+specified as having exactly two sides the same length, but for the purposes of
+this exercise we'll say at least two.)
+
+A _scalene_ triangle has all sides of different lengths.
+
+## Note
+
+For a shape to be a triangle at all, all sides have to be of length > 0, and
+the sum of the lengths of any two sides must be greater than or equal to the
+length of the third side. See [Triangle Inequality](https://en.wikipedia.org/wiki/Triangle_inequality).
+
+## Dig Deeper
+
+The case where the sum of the lengths of two sides _equals_ that of the
+third is known as a _degenerate_ triangle - it has zero area and looks like
+a single line. Feel free to add your own code/tests to check for degenerate triangles.
+
+## Setup
+
+Go through the setup instructions for TypeScript to
+install the necessary dependencies:
+
+http://exercism.io/languages/typescript
+
+## Requirements
+
+Install assignment dependencies:
+
+```bash
+$ yarn install
+```
+
+## Making the test suite pass
+
+Execute the tests with:
+
+```bash
+$ yarn test
+```
+
+
+
+## Source
+
+The Ruby Koans triangle project, parts 1 & 2 [http://rubykoans.com](http://rubykoans.com)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.