trackler 2.2.1.135 → 2.2.1.136

data/tracks/python/exercises/react/react.py

@@ -1,17 +1,17 @@
-class Cell(object):
-    def set_value(value):
-        pass
+class InputCell(object):
+    def __init__(self, initial_value):
+        self.value = None
 
-    def add_watcher(self, watcher_callback):
-        pass
 
-    def remove_watcher(self, watcher_callback):
-        pass
+class ComputeCell(object):
+    def __init__(self, inputs, compute_function):
+        self.value = None
 
+    def add_callback(self, callback):
+        pass
 
-class Reactor(object):
-    def create_input_cell(self, value):
+    def remove_callback(self, callback):
         pass
 
-    def create_compute_cell(self, dependencies, updater_callback):
+    def expect_callback_values(self, callback):
         pass

data/tracks/python/exercises/react/react_test.py

@@ -1,135 +1,201 @@
 import unittest
-
-from react import Reactor
-
-
-class CallbackManager(object):
-    counter = 0
-    observed1 = []
-    observed2 = []
-
-    @staticmethod
-    def reset():
-        CallbackManager.counter = 0
-        CallbackManager.observed1 = []
-        CallbackManager.observed2 = []
-
-    @staticmethod
-    def count(sender, value):
-        CallbackManager.counter += 1
-
-    @staticmethod
-    def observe1(sender, value):
-        CallbackManager.observed1.append(value)
-
-    @staticmethod
-    def observe2(sender, value):
-        CallbackManager.observed2.append(value)
-
-
-def increment(values):
-    return values[0] + 1
-
-
-def decrement(values):
-    return values[0] - 1
-
-
-def product(values):
-    return values[0] * values[1]
-
-
-def minimum_of_2(values):
-    return values[0] + 1 if values[0] > 2 else 2
-
-
-class ReactTest(unittest.TestCase):
-    def test_setting_input_changes_value(self):
-        reactor = Reactor()
-        inputCell1 = reactor.create_input_cell(1)
-        self.assertEqual(inputCell1.value, 1)
-        inputCell1.set_value(2)
-        self.assertEqual(inputCell1.value, 2)
-
-    def test_computed_cell_determined_by_dependencies(self):
-        reactor = Reactor()
-        inputCell1 = reactor.create_input_cell(1)
-        computeCell1 = reactor.create_compute_cell({inputCell1}, increment)
-
-        self.assertEqual(computeCell1.value, 2)
-        inputCell1.set_value(2)
-        self.assertEqual(computeCell1.value, 3)
-
-    def test_compute_cells_determined_by_other_compute_cells(self):
-        reactor = Reactor()
-        inputCell1 = reactor.create_input_cell(1)
-        computeCell1 = reactor.create_compute_cell({inputCell1}, increment)
-        computeCell2 = reactor.create_compute_cell({inputCell1}, decrement)
-        computeCell3 = reactor.create_compute_cell({computeCell1,
-                                                    computeCell2},
-                                                   product)
-        self.assertEqual(computeCell3.value, 0)
-        inputCell1.set_value(3)
-        self.assertEqual(computeCell3.value, 8)
-
-    def test_compute_cells_can_have_callbacks(self):
-        reactor = Reactor()
-        inputCell1 = reactor.create_input_cell(1)
-        computeCell1 = reactor.create_compute_cell({inputCell1}, increment)
-        observed = []
-        computeCell1.add_watcher(lambda sender, value: observed.append(value))
-        self.assertEqual(observed, [])
-        inputCell1.set_value(2)
-        self.assertEqual(observed, [3])
-
-    def test_callbacks__only_trigger_on_change(self):
-        reactor = Reactor()
-        inputCell1 = reactor.create_input_cell(1)
-        computeCell1 = reactor.create_compute_cell({inputCell1}, minimum_of_2)
-
-        CallbackManager.reset()
-        computeCell1.add_watcher(CallbackManager.count)
-
-        inputCell1.set_value(1)
-        self.assertEqual(CallbackManager.counter, 0)
-        inputCell1.set_value(2)
-        self.assertEqual(CallbackManager.counter, 0)
-        inputCell1.set_value(3)
-        self.assertEqual(CallbackManager.counter, 1)
-
-    def test_callbacks_can_be_removed(self):
-        reactor = Reactor()
-        inputCell1 = reactor.create_input_cell(1)
-        computeCell1 = reactor.create_compute_cell({inputCell1}, increment)
-
-        CallbackManager.reset()
-        computeCell1.add_watcher(CallbackManager.observe1)
-        computeCell1.add_watcher(CallbackManager.observe2)
-
-        inputCell1.set_value(2)
-        self.assertEqual(CallbackManager.observed1, [3])
-        self.assertEqual(CallbackManager.observed2, [3])
-
-        computeCell1.remove_watcher(CallbackManager.observe1)
-        inputCell1.set_value(3)
-        self.assertEqual(CallbackManager.observed1, [3])
-        self.assertEqual(CallbackManager.observed2, [3, 4])
-
-    def test_callbacks_only_called_once(self):
-        reactor = Reactor()
-        inputCell1 = reactor.create_input_cell(1)
-        computeCell1 = reactor.create_compute_cell({inputCell1}, increment)
-        computeCell2 = reactor.create_compute_cell({inputCell1}, decrement)
-        computeCell3 = reactor.create_compute_cell({computeCell2}, decrement)
-        computeCell4 = reactor.create_compute_cell({computeCell1,
-                                                    computeCell3},
-                                                   product)
-
-        CallbackManager.reset()
-        computeCell4.add_watcher(CallbackManager.count)
-
-        inputCell1.set_value(3)
-        self.assertEqual(CallbackManager.counter, 1)
+from functools import partial
+
+from react import InputCell, ComputeCell
+
+
+# Tests adapted from `problem-specifications//canonical-data.json` @ v2.0.0
+
+class ReactTests(unittest.TestCase):
+
+    def test_input_cells_have_a_value(self):
+        input_ = InputCell(10)
+        self.assertEqual(input_.value, 10)
+
+    def test_can_set_input_cell_value(self):
+        input_ = InputCell(4)
+        input_.value = 20
+        self.assertEqual(input_.value, 20)
+
+    def test_compute_cells_calculate_initial_value(self):
+        input_ = InputCell(1)
+        output = ComputeCell([input_], lambda inputs: inputs[0] + 1)
+        self.assertEqual(output.value, 2)
+
+    def test_compute_cells_take_inputs_in_right_order(self):
+        one = InputCell(1)
+        two = InputCell(2)
+        output = ComputeCell(
+            [one, two],
+            lambda inputs: inputs[0] + inputs[1]*10
+        )
+        self.assertEqual(output.value, 21)
+
+    def test_compute_cells_update_value_when_dependencies_are_changed(self):
+        input_ = InputCell(1)
+        output = ComputeCell([input_], lambda inputs: inputs[0] + 1)
+
+        input_.value = 3
+        self.assertEqual(output.value, 4)
+
+    def test_compute_cells_can_depend_on_other_compute_cells(self):
+        input_ = InputCell(1)
+        times_two = ComputeCell([input_], lambda inputs: inputs[0] * 2)
+        times_thirty = ComputeCell([input_], lambda inputs: inputs[0] * 30)
+        output = ComputeCell(
+            [times_two, times_thirty],
+            lambda inputs: inputs[0] + inputs[1]
+        )
+
+        self.assertEqual(output.value, 32)
+        input_.value = 3
+        self.assertEqual(output.value, 96)
+
+    def test_compute_cells_fire_callbacks(self):
+        input_ = InputCell(1)
+        output = ComputeCell([input_], lambda inputs: inputs[0] + 1)
+
+        observer = []
+        callback1 = self.callback_factory(observer)
+
+        output.add_callback(callback1)
+        input_.value = 3
+        self.assertEqual(observer[-1], 4)
+
+    def test_callbacks_only_fire_on_change(self):
+        input_ = InputCell(1)
+        output = ComputeCell(
+            [input_],
+            lambda inputs: 111 if inputs[0] < 3 else 222
+        )
+
+        observer = []
+        callback1 = self.callback_factory(observer)
+
+        output.add_callback(callback1)
+        input_.value = 2
+        self.assertEqual(observer, [])
+        input_.value = 4
+        self.assertEqual(observer[-1], 222)
+
+    def test_callbacks_do_not_report_already_reported_values(self):
+        input_ = InputCell(1)
+        output = ComputeCell([input_], lambda inputs: inputs[0] + 1)
+
+        observer = []
+        callback1 = self.callback_factory(observer)
+
+        output.add_callback(callback1)
+        input_.value = 2
+        self.assertEqual(observer[-1], 3)
+        input_.value = 3
+        self.assertEqual(observer[-1], 4)
+
+    def test_callbacks_can_fire_from_multiple_cells(self):
+        input_ = InputCell(1)
+        plus_one = ComputeCell([input_], lambda inputs: inputs[0] + 1)
+        minus_one = ComputeCell([input_], lambda inputs: inputs[0] - 1)
+
+        cb1_observer, cb2_observer = [], []
+        callback1 = self.callback_factory(cb1_observer)
+        callback2 = self.callback_factory(cb2_observer)
+
+        plus_one.add_callback(callback1)
+        minus_one.add_callback(callback2)
+        input_.value = 10
+
+        self.assertEqual(cb1_observer[-1], 11)
+        self.assertEqual(cb2_observer[-1], 9)
+
+    def test_callbacks_can_be_added_and_removed(self):
+        input_ = InputCell(11)
+        output = ComputeCell([input_], lambda inputs: inputs[0] + 1)
+
+        cb1_observer, cb2_observer, cb3_observer = [], [], []
+        callback1 = self.callback_factory(cb1_observer)
+        callback2 = self.callback_factory(cb2_observer)
+        callback3 = self.callback_factory(cb3_observer)
+
+        output.add_callback(callback1)
+        output.add_callback(callback2)
+        input_.value = 31
+        self.assertEqual(cb1_observer[-1], 32)
+        self.assertEqual(cb2_observer[-1], 32)
+
+        output.remove_callback(callback1)
+        output.add_callback(callback3)
+        input_.value = 41
+        self.assertEqual(cb2_observer[-1], 42)
+        self.assertEqual(cb3_observer[-1], 42)
+
+        # Expect callback1 not to be called.
+        self.assertEqual(len(cb1_observer), 1)
+
+    def test_removing_a_callback_multiple_times(self):
+        """Guard against incorrect implementations which store their
+        callbacks in an array."""
+        input_ = InputCell(1)
+        output = ComputeCell([input_], lambda inputs: inputs[0] + 1)
+
+        cb1_observer, cb2_observer = [], []
+        callback1 = self.callback_factory(cb1_observer)
+        callback2 = self.callback_factory(cb2_observer)
+
+        output.add_callback(callback1)
+        output.add_callback(callback2)
+        output.remove_callback(callback1)
+        output.remove_callback(callback1)
+        output.remove_callback(callback1)
+        input_.value = 2
+
+        self.assertEqual(cb1_observer, [])
+        self.assertEqual(cb2_observer[-1], 3)
+
+    def test_callbacks_should_only_be_called_once(self):
+        """Guard against incorrect implementations which call a callback
+        function multiple times when multiple dependencies change."""
+        input_ = InputCell(1)
+        plus_one = ComputeCell([input_], lambda inputs: inputs[0] + 1)
+        minus_one1 = ComputeCell([input_], lambda inputs: inputs[0] - 1)
+        minus_one2 = ComputeCell([minus_one1], lambda inputs: inputs[0] - 1)
+        output = ComputeCell(
+            [plus_one, minus_one2],
+            lambda inputs: inputs[0] * inputs[1]
+        )
+
+        observer = []
+        callback1 = self.callback_factory(observer)
+
+        output.add_callback(callback1)
+        input_.value = 4
+        self.assertEqual(observer[-1], 10)
+
+    def test_callbacks_not_called_so_long_as_output_not_changed(self):
+        """Guard against incorrect implementations which call callbacks
+        if dependencies change but output value doesn't change."""
+        input_ = InputCell(1)
+        plus_one = ComputeCell([input_], lambda inputs: inputs[0] + 1)
+        minus_one = ComputeCell([input_], lambda inputs: inputs[0] - 1)
+        always_two = ComputeCell(
+            [plus_one, minus_one],
+            lambda inputs: inputs[0] - inputs[1]
+        )
+
+        observer = []
+        callback1 = self.callback_factory(observer)
+
+        always_two.add_callback(callback1)
+        input_.value = 2
+        input_.value = 3
+        input_.value = 4
+        input_.value = 5
+        self.assertEqual(observer, [])
+
+    # Utility functions.
+    def callback_factory(self, observer):
+        def callback(observer, value):
+            observer.append(value)
+        return partial(callback, observer)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/sieve/README.md

