trackler 2.0.6.0 → 2.0.6.1

data/tracks/ocaml/tools/test-generator/src/special_cases.ml

@@ -3,18 +3,18 @@ open Core.Std
 open Model
 
 let optional_int ~(none: int) = function
-  | Int n when n = none -> "None"
-  | Int n -> "(Some " ^ Int.to_string n ^ ")"
-  | x -> parameter_to_string x
+| Int n when n = none -> "None"
+| Int n -> "(Some " ^ Int.to_string n ^ ")"
+| x -> parameter_to_string x
 
 let optional_int_list = function
-  | IntList xs -> "(Some [" ^ String.concat ~sep:"; " (List.map ~f:Int.to_string xs) ^ "])"
-  | _ -> "None"
+| IntList xs -> "(Some [" ^ String.concat ~sep:"; " (List.map ~f:Int.to_string xs) ^ "])"
+| _ -> "None"
 
 let optional_int_or_string ~(none: int) = function
-  | String s -> "(Some \"" ^ s ^ "\")"
-  | Int n when n = none -> "None"
-  | x -> parameter_to_string x
+| String s -> "(Some \"" ^ s ^ "\")"
+| Int n when n = none -> "None"
+| x -> parameter_to_string x
 
 let default_value ~(key: string) ~(value: string) (parameters: (string * string) list): (string * string) list =
   if List.exists ~f:(fun (k, _) -> k = key) parameters
@@ -30,28 +30,32 @@ let optional_strings ~(f: string -> bool) (parameters: (string * string) list):
   List.map ~f:replace parameters
 
 let edit_expected ~(stringify: parameter -> string) ~(slug: string) ~(value: parameter) = match slug with
-  | "hamming" -> optional_int ~none:(-1) value
-  | "all-your-base" -> optional_int_list value
-  | "say" -> optional_int_or_string ~none:(-1) value
-  | _ -> stringify value
+| "hamming" -> optional_int ~none:(-1) value
+| "all-your-base" -> optional_int_list value
+| "say" -> optional_int_or_string ~none:(-1) value
+| _ -> stringify value
 
 let edit_say (ps: (string * string) list) =
   let edit = function
-    | ("input", v) -> ("input", if Int.of_string v >= 0 then "(" ^ v ^ "L)" else v ^ "L")
-    | x -> x in
+  | ("input", v) -> ("input", if Int.of_string v >= 0 then "(" ^ v ^ "L)" else v ^ "L")
+  | x -> x in
   List.map ps ~f:edit
 
 let edit_all_your_base (ps: (string * string) list) =
   let edit = function
-    | ("output_base", v) -> ("output_base", if Int.of_string v >= 0 then v else "(" ^ v ^ ")")
-    | ("input_base", v) -> ("input_base", if Int.of_string v >= 0 then v else "(" ^ v ^ ")")
-    | x -> x in
+  | ("output_base", v) -> ("output_base", if Int.of_string v >= 0 then v else "(" ^ v ^ ")")
+  | ("input_base", v) -> ("input_base", if Int.of_string v >= 0 then v else "(" ^ v ^ ")")
+  | x -> x in
   List.map ps ~f:edit
 
 let edit_parameters ~(slug: string) (parameters: (string * string) list) = match (slug, parameters) with
-  | ("hello-world", ps) -> default_value ~key:"name" ~value:"None"
-    @@ optional_strings ~f:(fun _x -> true)
-    @@ parameters
-  | ("say", ps) -> edit_say ps
-  | ("all-your-base", ps) -> edit_all_your_base ps
-  | (_, ps) -> ps
+| ("hello-world", ps) -> default_value ~key:"name" ~value:"None"
+  @@ optional_strings ~f:(fun _x -> true)
+  @@ parameters
+| ("say", ps) -> edit_say ps
+| ("all-your-base", ps) -> edit_all_your_base ps
+| (_, ps) -> ps
+
+let expected_key_name slug = match slug with
+| "dominoes" -> "can_chain"
+| _ -> "expected"

data/tracks/ocaml/tools/test-generator/src/utils.ml

@@ -1,6 +1,6 @@
 open Core.Std
