trackler 2.2.1.116 → 2.2.1.117

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

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

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

@@ -1,29 +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 abstract class Cell() {
+        shared formal Element currentValue;
     }
-
-    shared new double(Cell c1, Cell c2, Element(Element, Element) f) extends Cell() {
+    
+    shared class InputCell(Element initialValue) extends Cell() {
+        shared actual variable Element currentValue = nothing;
     }
-
-    shared alias Callback => Anything(Element);
-
-    shared actual Element currentValue = nothing;
-
-    shared interface Subscription {
-      shared formal void cancel();
+    
+    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;
+        }
     }
-
-    shared Subscription addCallback(Callback f) {
-      return nothing;
-    }
-  }
 }

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

@@ -1,197 +1,218 @@
-import ceylon.test { ... }
+import ceylon.test {
+    ...
+}
 
-// Tests adapted from problem-specifications version 1.1.0
+// Tests adapted from problem-specifications version 1.2.0
 
 test
 void inputCellsHaveValue() {
-  value r = Reactor<Integer>();
-  value input = r.InputCell(10);
-  assertEquals(input.currentValue, 10);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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]);
+    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, []);
+    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]);
+}
 
-  input.currentValue = 4;
-  assertEquals(vals, [222]);
+test
+void callbacksCanBeCalledMultipleTimes() {
+    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 = 2;
+    assertEquals(vals, [3]);
+    
+    input.currentValue = 3;
+    assertEquals(vals, [3, 4]);
 }
 
 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]);
+    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;
+    
+    assertEquals(vals1, [32]);
+    assertEquals(vals2, [32]);
+    
+    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]);
+    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]);
+    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, []);
+    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]
+    [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`)
+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);
+    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

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

data/tracks/ceylon/exercises/rna-transcription/example/RNA.ceylon

@@ -1,13 +1,15 @@
 class Error() {}
 
 String|Error transcription(String dna) {
-  return dna.fold("" of String|Error)((String|Error r,
-                                       Character    c) =>   if (is Error r)
-                                                          then (r)
-                                                          else (switch (c)
-                                                                case ('G') r + "C"
-                                                                case ('C') r + "G"
-                                                                case ('T') r + "A"
-                                                                case ('A') r + "U"
-                                                                else (Error())));
+    return dna.fold("" of String|Error)((String|Error r, Character c) =>
+            if (is Error r)
+            then r
+            else (switch (c)
+                        case ('G') r + "C"
+                        case ('C') r + "G"
+                        case ('T') r + "A"
+                        case ('A') r + "U"
+                        else Error()
+                )
+    );
 }

data/tracks/ceylon/exercises/rna-transcription/source/rnatranscription/RNA.ceylon

@@ -1,5 +1,5 @@
 class Error() {}
 
 String|Error transcription(String dna) {
-  return nothing;
+    return nothing;
 }