trackler 2.2.1.19 → 2.2.1.20

data/tracks/scala/testgen/src/main/scala/SayTestGenerator.scala

@@ -0,0 +1,50 @@
+import java.io.File
+
+import PrimeFactorsTestGenerator.toString
+import testgen.TestSuiteBuilder.{sutArgs, _}
+import testgen._
+
+object SayTestGenerator {
+  def main(args: Array[String]): Unit = {
+    val file = new File("src/main/resources/say.json")
+
+    def toString(expected: CanonicalDataParser.Expected): String = {
+      expected match {
+        case Left(_) => "None"
+        case Right(-1) => "None"
+        case Right(n)  => s"""Some("$n")"""
+      }
+    }
+
+    def sutArgs(parseResult: CanonicalDataParser.ParseResult, argNames: String*): String =
+      argNames map (name => toArgString(parseResult(name))) mkString ", "
+
+    def toArgString(any: Any): String = {
+      any match {
+        case lstr: Long =>
+          lstr.toString + "l"
+        case istr: Integer =>
+          istr.toString
+        case dstr: Double =>
+          dstr.toLong + "l"
+        case _ => any.toString
+      }
+    }
+
+    def fromLabeledTest(argNames: String*): ToTestCaseData =
+      withLabeledTest { sut =>
+        labeledTest =>
+          val args = sutArgs(labeledTest.result, argNames: _*)
+          val property = labeledTest.property
+          val sutCall =
+            s"""$sut.inEnglish($args)"""
+          val expected = toString(labeledTest.expected)
+          TestCaseData(labeledTest.description, sutCall, expected)
+      }
+
+    val code = TestSuiteBuilder.build(file, fromLabeledTest("input"))
+    println(s"-------------")
+    println(code)
+    println(s"-------------")
+  }
+}

data/tracks/sml/bin/generate

