react: complete exercise

Author: petertseng

exercises/react/example/Reactor.ceylon

@@ -1,3 +1,5 @@
+import ceylon.collection { HashMap, MutableMap }
+
 alias Element => Integer;
 
 class Reactor() {
@@ -20,6 +22,7 @@ class Reactor() {
     assign currentValue {
       currentValue_ = currentValue;
       eachDependent((d) => d.propagate());
+      eachDependent((d) => d.fireCallbacks());
     }
   }
 
@@ -28,16 +31,46 @@ class Reactor() {
   }
 
   shared class ComputeCell(Element() newValue) extends Cell() {
+    shared alias Callback => Anything(Element);
+
     variable Element currentValue_ = newValue();
+    variable Element lastCallbackValue = currentValue_;
     shared actual Element currentValue => currentValue_;
 
+    variable Integer callbacksIssued = 0;
+    variable MutableMap<Integer, Callback> activeCallbacks = HashMap<Integer, Callback>();
+
+    shared interface Subscription {
+      shared formal void cancel();
+    }
+
+    shared Subscription addCallback(Callback f) {
+      value id = callbacksIssued;
+      callbacksIssued++;
+      activeCallbacks.put(id, f);
+      return object satisfies Subscription {
+        cancel() => activeCallbacks.remove(id);
+      };
+    }
+
     shared void propagate() {
       value 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());
+    }
   }
 
   shared ComputeCell newComputeCell1(Cell c, Element(Element) f) {

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";
+}

exercises/react/source/react/Reactor.ceylon

@@ -1 +1,37 @@
-// TODO
+alias Element => Integer;
+
+class Reactor() {
+  shared abstract class Cell() {
+    shared formal Element currentValue;
+  }
+
+  shared class InputCell(Element initialValue) extends Cell() {
+    shared actual variable Element currentValue = nothing;
+  }
+
+  shared InputCell newInputCell(Element initialValue) {
+    return nothing;
+  }
+
+  shared class ComputeCell(Element() newValue) 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 ComputeCell newComputeCell1(Cell c, Element(Element) f) {
+    return nothing;
+  }
+
+  shared ComputeCell newComputeCell2(Cell c1, Cell c2, Element(Element, Element) f) {
+    return nothing;
+  }
+}

exercises/react/source/react/ReactorTest.ceylon

@@ -40,3 +40,98 @@ void computeCellsUpdateValueWhenDependenciesChange() {
   input.currentValue = 3;
   assertEquals(output.currentValue, 4);
 }
+
+test
+void computeCellsCanDependOnOtherComputeCells() {
+  value r = Reactor();
+  value input = r.newInputCell(1);
+  value timesTwo = r.newComputeCell1(input, (x) => x * 2);
+  value timesThirty = r.newComputeCell1(input, (x) => x * 30);
+  value output = r.newComputeCell2(timesTwo, timesThirty, (x, y) => x + y);
+
+  assertEquals(output.currentValue, 32);
+  input.currentValue = 3;
+  assertEquals(output.currentValue, 96);
+}
+
+test
+void computeCellsFireCallbacks() {
+  value r = Reactor();
+  value input = r.newInputCell(1);
+  value output = r.newComputeCell1(input, (x) => x + 1);
+
+  variable Element[] vals = [];
+  output.addCallback((x) => vals = vals.withTrailing(x));
+
+  input.currentValue = 3;
+  assertEquals(vals, [4]);
+}
+
+test
+void callbacksOnlyFireOnChange() {
+  value r = Reactor();
+  value input = r.newInputCell(1);
+  value output = r.newComputeCell1(input, (x) => if (x < 3) then 111 else 222);
+
+  variable Element[] vals = [];
+  output.addCallback((x) => vals = vals.withTrailing(x));
+
+  input.currentValue = 2;
+  assertEquals(vals, []);
+
+  input.currentValue = 4;
+  assertEquals(vals, [222]);
+}
+
+test
+void removingCallbackMultipleTimesDoesntInterfereWithOtherCallbacks() {
+  value r = Reactor();
+  value input = r.newInputCell(1);
+  value output = r.newComputeCell1(input, (x) => x + 1);
+
+  variable Element[] vals1 = [];
+  value sub1 = output.addCallback((x) => vals1 = vals1.withTrailing(x));
+  variable Element[] 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();
+  value input = r.newInputCell(1);
+  value plusOne = r.newComputeCell1(input, (x) => x + 1);
+  value minusOne1 = r.newComputeCell1(input, (x) => x - 1);
+  value minusOne2 = r.newComputeCell1(minusOne1, (x) => x - 1);
+  value output = r.newComputeCell2(plusOne, minusOne2, (x, y) => x * y);
+
+  variable Element[] vals = [];
+  output.addCallback((x) => vals = vals.withTrailing(x));
+
+  input.currentValue = 4;
+  assertEquals(vals, [10]);
+}
+
+test
+void callbacksAreNotCalledIfDependenciesChangeButOutputValueDoesntChange() {
+  value r = Reactor();
+  value input = r.newInputCell(1);
+  value plusOne = r.newComputeCell1(input, (x) => x + 1);
+  value minusOne = r.newComputeCell1(input, (x) => x - 1);
+  value alwaysTwo = r.newComputeCell2(plusOne, minusOne, (x, y) => x - y);
+
+  variable Element[] vals = [];
+  alwaysTwo.addCallback((x) => vals = vals.withTrailing(x));
+
+  for (i in 1..10) {
+    input.currentValue = i;
+  }
+  assertEquals(vals, []);
+}