trackler 2.0.6.14 → 2.0.6.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b4773a317ee74fec5189add40d22bdb0810d4d5b
-  data.tar.gz: efb405ccd313b9bd85d8e49a64f95e73685465a0
+  metadata.gz: d2be37cbc31136941811e051179467879b92babc
+  data.tar.gz: 14dfc0634c8eacfb96344447eb05bc63dfaafe3d
 SHA512:
-  metadata.gz: df8a85473aed5805295b688533608f1bf7018764f6a030987c4a94805266c2996ea55764a039ae12f8dad321455d085af0ea5fbbf6b45f5e7b2f4756916c8506
-  data.tar.gz: a832b5beb59c5e7f4c2f72b8d6e7b0ddd681cca16fcb814d9372e98f055f36d0a8bba906e86eb97772de95ce7fab6306d8df3fcf11425d4a9b38dc58e356d9fa
+  metadata.gz: f9e6fcb733742f7201eca5aff89b7e19de23e040ff3809a77aff1459483226f59b2bab528e70b862149656512677e018025f367be6233c23dfb2e8769b6f9ed5
+  data.tar.gz: b39e788481896ab1b612425a7922dd249defb2c7b6c30091c15b9deeca895ecfc421372d2023c11bfde097ec4297166b9e5917949774a83697ddba7c8d0ea40c

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.6.14"
+  VERSION = "2.0.6.15"
 end

data/tracks/ceylon/.travis.yml

@@ -7,4 +7,5 @@ install:
   - sdk install ceylon
 script:
   - bin/configlet .
+  - bin/compile-all-stubs
   - bin/test-all-exercises

data/tracks/ceylon/bin/compile-all-stubs