-open Yojson.Safe
-open Yojson.Safe.Util
+open Yojson.Basic
+open Yojson.Basic.Util
 
 let map2 (f: 'a -> 'b -> 'c) (r1: ('a, 'e) Result.t) (r2: ('b, 'e) Result.t): ('c, 'e) Result.t = match (r1, r2) with
   | (Error x, _) -> Error x

data/tracks/ocaml/tools/test-generator/templates/dominoes/template.ml

@@ -0,0 +1,40 @@
+open Core.Std
+open OUnit2
+open Dominoes
+
+let print_dominoe (d1, d2) = sprintf "(%d,%d)" d1 d2
+
+let option_printer = function
+  | None -> "None"
+  | Some xs -> "Some [" ^ String.concat ~sep:";" (List.map xs ~f:print_dominoe) ^ "]"
+
+let drop_1_right xs = List.rev xs |> List.tl_exn |> List.rev
+
+let check_chain (chained: dominoe list) = 
+  let assert_dominoes_match d1 d2 =
+    if snd d1 <> fst d2 then failwith @@ sprintf "%s and %s cannot be chained together" (print_dominoe d1) (print_dominoe d2) else () in
+  let consecutives = List.zip_exn (drop_1_right chained) (List.tl_exn chained) in
+  List.iter consecutives ~f:(fun (d1, d2) -> assert_dominoes_match d1 d2)
+
+let assert_empty c = if List.is_empty c then () else failwith "Expected 0 length chain"
+
+let assert_valid_chain input _ctxt =
+  match chain input with
+  | None -> failwith "Expecting a chain"
+  | Some(c) -> (if List.is_empty input then assert_empty else check_chain) c  
+
+let assert_no_chain input _ctxt =
+  assert_equal None (chain input) ~printer:option_printer
+
+let assert_chain input hasChain =
+  if hasChain then assert_valid_chain input else assert_no_chain input
+
+let tests = [
+(* TEST
+  "$description" >::
+    assert_chain $input $expected;
+END TEST *)
+]
+
+let () =
+  run_test_tt_main ("dominoes tests" >::: tests)

data/tracks/ocaml/tools/test-generator/test/parser_test.ml

@@ -12,101 +12,107 @@ let ae exp got _test_ctxt = assert_equal exp got ~printer:show_cases
 
 let single x = Ok (Single x)
 
+let call_parser json = parse_json_text json "expected"
+
 let parser_tests = [
   "parses empty json as empty list" >::
-    ae (single []) (parse_json_text "{\"cases\" : []}");
+    ae (single []) (call_parser "{\"cases\" : []}");
 
   "gives an error with a json map that does not have the key cases in" >::
     ae (Error (TestMustHaveKeyCalledCases "case"))
-       (parse_json_text "{\"case\" : [{\"description\" : \"d1\", \"expected\" : 100}]}");
+       (call_parser "{\"case\" : [{\"description\" : \"d1\", \"expected\" : 100}]}");
 
   "gives an error with cases that is not a json list" >::
     ae (Error ExpectingListOfCases)
-       (parse_json_text "{\"cases\" : 11}");
+       (call_parser "{\"cases\" : 11}");
 
   "gives an error with a case that is not a json map" >::
     ae (Error ExpectingMapForCase)
-       (parse_json_text "{\"cases\" : [\"key\"]}");
+       (call_parser "{\"cases\" : [\"key\"]}");
 
   "parses a single element with a description and expected string output" >::
     ae (single [{description = "d1"; parameters = []; expected = String "value"}])
-       (parse_json_text "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : \"value\"}]}");
+       (call_parser "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : \"value\"}]}");
 
   "parses a single element with a description and expected float output" >::
     ae (single [{description = "d1"; parameters = []; expected = Float 100.}])
-       (parse_json_text "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : 100.0}]}");
+       (call_parser "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : 100.0}]}");
 
   "parses a single element with a description and expected bool output" >::
     ae (single [{description = "d1"; parameters = []; expected = Bool true}])
-      (parse_json_text "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : true}]}");
+      (call_parser "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : true}]}");
 
   "parses a single element with a description and expected int list output" >::
     ae (single [{description = "d1"; parameters = []; expected = IntList [1;2;3]}])
-      (parse_json_text "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : [1, 2, 3]}]}");
+      (call_parser "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : [1, 2, 3]}]}");
 
   "parses a single element with a description and expected null output" >::
     ae (single [{description = "d1"; parameters = []; expected = Null}])
-      (parse_json_text "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : null}]}");
+      (call_parser "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : null}]}");
 
   "parses a single element with an int key value pair" >::
     ae (single [{description = "d1"; parameters = [("input", Int 1996)]; expected = Bool true}])
-      (parse_json_text "{\"cases\" : [{\"description\" : \"d1\", \"input\" : 1996, \"expected\" : true}]}");
+      (call_parser "{\"cases\" : [{\"description\" : \"d1\", \"input\" : 1996, \"expected\" : true}]}");
 
   "parses a single element with a string key value pair" >::
     ae (single [{description = "d1"; parameters = [("input", String "some-string")]; expected = Int 85}])
-      (parse_json_text "{\"cases\" : [{\"description\" : \"d1\", \"input\" : \"some-string\", \"expected\" : 85}]}");
+      (call_parser "{\"cases\" : [{\"description\" : \"d1\", \"input\" : \"some-string\", \"expected\" : 85}]}");
 
   "parses a single element with a string list key value pair" >::
     ae (single [{description = "d1"; parameters = [("input", StringList ["s1"; "s2"])]; expected = Int 85}])
-      (parse_json_text "{\"cases\" : [{\"description\" : \"d1\", \"input\" : [\"s1\", \"s2\"], \"expected\" : 85}]}");
+      (call_parser "{\"cases\" : [{\"description\" : \"d1\", \"input\" : [\"s1\", \"s2\"], \"expected\" : 85}]}");
+
+  "parses a single element with a int tuple list (modelled as an int list) key value pair" >::
+    ae (single [{description = "d1"; parameters = [("input", IntTupleList [(1,2);(3,4)])]; expected = Int 85}])
+      (call_parser "{\"cases\" : [{\"description\" : \"d1\", \"input\" : [[1,2],[3,4]], \"expected\" : 85}]}");
 
   "an element without a description is an Error" >::
     ae (Error NoDescription)
-      (parse_json_text "{\"cases\" : [{\"input\" : 11, \"expected\" : 85}]}");
+      (call_parser "{\"cases\" : [{\"input\" : 11, \"expected\" : 85}]}");
 
   "an element with a description which is an int is an Error" >::
     ae (Error BadDescription)
-      (parse_json_text "{\"cases\" : [{\"description\" : 1, \"input\" : 11, \"expected\" : 85}]}");
+      (call_parser "{\"cases\" : [{\"description\" : 1, \"input\" : 11, \"expected\" : 85}]}");
 
   "an element without description is an Error" >::
     ae (Error NoDescription)
-      (parse_json_text "{\"cases\" : [{\"input\" : 11}]}");
+      (call_parser "{\"cases\" : [{\"input\" : 11}]}");
 
   "parses a map in the expected parameter" >::(fun _ctx ->
       assert_equal (single [{description = "d1"; parameters = []; expected = IntStringMap [("one", 1); ("two", 2)]}])
-        (parse_json_text "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : {\"one\": 1, \"two\": 2}}]}");
+        (call_parser "{\"cases\" : [{\"description\" : \"d1\", \"expected\" : {\"one\": 1, \"two\": 2}}]}");
       );
 
   "parses leap.json" >::(fun ctxt ->
-      match parse_json_text @@ In_channel.read_all "test/leap.json" with
+      match call_parser @@ In_channel.read_all "test/leap.json" with
       | Ok (Single p) -> assert_equal 7 (List.length p)
       | Ok (Suite p) -> assert_failure "was suite"
       | Error e -> assert_failure ("failed to parse leap.json: " ^ show_error e)
   );
 
   "parses hello_world.json which has a # element as documentation" >::(fun ctxt ->
-      match parse_json_text @@ In_channel.read_all "test/hello_world.json" with
+      match call_parser @@ In_channel.read_all "test/hello_world.json" with
       | Ok (Single p) -> ()
       | Ok (Suite p) -> assert_failure "was suite"
       | Error e -> assert_failure ("failed to parse hello_world.json: " ^ show_error e)
     );
 
   "parses difference_of_squares.json" >::(fun ctxt ->
-      match parse_json_text @@ In_channel.read_all "test/difference_of_squares.json" with
+      match call_parser @@ In_channel.read_all "test/difference_of_squares.json" with
       | Ok (Suite p) -> assert_equal ["square_of_sum"; "sum_of_squares"; "difference_of_squares"] (List.map ~f:(fun x -> x.name) p)
       | Ok (Single p) -> assert_failure "was single"
       | Error e -> assert_failure ("failed to parse difference_of_squares.json: " ^ show_error e)
     );
 
   "parses clock.json" >::(fun ctxt ->
-      match parse_json_text @@ In_channel.read_all "test/clock.json" with
+      match call_parser @@ In_channel.read_all "test/clock.json" with
       | Ok (Suite p) -> assert_equal ["create"; "add"; "equal"] (List.map ~f:(fun x -> x.name) p)
       | Ok (Single p) -> assert_failure "was single"
       | Error e -> assert_failure ("failed to parse clock.json: " ^ show_error e)
     );
 
   "parses json with a methods key for dynamic languages" >::(fun ctxt ->
-      match parse_json_text @@ In_channel.read_all "test/with-methods-key.json" with
+      match call_parser @@ In_channel.read_all "test/with-methods-key.json" with
       | Ok (Suite p) -> assert_failure "was suite"
       | Ok (Single p) -> ()
       | Error e -> assert_failure ("failed to parse with-methods-key.json: " ^ show_error e)

data/tracks/pony/config.json

@@ -45,6 +45,11 @@
       "difficulty": 1,
       "slug": "anagram",
       "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "rna-transcription",
+      "topics": []
     }
   ]
 }

