trackler 2.2.1.19 → 2.2.1.20

data/tracks/sml/exercises/list-ops/README.md

@@ -0,0 +1,40 @@
+# List Ops
+
+Implement basic list operations.
+
+In functional languages list operations like `length`, `map`, and
+`reduce` are very common. Implement a series of basic list operations,
+without using existing functions.
+
+## Loading your exercise implementation in PolyML
+
+```
+$ poly --use {exercise}.sml
+```
+
+Or:
+
+```
+$ 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!
+
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/sml/exercises/list-ops/example.sml

@@ -0,0 +1,34 @@
+fun concat []                 = []
+  | concat [[]]               = []
+  | concat ([] :: xss)        = concat xss
+  | concat ((x :: xs) :: xss) = x :: concat (xs :: xss)
+
+fun reverse xs =
+  let
+    fun reverse' acc []        = acc
+      | reverse' acc (x :: xs) = reverse' (x :: acc) xs
+  in
+    reverse' [] xs
+  end
+
+fun filter (predicate, []) = []
+  | filter (predicate, (x :: xs)) =
+      if predicate x
+      then x :: filter (predicate, xs)
+      else filter (predicate, xs)
+
+fun map (f, [])      = []
+  | map (f, x :: xs) = f x :: map (f, xs)
+
+fun append (xs, [])      = xs
+  | append ([], ys)      = ys
+  | append (x :: xs, ys) = x :: append(xs, ys)
+
+fun length []        = 0
+  | length (x :: xs) = 1 + length xs
+
+fun foldl (_, acc, [])        = acc
+  | foldl (f, acc, (x :: xs)) = foldl (f, (f (acc, x)), xs)
+
+fun foldr (f, acc, [])      = acc
+  | foldr (f, acc, (x::xs)) = f (x, (foldr (f, acc, xs)))

data/tracks/sml/exercises/list-ops/list-ops.sml

@@ -0,0 +1,23 @@
+fun concat (lists: int list list): int list =
+  raise Fail "'concat' is not implemented"
+
+fun reverse (list: int list): int list =
+  raise Fail "'reverse' is not implemented"
+
+fun filter (function: int -> bool, list: int list): int list =
+  raise Fail "'filter' is not implemented"
+
+fun map (function: int -> int, list: int list): int list =
+  raise Fail "'map' is not implemented"
+
+fun append (list1: int list, list2: int list): int list =
+  raise Fail "'append' is not implemented"
+
+fun length (ns: int list): int =
+  raise Fail "'length' is not implemented"
+
+fun foldl (function: int * int -> int, initial: int, list: int list): int =
+  raise Fail "'foldl' is not implemented"
+
+fun foldr (function: int * int -> int, initial: int, list: int list): int =
+  raise Fail "'foldr' is not implemented"

data/tracks/sml/exercises/list-ops/test.sml

@@ -0,0 +1,85 @@
+(* version 2.0.0 *)
+
+use "testlib.sml";
+use "list-ops.sml";
+
+infixr |>
+fun x |> f = f x
+
+val testsuite =
+  describe "list-ops" [
+    describe "append entries to a list and return the new list" [
+      test "empty lists"
+        (fn _ => append ([], []) |> Expect.equalTo []),
+
+      test "empty list to list"
+        (fn _ => append ([], [1, 2, 3, 4]) |> Expect.equalTo [1, 2, 3, 4]),
+
+      test "non-empty lists"
+        (fn _ => append ([1, 2], [2, 3, 4, 5]) |> Expect.equalTo [1, 2, 2, 3, 4, 5])
+    ],
+
+    describe "concat lists and lists of list into a new list" [
+      test "empty list"
+        (fn _ => concat ([]) |> Expect.equalTo []),
+
+      test "list of lists"
+        (fn _ => concat ([[1, 2], [3], [], [4, 5, 6]]) |> Expect.equalTo [1, 2, 3, 4, 5, 6])
+    ],
+
+    describe "filter list returning only values that satisfy the filter function" [
+      test "empty list"
+        (fn _ => filter (fn n => n mod 2 = 1, []) |> Expect.equalTo []),
+
+      test "non-empty list"
+        (fn _ => filter (fn n => n mod 2 = 1, [1, 2, 3, 5]) |> Expect.equalTo [1, 3, 5])
+    ],
+
+    describe "returns the length of a list" [
+      test "empty list"
+        (fn _ => length ([]) |> Expect.equalTo 0),
+
+      test "non-empty list"
+        (fn _ => length ([1, 2, 3, 4]) |> Expect.equalTo 4)
+    ],
+
+    describe "return a list of elements whos values equal the list value transformed by the mapping function" [
+      test "empty list"
+        (fn _ => map (fn n => n + 1, []) |> Expect.equalTo []),
+
+      test "non-empty list"
+        (fn _ => map (fn n => n + 1, [1, 3, 5, 7]) |> Expect.equalTo [2, 4, 6, 8])
+    ],
+
+    describe "folds (reduces) the given list from the left with a function" [
+      test "empty list"
+        (fn _ => foldl (fn (x, y) => x * y, 2, []) |> Expect.equalTo 2),
+
+      test "direction independent function applied to non-empty list"
+        (fn _ => foldl (fn (x, y) => x + y, 5, [1, 2, 3, 4]) |> Expect.equalTo 15),
+
+      test "direction dependent function applied to non-empty list"
+        (fn _ => foldl (fn (x, y) => x div y, 5, [2, 5]) |> Expect.equalTo 0)
+    ],
+
+    describe "folds (reduces) the given list from the right with a function" [
+      test "empty list"
+        (fn _ => foldr (fn (x, y) => x * y, 2, []) |> Expect.equalTo 2),
+
+      test "direction independent function applied to non-empty list"
+        (fn _ => foldr (fn (x, y) => x + y, 5, [1, 2, 3, 4]) |> Expect.equalTo 15),
+
+      test "direction dependent function applied to non-empty list"
+        (fn _ => foldr (fn (x, y) => x div y, 5, [2, 5]) |> Expect.equalTo 2)
+    ],
+
+    describe "reverse the elements of the list" [
+      test "empty list"
+        (fn _ => reverse ([]) |> Expect.equalTo []),
+
+      test "non-empty list"
+        (fn _ => reverse ([1, 3, 5, 7]) |> Expect.equalTo [7, 5, 3, 1])
+    ]
+  ]
+
+val _ = Test.run testsuite

data/tracks/sml/exercises/list-ops/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/prime-factors/README.md

@@ -0,0 +1,66 @@
+# Prime Factors
+
+Compute the prime factors of a given natural number.
+
+A prime number is only evenly divisible by itself and 1.
+
+Note that 1 is not a prime number.
+
+## Example
+
+What are the prime factors of 60?
+
+- Our first divisor is 2. 2 goes into 60, leaving 30.
+- 2 goes into 30, leaving 15.
+  - 2 doesn't go cleanly into 15. So let's move on to our next divisor, 3.
+- 3 goes cleanly into 15, leaving 5.
+  - 3 does not go cleanly into 5. The next possible factor is 4.
+  - 4 does not go cleanly into 5. The next possible factor is 5.
+- 5 does go cleanly into 5.
+- We're left only with 1, so now, we're done.
+
+Our successful divisors in that computation represent the list of prime
+factors of 60: 2, 2, 3, and 5.
+
+You can check this yourself:
+
+- 2 * 2 * 3 * 5
+- = 4 * 15
+- = 60
+- Success!
+
+## Loading your exercise implementation in PolyML
+
+```
+$ poly --use {exercise}.sml
+```
+
+Or:
+
+```
+$ 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
+
+The Prime Factors Kata by Uncle Bob [http://butunclebob.com/ArticleS.UncleBob.ThePrimeFactorsKata](http://butunclebob.com/ArticleS.UncleBob.ThePrimeFactorsKata)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

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

@@ -0,0 +1,15 @@
+fun factors n =
+  let
+    fun aux prime n =
+      if prime * prime > n
+      then [n]
+      else if n mod prime = 0
+           then prime :: aux prime (n div prime)
+           else if prime = 2
+                then aux (prime + 1) n
+                else aux (prime + 2) n
+  in
+    if n < 2
+    then []
+    else aux 2 n
+  end

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

@@ -0,0 +1,2 @@
+fun factors (input: int): int list =
+  raise Fail "'factors' is not implemented"

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

@@ -0,0 +1,35 @@
+(* version 1.0.0 *)
+
+use "prime-factors.sml";
+use "testlib.sml";
+
+infixr |>
+fun x |> f = f x
+
+val testsuite =
+  describe "prime-factors" [
+    describe "returns prime factors for the given input number" [
+      test "no factors"
+        (fn _ => factors (1) |> Expect.equalTo []),
+
+      test "prime number"
+        (fn _ => factors (2) |> Expect.equalTo [2]),
+
+      test "square of a prime"
+        (fn _ => factors (9) |> Expect.equalTo [3, 3]),
+
+      test "cube of a prime"
+        (fn _ => factors (8) |> Expect.equalTo [2, 2, 2]),
+
+      test "product of primes and non-primes"
+        (fn _ => factors (12) |> Expect.equalTo [2, 2, 3]),
+
+      test "product of primes"
+        (fn _ => factors (901255) |> Expect.equalTo [5, 17, 23, 461]),
+
+      test "factors include a large prime"
+        (fn _ => factors (93819012551) |> Expect.equalTo [11, 9539, 894119])
+    ]
+  ]
+
+val _ = Test.run testsuite