@@ -5,8 +5,8 @@ number.
 
 The Sieve of Eratosthenes is a simple, ancient algorithm for finding all
 prime numbers up to any given limit. It does so by iteratively marking as
-composite (i.e. not prime) the multiples of each prime,
-starting with the multiples of 2.
+composite (i.e. not prime) the multiples of each prime, starting with the
+multiples of 2. It does not use any division or remainder operation.
 
 Create your range, starting at two and continuing up to and including the given limit. (i.e. [2, limit])
 
@@ -25,7 +25,9 @@ https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
 
 Notice that this is a very specific algorithm, and the tests don't check
 that you've implemented the algorithm, only that you've come up with the
-correct list of primes.
+correct list of primes. A good first test is to check that you do not use
+division or remainder operations (div, /, mod or % depending on the
+language).
 
 ## Exception messages
 

data/tracks/rust/exercises/react/example.rs

@@ -1,12 +1,31 @@
 use std::collections::HashMap;
 
-pub type CellID = usize;
-pub type CallbackID = usize;
-
-#[derive(Debug, PartialEq)]
-pub enum SetValueError {
-    NonexistentCell,
-    ComputeCell,
+/// `InputCellID` is a unique identifier for an input cell.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct InputCellID(usize);
+/// `ComputeCellID` is a unique identifier for a compute cell.
+/// Values of type `InputCellID` and `ComputeCellID` should not be mutually assignable,
+/// demonstrated by the following tests:
+///
+/// ```compile_fail
+/// let mut r = react::Reactor::new();
+/// let input: react::ComputeCellID = r.create_input(111);
+/// ```
+///
+/// ```compile_fail
+/// let mut r = react::Reactor::new();
+/// let input = r.create_input(111);
+/// let compute: react::InputCellID = r.create_compute(&[react::CellID::Input(input)], |_| 222).unwrap();
+/// ```
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct ComputeCellID(usize);
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub struct CallbackID(usize);
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum CellID {
+    Input(InputCellID),
+    Compute(ComputeCellID),
 }
 
 #[derive(Debug, PartialEq)]
@@ -15,27 +34,38 @@ pub enum RemoveCallbackError {
     NonexistentCallback,
 }
 
-struct Cell<'a, T: Copy> {
+struct Cell<T: Copy> {
     value: T,
     last_value: T,
-    dependents: Vec<CellID>,
-    cell_type: CellType<'a, T>,
-    callbacks_issued: usize,
-    callbacks: HashMap<CallbackID, Box<FnMut(T) -> () + 'a>>,
+    dependents: Vec<ComputeCellID>,
 }
 
-enum CellType<'a, T: Copy> {
-    Input,
-    Compute(Vec<CellID>, Box<Fn(&[T]) -> T + 'a>),
+struct ComputeCell<'a, T: Copy> {
+    cell: Cell<T>,
+
+    dependencies: Vec<CellID>,
+    f: Box<Fn(&[T]) -> T + 'a>,
+    callbacks_issued: usize,
+    callbacks: HashMap<CallbackID, Box<FnMut(T) -> () + 'a>>,
 }
 
-impl <'a, T: Copy> Cell<'a, T> {
-    fn new(initial: T, cell_type: CellType<'a, T>) -> Self {
+impl <T: Copy> Cell<T> {
+    fn new(initial: T) -> Self {
         Cell {
             value: initial,
             last_value: initial,
             dependents: Vec::new(),
-            cell_type: cell_type,
+        }
+    }
+}
+
+impl <'a, T: Copy> ComputeCell<'a, T> {
+    fn new<F: Fn(&[T]) -> T + 'a>(initial: T, dependencies: Vec<CellID>, f: F) -> Self {
+        ComputeCell {
+            cell: Cell::new(initial),
+
+            dependencies,
+            f: Box::new(f),
             callbacks_issued: 0,
             callbacks: HashMap::new(),
         }
@@ -43,52 +73,58 @@ impl <'a, T: Copy> Cell<'a, T> {
 }
 
 pub struct Reactor<'a, T: Copy> {
-    cells: Vec<Cell<'a, T>>,
+    inputs: Vec<Cell<T>>,
+    computes: Vec<ComputeCell<'a, T>>,
 }
 
 impl <'a, T: Copy + PartialEq> Reactor<'a, T> {
     pub fn new() -> Self {
         Reactor{
-            cells: Vec::new(),
+            inputs: Vec::new(),
+            computes: Vec::new(),
         }
     }
 
-    pub fn create_input(&mut self, initial: T) -> CellID {
-        self.cells.push(Cell::new(initial, CellType::Input));
-        self.cells.len() - 1
+    pub fn create_input(&mut self, initial: T) -> InputCellID {
+        self.inputs.push(Cell::new(initial));
+        InputCellID(self.inputs.len() - 1)
     }
 
-    pub fn create_compute<F: Fn(&[T]) -> T + 'a>(&mut self, dependencies: &[CellID], compute_func: F) -> Result<CellID, CellID> {
+    pub fn create_compute<F: Fn(&[T]) -> T + 'a>(&mut self, dependencies: &[CellID], compute_func: F) -> Result<ComputeCellID, CellID> {
         // Check all dependencies' validity before modifying any of them,
         // so that we don't perform an incorrect partial write.
-        if let Some(&invalid) = dependencies.iter().find(|&dep| *dep >= self.cells.len()) {
-            return Err(invalid);
+        for &dep in dependencies {
+            match dep {
+                CellID::Input(InputCellID(id)) => if id >= self.inputs.len() { return Err(dep) },
+                CellID::Compute(ComputeCellID(id)) => if id >= self.computes.len() { return Err(dep) },
+            }
         }
-        let new_id = self.cells.len();
-        for &id in dependencies {
-            self.cells.get_mut(id).unwrap().dependents.push(new_id);
+        let new_id = ComputeCellID(self.computes.len());
+        for &dep in dependencies {
+            match dep {
+                CellID::Input(InputCellID(id)) => self.inputs[id].dependents.push(new_id),
+                CellID::Compute(ComputeCellID(id)) => self.computes[id].cell.dependents.push(new_id),
+            }
         }
         let inputs: Vec<_> = dependencies.iter().map(|&id| self.value(id).unwrap()).collect();
         let initial = compute_func(&inputs);
-        self.cells.push(Cell::new(initial, CellType::Compute(dependencies.iter().cloned().collect(), Box::new(compute_func))));
+        self.computes.push(ComputeCell::new(initial, dependencies.to_vec(), compute_func));
         Ok(new_id)
     }
 
     pub fn value(&self, id: CellID) -> Option<T> {
-        self.cells.get(id).map(|c| c.value)
+        match id {
+            CellID::Input(InputCellID(id)) => self.inputs.get(id).map(|c| c.value),
+            CellID::Compute(ComputeCellID(id)) => self.computes.get(id).map(|c| c.cell.value),
+        }
     }
 
-    pub fn set_value(&mut self, id: CellID, new_value: T) -> Result<(), SetValueError> {
-        match self.cells.get_mut(id) {
-            Some(c) => match c.cell_type {
-                CellType::Input => {
-                    c.value = new_value;
-                    Ok(c.dependents.clone())
-                },
-                CellType::Compute(_, _) => Err(SetValueError::ComputeCell),
-            },
-            None => Err(SetValueError::NonexistentCell),
-        }.map(|deps| {
+    pub fn set_value(&mut self, id: InputCellID, new_value: T) -> bool {
+        let InputCellID(id) = id;
+        self.inputs.get_mut(id).map(|c| {
+            c.value = new_value;
+            c.dependents.clone()
+        }).map(|deps| {
             for &d in deps.iter() {
                 self.update_dependent(d);
             }
@@ -97,19 +133,22 @@ impl <'a, T: Copy + PartialEq> Reactor<'a, T> {
             for d in deps {
                 self.fire_callbacks(d);
             }
-        })
+        }).is_some()
     }
 
-    pub fn add_callback<F: FnMut(T) -> () + 'a>(&mut self, id: CellID, callback: F) -> Option<CallbackID> {
-        self.cells.get_mut(id).map(|c| {
+    pub fn add_callback<F: FnMut(T) -> () + 'a>(&mut self, id: ComputeCellID, callback: F) -> Option<CallbackID> {
+        let ComputeCellID(id) = id;
+        self.computes.get_mut(id).map(|c| {
             c.callbacks_issued += 1;
-            c.callbacks.insert(c.callbacks_issued, Box::new(callback));
-            c.callbacks_issued
+            let cbid = CallbackID(c.callbacks_issued);
+            c.callbacks.insert(cbid, Box::new(callback));
+            cbid
         })
     }
 
-    pub fn remove_callback(&mut self, cell: CellID, callback: CallbackID) -> Result<(), RemoveCallbackError> {
-        match self.cells.get_mut(cell) {
+    pub fn remove_callback(&mut self, cell: ComputeCellID, callback: CallbackID) -> Result<(), RemoveCallbackError> {
+        let ComputeCellID(cell) = cell;
+        match self.computes.get_mut(cell) {
             Some(c) => match c.callbacks.remove(&callback) {
                 Some(_) => Ok(()),
                 None => Err(RemoveCallbackError::NonexistentCallback),
@@ -118,29 +157,28 @@ impl <'a, T: Copy + PartialEq> Reactor<'a, T> {
         }
     }
 
-    fn update_dependent(&mut self, id: CellID) {
+    fn update_dependent(&mut self, id: ComputeCellID) {
+        let ComputeCellID(id) = id;
+
         let (new_value, dependents) = {
             // This block limits the scope of the self.cells borrow.
             // This is necessary becaue we borrow it mutably below.
-            let (dependencies, f, dependents) = match self.cells.get(id) {
-                Some(c) => match c.cell_type {
-                    CellType::Input => panic!("Input cell can't be a dependent"),
-                    CellType::Compute(ref dependencies, ref f) => (dependencies, f, c.dependents.clone()),
-                },
+            let (dependencies, f, dependents) = match self.computes.get(id) {
+                Some(c) => (&c.dependencies, &c.f, c.cell.dependents.clone()),
                 None => panic!("Cell to update disappeared while querying"),
             };
             let inputs: Vec<_> = dependencies.iter().map(|&id| self.value(id).unwrap()).collect();
             (f(&inputs), dependents)
         };
 
-        match self.cells.get_mut(id) {
+        match self.computes.get_mut(id) {
             Some(c) => {
-                if c.value == new_value {
+                if c.cell.value == new_value {
                     // No change here, we don't need to update our dependents.
                     // (It wouldn't hurt to, but it would be unnecessary work)
                     return;
                 }
-                c.value = new_value;
+                c.cell.value = new_value;
             },
             None => panic!("Cell to update disappeared while updating"),
         }
@@ -150,19 +188,20 @@ impl <'a, T: Copy + PartialEq> Reactor<'a, T> {
         }
     }
 
-    fn fire_callbacks(&mut self, id: CellID) {
-        let dependents = match self.cells.get_mut(id) {
+    fn fire_callbacks(&mut self, id: ComputeCellID) {
+        let ComputeCellID(id) = id;
+        let dependents = match self.computes.get_mut(id) {
             Some(c) => {
-                if c.value == c.last_value {
+                if c.cell.value == c.cell.last_value {
                     // Value hasn't changed since last callback fire.
                     // We thus shouldn't fire the callbacks.
                     return
                 }
                 for cb in c.callbacks.values_mut() {
-                    cb(c.value);
+                    cb(c.cell.value);
                 }
-                c.last_value = c.value;
-                c.dependents.clone()
+                c.cell.last_value = c.cell.value;
+                c.cell.dependents.clone()
             },
             None => panic!("Callback cell disappeared"),
         };