@@ -0,0 +1,16 @@
+#!/bin/sh
+
+exercises=$(dirname $(dirname $0))/exercises
+status=0
+
+dir=$(pwd)
+
+for d in $exercises/*/; do
+  cd $d
+  if ! ceylon compile; then
+    status=1
+  fi
+  cd $dir
+done
+
+exit $status

data/tracks/ceylon/config.json

@@ -44,6 +44,17 @@
         "Stacks",
         "Strings"
       ]
+    },
+    {
+      "slug": "react",
+      "difficulty": 10,
+      "topics": [
+        "Reactive programming",
+        "Generics",
+        "Classes",
+        "Member classes",
+        "Callable"
+      ]
     }
   ],
   "deprecated": [

data/tracks/ceylon/exercises/react/example/Reactor.ceylon

@@ -0,0 +1,96 @@
+import ceylon.collection { HashMap, MutableMap }
+
+class Reactor<Element>() given Element satisfies Object {
+  shared abstract class Cell() {
+    shared formal Element currentValue;
+    variable ComputeCell.Inner[] dependents = [];
+    shared default void addDependent(ComputeCell.Inner c) {
+      dependents = dependents.withTrailing(c);
+    }
+    shared void eachDependent(Anything(ComputeCell.Inner) f) {
+      for (dep in dependents) {
+        f(dep);
+      }
+    }
+  }
+
+  shared class InputCell(Element initialValue) extends Cell() {
+    variable Element currentValue_ = initialValue;
+    shared actual Element currentValue => currentValue_;
+    assign currentValue {
+      currentValue_ = currentValue;
+      eachDependent((d) => d.propagate());
+      eachDependent((d) => d.fireCallbacks());
+    }
+  }
+
+  shared class ComputeCell extends Cell {
+    shared alias Callback => Anything(Element);
+
+    shared interface Subscription {
+      shared formal void cancel();
+    }
+
+    shared class Inner(Element() newValue) extends Cell() {
+      variable Element currentValue_ = newValue();
+      shared actual Element currentValue => currentValue_;
+      variable Element lastCallbackValue = currentValue_;
+
+      variable Integer callbacksIssued = 0;
+      variable MutableMap<Integer, Callback> activeCallbacks = HashMap<Integer, Callback>();
+
+      shared Subscription addCallback(Callback f) {
+        value id = callbacksIssued;
+        callbacksIssued++;
+        activeCallbacks.put(id, f);
+        return object satisfies Subscription {
+          cancel() => activeCallbacks.remove(id);
+        };
+      }
+
+      shared void propagate() {
+        Element nv = newValue();
+        if (nv != currentValue) {
+          currentValue_ = nv;
+          eachDependent((d) => d.propagate());
+        }
+      }
+
+      shared void fireCallbacks() {
+        if (lastCallbackValue == currentValue) {
+          return;
+        }
+        lastCallbackValue = currentValue;
+        for (cb in activeCallbacks.items) {
+          cb(currentValue);
+        }
+        eachDependent((d) => d.fireCallbacks());
+      }
+    }
+
+    Inner inner;
+
+    shared new single(Cell c, Element(Element) f) extends Cell() {
+      // Since `c.addDependent(this)` is illegal, we have to create an inner cell.
+      inner = Inner(() => f(c.currentValue));
+      c.addDependent(inner);
+    }
+
+    shared new double(Cell c1, Cell c2, Element(Element, Element) f) extends Cell() {
+      // Since `c.addDependent(this)` is illegal, we have to create an inner cell.
+      inner = Inner(() => f(c1.currentValue, c2.currentValue));
+      c1.addDependent(inner);
+      c2.addDependent(inner);
+    }
+
+    shared actual Element currentValue => inner.currentValue;
+
+    shared Subscription addCallback(Callback f) {
+      return inner.addCallback(f);
+    }
+
+    shared actual void addDependent(ComputeCell.Inner c) {
+      inner.addDependent(c);
+    }
+  }
+}

data/tracks/ceylon/exercises/react/example/module.ceylon

@@ -0,0 +1,4 @@
+module react "1.0" {
+  import "ceylon.collection" "1.3.1";
+  import "ceylon.test" "1.3.1";
+}

data/tracks/ceylon/exercises/react/source/react/Reactor.ceylon

@@ -0,0 +1,29 @@
+class Reactor<Element>() given Element satisfies Object {
+  shared abstract class Cell() {
+    shared formal Element currentValue;
+  }
+
+  shared class InputCell(Element initialValue) extends Cell() {
+    shared actual variable Element currentValue = nothing;
+  }
+
+  shared class ComputeCell extends Cell {
+    shared new single(Cell c, Element(Element) f) extends Cell() {
+    }
+
+    shared new double(Cell c1, Cell c2, Element(Element, Element) f) extends Cell() {
+    }
+
+    shared alias Callback => Anything(Element);
+
+    shared actual Element currentValue = nothing;
+
+    shared interface Subscription {
+      shared formal void cancel();
+    }
+
+    shared Subscription addCallback(Callback f) {
+      return nothing;
+    }
+  }
+}

data/tracks/ceylon/exercises/react/source/react/ReactorTest.ceylon

@@ -0,0 +1,195 @@
+import ceylon.test { ... }
+
+test
+void inputCellsHaveValue() {
+  value r = Reactor<Integer>();
+  value input = r.InputCell(10);
+  assertEquals(input.currentValue, 10);
+}
+
+test
+void inputCellsCanHaveValuesSet() {
+  value r = Reactor<Integer>();
+  value input = r.InputCell(4);
+  input.currentValue = 20;
+  assertEquals(input.currentValue, 20);
+}
+
+test
+void computeCellsCalculateInitialValue() {
+  value r = Reactor<Integer>();
+  value input = r.InputCell(1);
+  value output = r.ComputeCell.single(input, (Integer x) => x + 1);
+  assertEquals(output.currentValue, 2);
+}
+
+test
+void computeCellsTakeInputInRightOrder() {
+  value r = Reactor<Integer>();
+  value one = r.InputCell(1);
+  value two = r.InputCell(2);
+  value output = r.ComputeCell.double(one, two, (Integer x, Integer y) => x + y * 10);
+  assertEquals(output.currentValue, 21);
+}
+
+test
+void computeCellsUpdateValueWhenDependenciesChange() {
+  value r = Reactor<Integer>();
+  value input = r.InputCell(1);
+  value output = r.ComputeCell.single(input, (Integer x) => x + 1);
+  input.currentValue = 3;
+  assertEquals(output.currentValue, 4);
+}
+
+test
+void computeCellsCanDependOnOtherComputeCells() {
+  value r = Reactor<Integer>();
+  value input = r.InputCell(1);
+  value timesTwo = r.ComputeCell.single(input, (Integer x) => x * 2);
+  value timesThirty = r.ComputeCell.single(input, (Integer x) => x * 30);
+  value output = r.ComputeCell.double(timesTwo, timesThirty, (Integer x, Integer y) => x + y);
+
+  assertEquals(output.currentValue, 32);
+  input.currentValue = 3;
+  assertEquals(output.currentValue, 96);
+}
+
+test
+void computeCellsFireCallbacks() {
+  value r = Reactor<Integer>();
+  value input = r.InputCell(1);
+  value output = r.ComputeCell.single(input, (Integer x) => x + 1);
+
+  variable Integer[] vals = [];
+  output.addCallback((x) => vals = vals.withTrailing(x));
+
+  input.currentValue = 3;
+  assertEquals(vals, [4]);
+}
+
+test
+void callbacksOnlyFireOnChange() {
+  value r = Reactor<Integer>();
+  value input = r.InputCell(1);
+  value output = r.ComputeCell.single(input, (Integer x) => if (x < 3) then 111 else 222);
+
+  variable Integer[] vals = [];
+  output.addCallback((x) => vals = vals.withTrailing(x));
+
+  input.currentValue = 2;
+  assertEquals(vals, []);
+
+  input.currentValue = 4;
+  assertEquals(vals, [222]);
+}
+
+test
+void callbacksCanBeAddedAndRemoved() {
+  value r = Reactor<Integer>();
+  value input = r.InputCell(11);
+  value output = r.ComputeCell.single(input, (Integer x) => x + 1);
+
+  variable Integer[] vals1 = [];
+  value sub1 = output.addCallback((x) => vals1 = vals1.withTrailing(x));
+  variable Integer[] vals2 = [];
+  output.addCallback((x) => vals2 = vals2.withTrailing(x));
+
+  input.currentValue = 31;
+
+  sub1.cancel();
+  variable Integer[] vals3 = [];
+  output.addCallback((x) => vals3 = vals3.withTrailing(x));
+
+  input.currentValue = 41;
+
+  assertEquals(vals1, [32]);
+  assertEquals(vals2, [32, 42]);
+  assertEquals(vals3, [42]);
+}
+
+test
+void removingCallbackMultipleTimesDoesntInterfereWithOtherCallbacks() {
+  value r = Reactor<Integer>();
+  value input = r.InputCell(1);
+  value output = r.ComputeCell.single(input, (Integer x) => x + 1);
+
+  variable Integer[] vals1 = [];
+  value sub1 = output.addCallback((x) => vals1 = vals1.withTrailing(x));
+  variable Integer[] vals2 = [];
+  output.addCallback((x) => vals2 = vals2.withTrailing(x));
+
+  for (i in 1..10) {
+    sub1.cancel();
+  }
+
+  input.currentValue = 2;
+  assertEquals(vals1, []);
+  assertEquals(vals2, [3]);
+}
+
+test
+void callbacksAreOnlyCalledOnceEvenIfMultipleDependenciesChange() {
+  value r = Reactor<Integer>();
+  value input = r.InputCell(1);
+  value plusOne = r.ComputeCell.single(input, (Integer x) => x + 1);
+  value minusOne1 = r.ComputeCell.single(input, (Integer x) => x - 1);
+  value minusOne2 = r.ComputeCell.single(minusOne1, (Integer x) => x - 1);
+  value output = r.ComputeCell.double(plusOne, minusOne2, (Integer x, Integer y) => x * y);
+
+  variable Integer[] vals = [];
+  output.addCallback((x) => vals = vals.withTrailing(x));
+
+  input.currentValue = 4;
+  assertEquals(vals, [10]);
+}
+
+test
+void callbacksAreNotCalledIfDependenciesChangeButOutputValueDoesntChange() {
+  value r = Reactor<Integer>();
+  value input = r.InputCell(1);
+  value plusOne = r.ComputeCell.single(input, (Integer x) => x + 1);
+  value minusOne = r.ComputeCell.single(input, (Integer x) => x - 1);
+  value alwaysTwo = r.ComputeCell.double(plusOne, minusOne, (Integer x, Integer y) => x - y);
+
+  variable Integer[] vals = [];
+  alwaysTwo.addCallback((x) => vals = vals.withTrailing(x));
+
+  for (i in 1..10) {
+    input.currentValue = i;
+  }
+  assertEquals(vals, []);
+}
+
+{[Boolean, Boolean, Boolean, Boolean, Boolean]*} adderCases => {
+  [false, false, false, false, false],
+  [false, false, true, false, true],
+  [false, true, false, false, true],
+  [false, true, true, true, false],
+  [true, false, false, false, true],
+  [true, false, true, true, false],
+  [true, true, false, true, false],
+  [true, true, true, true, true]
+};
+
+test
+parameters(`value adderCases`)
+// This is a digital logic circuit called an adder:
+// https://en.wikipedia.org/wiki/Adder_(electronics)
+void testAdder(Boolean aval, Boolean bval, Boolean cinval, Boolean expectCout, Boolean expectSum) {
+  value r = Reactor<Boolean>();
+  value a = r.InputCell(aval);
+  value b = r.InputCell(bval);
+  value carryIn = r.InputCell(cinval);
+
+  value aXorB = r.ComputeCell.double(a, b, (Boolean a, Boolean b) => a != b);
+  value sum = r.ComputeCell.double(aXorB, carryIn, (Boolean axorb, Boolean cin) => axorb != cin);
+
+  value aXorBAndCin = r.ComputeCell.double(aXorB, carryIn, (Boolean axorb, Boolean cin) => axorb && cin);
+  value aAndB = r.ComputeCell.double(a, b, (Boolean a, Boolean b) => a && b);
+  value carryOut = r.ComputeCell.double(aXorBAndCin, aAndB, (Boolean a, Boolean b) => a || b);
+
+  // Test them both at once so if they fail we get to see both values.
+  [Boolean, Boolean] expected = [expectSum, expectCout];
+  [Boolean, Boolean] observed = [sum.currentValue, carryOut.currentValue];
+  assertEquals(expected, observed);
+}

data/tracks/ceylon/exercises/react/source/react/module.ceylon

@@ -0,0 +1,3 @@
+module react "1.0" {
+  import "ceylon.test" "1.3.1";
+}

data/tracks/csharp/config.json

@@ -814,6 +814,15 @@
         "Transforming"
       ]
     },
+    {
+      "slug": "zipper",
+      "difficulty": 10,
+      "topics": [
+        "Trees",
+        "Recursion",
+        "Searching"
+      ]
+    },
     {
       "slug": "alphametics",
       "difficulty": 10,

data/tracks/csharp/exercises/pov/Example.cs

@@ -17,9 +17,9 @@ public class Graph<T> : IEquatable<Graph<T>>
         Value.Equals(other.Value) && Children.SequenceEqual(other.Children);
 }
 
-public class Crumb<T>
+public class GraphCrumb<T>
 {
-    public Crumb(T value, IEnumerable<Graph<T>> left, IEnumerable<Graph<T>> right)
+    public GraphCrumb(T value, IEnumerable<Graph<T>> left, IEnumerable<Graph<T>> right)
     {
         Value = value;
         Left = left;
@@ -31,16 +31,16 @@ public class Crumb<T>
     public IEnumerable<Graph<T>> Right { get; }
 }
 
-public class Zipper<T>
+public class GraphZipper<T>
 {
-    public Zipper(Graph<T> focus, IEnumerable<Crumb<T>> crumbs)
+    public GraphZipper(Graph<T> focus, IEnumerable<GraphCrumb<T>> crumbs)
     {
         Focus = focus;
         Crumbs = crumbs;
     }
 
     public Graph<T> Focus { get; }
-    public IEnumerable<Crumb<T>> Crumbs { get; }
+    public IEnumerable<GraphCrumb<T>> Crumbs { get; }
 }
 
 public static class Pov
@@ -54,15 +54,15 @@ public static class Pov
     public static IEnumerable<T> TracePathBetween<T>(T value1, T value2, Graph<T> graph) where T : IComparable
         => ZipperToPath(FindNode(value2, GraphToZipper(FromPOV(value1, graph))));
 
-    private static Zipper<T> GraphToZipper<T>(Graph<T> graph)
+    private static GraphZipper<T> GraphToZipper<T>(Graph<T> graph)
     {
         if (graph == null)
             return null;
 
-        return new Zipper<T>(graph, Enumerable.Empty<Crumb<T>>());
+        return new GraphZipper<T>(graph, Enumerable.Empty<GraphCrumb<T>>());
     }
 
-    private static IEnumerable<T> ZipperToPath<T>(Zipper<T> zipper)
+    private static IEnumerable<T> ZipperToPath<T>(GraphZipper<T> zipper)
     {
         if (zipper == null)
             return null;
@@ -70,7 +70,7 @@ public static class Pov
         return zipper.Crumbs.Select(c => c.Value).Reverse().Concat(new[] { zipper.Focus.Value });
     }
 
-    private static Zipper<T> GoDown<T>(Zipper<T> zipper)
+    private static GraphZipper<T> GoDown<T>(GraphZipper<T> zipper)
     {        
         if (zipper == null || !zipper.Focus.Children.Any())
             return null;
@@ -78,12 +78,12 @@ public static class Pov
         var focus = zipper.Focus;
         var children = focus.Children;
 
-        var newCrumb = new Crumb<T>(focus.Value, Enumerable.Empty<Graph<T>>(), children.Skip(1));
+        var newCrumb = new GraphCrumb<T>(focus.Value, Enumerable.Empty<Graph<T>>(), children.Skip(1));
 
-        return new Zipper<T>(children.First(), new[] { newCrumb }.Concat(zipper.Crumbs));
+        return new GraphZipper<T>(children.First(), new[] { newCrumb }.Concat(zipper.Crumbs));
     }
 
-    private static Zipper<T> GoRight<T>(Zipper<T> zipper)
+    private static GraphZipper<T> GoRight<T>(GraphZipper<T> zipper)
     {        
         if (zipper == null || !zipper.Crumbs.Any() || !zipper.Crumbs.First().Right.Any())
             return null;
@@ -91,12 +91,12 @@ public static class Pov
         var crumbs = zipper.Crumbs;
         var firstCrumb = crumbs.First();
 
-        var newCrumb = new Crumb<T>(firstCrumb.Value, firstCrumb.Left.Concat(new[] { zipper.Focus }), firstCrumb.Right.Skip(1));
+        var newCrumb = new GraphCrumb<T>(firstCrumb.Value, firstCrumb.Left.Concat(new[] { zipper.Focus }), firstCrumb.Right.Skip(1));
 
-        return new Zipper<T>(firstCrumb.Right.First(), new[] { newCrumb }.Concat(crumbs.Skip(1)));
+        return new GraphZipper<T>(firstCrumb.Right.First(), new[] { newCrumb }.Concat(crumbs.Skip(1)));
     }
 
-    private static Zipper<T> FindNode<T>(T value, Zipper<T> zipper)
+    private static GraphZipper<T> FindNode<T>(T value, GraphZipper<T> zipper)
         where T : IComparable
     {
         if (zipper == null || zipper.Focus.Value.CompareTo(value) == 0)
@@ -105,7 +105,7 @@ public static class Pov
         return FindNode(value, GoDown(zipper)) ?? FindNode(value, GoRight(zipper));
     }
 
-    private static Graph<T> ChangeParent<T>(Zipper<T> zipper)
+    private static Graph<T> ChangeParent<T>(GraphZipper<T> zipper)
     {
         if (zipper == null)
             return null;
@@ -116,7 +116,7 @@ public static class Pov
         var firstCrumb = zipper.Crumbs.First();
         var focus = zipper.Focus;
 
-        var newZipper = new Zipper<T>(CreateGraph(firstCrumb.Value, firstCrumb.Left.Concat(firstCrumb.Right)), zipper.Crumbs.Skip(1));
+        var newZipper = new GraphZipper<T>(CreateGraph(firstCrumb.Value, firstCrumb.Left.Concat(firstCrumb.Right)), zipper.Crumbs.Skip(1));
         var parentGraph = ChangeParent(newZipper);
 
         var ys = focus.Children.Concat(new[] { parentGraph });