@@ -212,8 +212,8 @@ def generate_test_content(data, signature):
     return '\n'.join([
         '(* version %s *)' % data['version'],
         '',
-        'use "%s.sml";' % data['exercise'],
         'use "testlib.sml";',
+        'use "%s.sml";' % data['exercise'],
         '',
         'infixr |>',
         'fun x |> f = f x',

data/tracks/sml/config.json

@@ -4,6 +4,16 @@
   "active": false,
   "test_pattern": "test[.]sml$",
   "exercises": [
+    {
+      "uuid": "7e1d0e9a-435d-4dc6-8867-2fc4f9b7fe6f",
+      "slug": "all-your-base",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+
+      ]
+    },
     {
       "uuid": "4450455d-0786-6f80-7672-48368a115df16e0aa7e",
       "slug": "hello-world",
@@ -134,6 +144,26 @@
 
       ]
     },
+    {
+      "uuid": "6c191163-0a98-2380-debc-75144c1787f3853e868",
+      "slug": "prime-factors",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+
+      ]
+    },
+    {
+      "uuid": "c8b94fa9-d758-4dca-b7fc-7a130061e064",
+      "slug": "list-ops",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+
+      ]
+    },
     {
       "uuid": "225cfd7d-81a3-4a58-b1aa-1de2e40e7a93",
       "slug": "binary",

data/tracks/sml/exercises/all-your-base/README.md

@@ -0,0 +1,61 @@
+# All Your Base
+
+Convert a number, represented as a sequence of digits in one base, to any other base.
+
+Implement general base conversion. Given a number in base a, represented as a sequence of digits, convert it to base b.
+
+Note
+
+Try to implement the conversion yourself. Do not use something else to perform the conversion for you.
+
+About Positional Notation:
+
+In positional notation, a number in base b can be understood as a linear combination of powers of b.
+
+The number 42, in base 10, means:
+
+(4 * 10^1) + (2 * 10^0)
+
+The number 101010, in base 2, means:
+
+(1 * 2^5) + (0 * 2^4) + (1 * 2^3) + (0 * 2^2) + (1 * 2^1) + (0 * 2^0)
+
+The number 1120, in base 3, means:
+
+(1 * 3^3) + (1 * 3^2) + (2 * 3^1) + (0 * 3^0)
+
+I think you got the idea!
+
+Yes. Those three numbers above are exactly the same. Congratulations!
+
+## 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/all-your-base/all-your-base.sml

@@ -0,0 +1,2 @@
+fun rebase (input_base: int, input_digits: int list, output_base: int): int list option =
+  raise Fail "'rebase' is not implemented"

data/tracks/sml/exercises/all-your-base/example.sml

@@ -0,0 +1,36 @@
+fun rebase (inBase, digits, outBase) = let
+  fun fromBase base = let
+    fun f (x, NONE  ) = NONE
+      | f (x, SOME n) =
+        if x >= 0 andalso x < base then SOME(n * base + x)
+        else NONE
+  in
+    foldl f (SOME 0)
+  end
+
+  fun toBase base = let
+    infix divMod
+    fun a divMod b = (a div b, a mod b)
+
+    fun swap (a, b) = (b, a)
+
+    fun unfold f b =
+      case f b of
+        SOME(a, b') => a :: unfold f b'
+      | NONE        => []
+
+    fun f 0 = NONE
+      | f x = SOME (swap (x divMod base))
+  in
+    rev o (unfold f)
+  end
+in
+  if inBase < 2
+    orelse outBase < 2
+    orelse (List.length digits) = 0
+    orelse (List.length digits) = (List.length (List.filter (fn x => x = 0) digits))
+  then NONE
+  else case fromBase inBase digits of
+    SOME v => SOME (toBase outBase v)
+  | NONE   => NONE
+end

data/tracks/sml/exercises/all-your-base/test.sml

@@ -0,0 +1,75 @@
+(* version 1.1.0 *)
+
+use "all-your-base.sml";
+use "testlib.sml";
+
+infixr |>
+fun x |> f = f x
+
+val testsuite =
+  describe "all-your-base" [
+    test "single bit one to decimal"
+      (fn _ => rebase (2, [1], 10) |> Expect.equalTo (SOME [1])),
+
+    test "binary to single decimal"
+      (fn _ => rebase (2, [1, 0, 1], 10) |> Expect.equalTo (SOME [5])),
+
+    test "single decimal to binary"
+      (fn _ => rebase (10, [5], 2) |> Expect.equalTo (SOME [1, 0, 1])),
+
+    test "binary to multiple decimal"
+      (fn _ => rebase (2, [1, 0, 1, 0, 1, 0], 10) |> Expect.equalTo (SOME [4, 2])),
+
+    test "decimal to binary"
+      (fn _ => rebase (10, [4, 2], 2) |> Expect.equalTo (SOME [1, 0, 1, 0, 1, 0])),
+
+    test "trinary to hexadecimal"
+      (fn _ => rebase (3, [1, 1, 2, 0], 16) |> Expect.equalTo (SOME [2, 10])),
+
+    test "hexadecimal to trinary"
+      (fn _ => rebase (16, [2, 10], 3) |> Expect.equalTo (SOME [1, 1, 2, 0])),
+
+    test "15-bit integer"
+      (fn _ => rebase (97, [3, 46, 60], 73) |> Expect.equalTo (SOME [6, 10, 45])),
+
+    test "empty list"
+      (fn _ => rebase (2, [], 10) |> Expect.equalTo NONE),
+
+    test "single zero"
+      (fn _ => rebase (10, [0], 2) |> Expect.equalTo NONE),
+
+    test "multiple zeros"
+      (fn _ => rebase (10, [0, 0, 0], 2) |> Expect.equalTo NONE),
+
+    test "leading zeros"
+      (fn _ => rebase (7, [0, 6, 0], 10) |> Expect.equalTo (SOME [4, 2])),
+
+    test "first base is one"
+      (fn _ => rebase (1, [], 10) |> Expect.equalTo NONE),
+
+    test "first base is zero"
+      (fn _ => rebase (0, [], 10) |> Expect.equalTo NONE),
+
+    test "first base is negative"
+      (fn _ => rebase (~2, [1], 10) |> Expect.equalTo NONE),
+
+    test "negative digit"
+      (fn _ => rebase (2, [1, ~1, 1, 0, 1, 0], 10) |> Expect.equalTo NONE),
+
+    test "invalid positive digit"
+      (fn _ => rebase (2, [1, 2, 1, 0, 1, 0], 10) |> Expect.equalTo NONE),
+
+    test "second base is one"
+      (fn _ => rebase (2, [1, 0, 1, 0, 1, 0], 1) |> Expect.equalTo NONE),
+
+    test "second base is zero"
+      (fn _ => rebase (10, [7], 0) |> Expect.equalTo NONE),
+
+    test "second base is negative"
+      (fn _ => rebase (2, [1], ~7) |> Expect.equalTo NONE),
+
+    test "both bases are negative"
+      (fn _ => rebase (~2, [1], ~7) |> Expect.equalTo NONE)
+  ]
+
+val _ = Test.run testsuite

data/tracks/sml/exercises/all-your-base/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/difference-of-squares/example.sml

@@ -1,11 +1,8 @@
 local
-  val identity = fn x => x
-  fun range n = List.tabulate (n, identity)
   fun square n = n * n
-  val sum = foldl (op +) 0
-  fun inc n = n + 1
+  fun sum n = n * (n + 1) div 2
 in
-  val squareOfSum = square o sum o range o inc
-  fun sumOfSquares n = sum (map square ((range o inc) n))
+  val squareOfSum = square o sum
+  fun sumOfSquares n = n * (n + 1) * (2 * n + 1) div 6
   fun differenceOfSquares n = squareOfSum n - sumOfSquares n 
 end