data/tracks/pony/docs/ABOUT.md

@@ -0,0 +1,12 @@
+[Pony](http://www.ponylang.org) is an object-oriented, actor-model, capabilities-secure programming language focused on geting stuff done.
+
+It's object-oriented because it has classes and objects, like Python, Java, C++, and many other languages. It's actor-model because it has actors (similar to Erlang or Akka). These behave like objects, but they can also execute code asynchronously. Actors make Pony awesome.
+When we say Pony is capabilities-secure, we mean a few things:
+
+- It's type safe. Really type safe. There's a mathematical proof and everything.
+- It's memory safe. Ok, this comes with type safe, but it's still interesting. There are no dangling pointers, no buffer overruns, heck, the language doesn't even have the concept of null!
+- It's exception safe. There are no runtime exceptions. All exceptions have defined semantics, and they are always handled.
+- It's data-race free. Pony doesn't have locks or atomic operations or anything like that. Instead, the type system ensures at compile time that your concurrent program can never have data races. So you can write highly concurrent code and never get it wrong.
+- It's deadlock free. This one is easy, because Pony has no locks at all! So they definitely don't deadlock, because they don't exist.
+
+Newcomers should start with the [tutorial](https://tutorial.ponylang.org/).

data/tracks/pony/docs/INSTALLATION.md

@@ -1,14 +1,12 @@
-## Installation from Package
+## Installing the Pony Compiler
 
-### Mac OS X
-
-The Pony compiler (ponyc) is available for install using Homebrew!
+### Homebrew on Mac OS X
 
 ```bash
 brew update
 brew install ponyc
 ```
 
-## Installation from Source
+### Other Platforms
 
-Instructions for installing Pony from source on Windows, Mac OS X, Linux, and FreeBSD can be found in the [installation instructions in the Pony tutorial.]( http://tutorial.ponylang.org/getting-started/installation.html)
+Instructions for installing Pony can be found in the [ponyc installation](https://github.com/ponylang/ponyc/blob/master/README.md#installation)

data/tracks/pony/docs/LEARNING.md

@@ -0,0 +1,7 @@
+## Resources for Learning Pony:
+
+- [The Pony Tutorial](https://tutorial.ponylang.org/)
+- [Pony Patterns](https://patterns.ponylang.org/)
+- [Standard Library Documentation](http://www.ponylang.org/ponyc/)
+- [Mailing List](https://pony.groups.io/g/pony)
+- [IRC Channel](https://webchat.freenode.net/?channels=%23ponylang)

data/tracks/pony/docs/RESOURCES.md

@@ -0,0 +1,7 @@
+## Resources for Learning Pony
+
+- [The Pony Tutorial](https://tutorial.ponylang.org/)
+- [Pony Patterns](https://patterns.ponylang.org/)
+- [Standard Library Documentation](http://www.ponylang.org/ponyc/)
+- [Mailing List](https://pony.groups.io/g/pony)
+- [IRC Channel](https://webchat.freenode.net/?channels=%23ponylang)

data/tracks/pony/docs/TESTS.md

@@ -0,0 +1,11 @@
+## Running tests
+
+To compile and run the tests, just run the following in your exercise directory:
+```bash
+$ ponyc
+$ ./exercise-name
+```
+
+(Replace `exercise-name` with the name of the exercise directory)
+
+The compiled binary runs the tests in its Main actor, so just run the binary and see if your tests passed. Pony checks all code at compile time, so you may find that your tests won't compile until you write the required code. You can comment out tests that won't compile by starting each line with a `//`. Then, when you're ready to work on that test, you can un-comment it.

data/tracks/pony/exercises/hamming/test.pony

@@ -36,5 +36,5 @@ class iso _HammingDistanceTest is UnitTest
   fun name(): String => "hamming/Hamming"
 
   fun apply(h: TestHelper) =>
-    h.assert_error(lambda()? => Hamming("GAT", "GA") end)
-    h.assert_error(lambda()? => Hamming("GA", "GAC") end)
+    h.assert_error({()? => Hamming("GAT", "GA")})
+    h.assert_error({()? => Hamming("GA", "GAC")})

data/tracks/pony/exercises/rna-transcription/example.pony

@@ -0,0 +1,13 @@
+primitive ToRNA
+  fun apply(dna: String): String ? =>
+    let rna = recover String(dna.size()) end
+    for b in dna.values() do
+      rna.push(match b
+      | 'A' => 'U'
+      | 'T' => 'A'
+      | 'C' => 'G'
+      | 'G' => 'C'
+      else error
+      end)
+    end
+    rna

data/tracks/pony/exercises/rna-transcription/test.pony

@@ -0,0 +1,32 @@
+use "ponytest"
+
+actor Main is TestList
+  new create(env: Env) =>
+    PonyTest(env, this)
+
+  fun tag tests(test: PonyTest) =>
+    test(_TestRNATrancription)
+
+class iso _TestRNATrancription is UnitTest
+  fun name(): String => "rna-transcription"
+
+  fun apply(h: TestHelper) ? =>
+    let tests = [
+      // rna complement of cytosine is guanine
+      ("C", "G"),
+      // rna complement of guanine is cytosine
+      ("G", "C"),
+      // rna complement of thymine is adenine
+      ("T", "A"),
+      // rna complement of adenine is uracil
+      ("A", "U"),
+      // rna complement
+      ("ACGTGGTCTTAA", "UGCACCAGAAUU")
+    ]
+
+    for (input, expected) in tests.values() do
+      h.assert_eq[String](ToRNA(input), expected)
+    end
+
+    h.assert_error({() ? => ToRNA("U")})
+    h.assert_error({() ? => ToRNA("ACGTXXXCTTAA")})

data/tracks/r/exercises/anagram/example.R

@@ -1,3 +1,19 @@
-anagram <- function() {
-
+anagram <- function(subject,candidates) {
+  # subject is a string
+  # candidates is a character vector
+  # break subject into vector of characters
+  subject <- tolower(subject)
+  test_candidates <- tolower(candidates)
+  l <- strsplit(subject,"")[[1]]
+  # sub out each character from l in candidates
+  for (i in l) {
+    test_candidates <- sub(i,"",test_candidates)
+  }
+  result <- candidates[test_candidates=="" &
+                         tolower(candidates) != subject &
+                         nchar(candidates) == length(l)]
+  if (length(result)==0) {
+    return(c())
+  }
+  return(result)
 }

data/tracks/r/exercises/bob/example.R

@@ -1,3 +1,18 @@
-bob <- function() {
+bob <- function(input) {
+  # function bob takes a character input and responds
+  # with a couple different sentences
 
+  # strip white space
+  input <- gsub("[[:space:]]","",input)
+
+  if (input == "") {
+    return("Fine. Be that way!")
+  }
+  if (toupper(input) == input && tolower(input) != input) {
+    return("Whoa, chill out!")
+  }
+  if (endsWith(input,"?")) {
+    return("Sure.")
+  }
+  return("Whatever.")
 }

data/tracks/r/exercises/luhn/example.R

@@ -1,19 +1,35 @@
 # Convert a number to a valid number, if it isn't already.
-luhn <- function() {
-
+luhn <- function(input) {
+  if (is_valid(input)) {
+    return(input)
+  }
+  diff <- (10 - checksum(10*input)) %% 10
+  return(10 * input + diff)
 }
 
 # Get the check digit
-check_digit <- function() {
-
+check_digit <- function(input) {
+  as.numeric(substring(input,nchar(input))) 
 }
 
 # Compute the checksum
-checksum <- function() {
-
+checksum <- function(input) {
+  sum(addends(input))
 }
 
 # Determine whether the number is valid.
-is_valid <- function() {
+is_valid <- function(input) {
+  checksum(input) %% 10 == 0
+}
 
+# addends returns the vector of numbers that follow the luhn algorithm
+addends <- function(input) {
+  check <- check_digit(input)
+  v <- as.numeric(strsplit(as.character(input),"")[[1]])
+  # counting from right double value of every second digit
+  start_seq <- ifelse(length(v) %% 2 == 1, 0, 1)
+  v2 <- replace(v,seq(start_seq,length(v),2),v[seq(start_seq,length(v),2)]*2)
+  v2 <- ifelse(v2 > 9, v2 - 9, v2)
+  replace_vals <- v2[seq(start_seq,length(v),2)]
+  replace(v,seq(start_seq,length(v),2),replace_vals)
 }