trackler 2.2.1.135 → 2.2.1.136

data/tracks/rust/exercises/react/src/lib.rs

@@ -1,12 +1,29 @@
-// Because these are passed without & to some functions,
-// it will probably be necessary for these two types to be Copy.
-pub type CellID = ();
-pub type CallbackID = ();
+/// `InputCellID` is a unique identifier for an input cell.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct InputCellID();
+/// `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();
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct CallbackID();
 
-#[derive(Debug, PartialEq)]
-pub enum SetValueError {
-    NonexistentCell,
-    ComputeCell,
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum CellID {
+    Input(InputCellID),
+    Compute(ComputeCellID),
 }
 
 #[derive(Debug, PartialEq)]
@@ -28,7 +45,7 @@ impl <T: Copy + PartialEq> Reactor<T> {
     }
 
     // Creates an input cell with the specified initial value, returning its ID.
-    pub fn create_input(&mut self, _initial: T) -> CellID {
+    pub fn create_input(&mut self, _initial: T) -> InputCellID {
         unimplemented!()
     }
 
@@ -45,7 +62,7 @@ impl <T: Copy + PartialEq> Reactor<T> {
     // Notice that there is no way to *remove* a cell.
     // This means that you may assume, without checking, that if the dependencies exist at creation
     // time they will continue to exist as long as the Reactor exists.
-    pub fn create_compute<F: Fn(&[T]) -> T>(&mut self, _dependencies: &[CellID], _compute_func: F) -> Result<CellID, CellID> {
+    pub fn create_compute<F: Fn(&[T]) -> T>(&mut self, _dependencies: &[CellID], _compute_func: F) -> Result<ComputeCellID, CellID> {
         unimplemented!()
     }
 
@@ -62,16 +79,13 @@ impl <T: Copy + PartialEq> Reactor<T> {
 
     // Sets the value of the specified input cell.
     //
-    // Returns an Err if either:
-    // * the cell does not exist
-    // * the specified cell is a compute cell, since compute cells cannot have their values
-    //   directly set.
+    // Returns false if the cell does not exist.
     //
     // Similarly, you may wonder about `get_mut(&mut self, id: CellID) -> Option<&mut Cell>`, with
     // a `set_value(&mut self, new_value: T)` method on `Cell`.
     //
     // As before, that turned out to add too much extra complexity.
-    pub fn set_value(&mut self, _id: CellID, _new_value: T) -> Result<(), SetValueError> {
+    pub fn set_value(&mut self, _id: InputCellID, _new_value: T) -> bool {
         unimplemented!()
     }
 
@@ -87,7 +101,7 @@ impl <T: Copy + PartialEq> Reactor<T> {
     // * Exactly once if the compute cell's value changed as a result of the set_value call.
     //   The value passed to the callback should be the final value of the compute cell after the
     //   set_value call.
-    pub fn add_callback<F: FnMut(T) -> ()>(&mut self, _id: CellID, _callback: F) -> Option<CallbackID> {
+    pub fn add_callback<F: FnMut(T) -> ()>(&mut self, _id: ComputeCellID, _callback: F) -> Option<CallbackID> {
         unimplemented!()
     }
 
@@ -96,7 +110,7 @@ impl <T: Copy + PartialEq> Reactor<T> {
     // Returns an Err if either the cell or callback does not exist.
     //
     // A removed callback should no longer be called.
-    pub fn remove_callback(&mut self, cell: CellID, callback: CallbackID) -> Result<(), RemoveCallbackError> {
+    pub fn remove_callback(&mut self, cell: ComputeCellID, callback: CallbackID) -> Result<(), RemoveCallbackError> {
         unimplemented!(
             "Remove the callback identified by the CallbackID {:?} from the cell {:?}",
             callback,

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

@@ -6,7 +6,7 @@ use react::*;
 fn input_cells_have_a_value() {
     let mut reactor = Reactor::new();
     let input = reactor.create_input(10);
-    assert_eq!(reactor.value(input), Some(10));
+    assert_eq!(reactor.value(CellID::Input(input)), Some(10));
 }
 
 #[test]
@@ -14,8 +14,8 @@ fn input_cells_have_a_value() {
 fn an_input_cells_value_can_be_set() {
     let mut reactor = Reactor::new();
     let input = reactor.create_input(4);
-    assert!(reactor.set_value(input, 20).is_ok());
-    assert_eq!(reactor.value(input), Some(20));
+    assert!(reactor.set_value(input, 20));
+    assert_eq!(reactor.value(CellID::Input(input)), Some(20));
 }
 
 #[test]
@@ -23,7 +23,7 @@ fn an_input_cells_value_can_be_set() {
 fn error_setting_a_nonexistent_input_cell() {
     let mut dummy_reactor = Reactor::new();
     let input = dummy_reactor.create_input(1);
-    assert_eq!(Reactor::new().set_value(input, 0), Err(SetValueError::NonexistentCell));
+    assert!(!Reactor::new().set_value(input, 0));
 }
 
 #[test]
@@ -31,8 +31,8 @@ fn error_setting_a_nonexistent_input_cell() {
 fn compute_cells_calculate_initial_value() {
     let mut reactor = Reactor::new();
     let input = reactor.create_input(1);
-    let output = reactor.create_compute(&[input], |v| v[0] + 1).unwrap();
-    assert_eq!(reactor.value(output), Some(2));
+    let output = reactor.create_compute(&[CellID::Input(input)], |v| v[0] + 1).unwrap();
+    assert_eq!(reactor.value(CellID::Compute(output)), Some(2));
 }
 
 #[test]
@@ -41,8 +41,8 @@ fn compute_cells_take_inputs_in_the_right_order() {
     let mut reactor = Reactor::new();
     let one = reactor.create_input(1);
     let two = reactor.create_input(2);
-    let output = reactor.create_compute(&[one, two], |v| v[0] + v[1] * 10).unwrap();
-    assert_eq!(reactor.value(output), Some(21));
+    let output = reactor.create_compute(&[CellID::Input(one), CellID::Input(two)], |v| v[0] + v[1] * 10).unwrap();
+    assert_eq!(reactor.value(CellID::Compute(output)), Some(21));
 }
 
 #[test]
@@ -50,7 +50,7 @@ fn compute_cells_take_inputs_in_the_right_order() {
 fn error_creating_compute_cell_if_input_doesnt_exist() {
     let mut dummy_reactor = Reactor::new();
     let input = dummy_reactor.create_input(1);
-    assert_eq!(Reactor::new().create_compute(&[input], |_| 0), Err(input));
+    assert_eq!(Reactor::new().create_compute(&[CellID::Input(input)], |_| 0), Err(CellID::Input(input)));
 }
 
 #[test]
@@ -61,9 +61,9 @@ fn do_not_break_cell_if_creating_compute_cell_with_valid_and_invalid_input() {
     let dummy_cell = dummy_reactor.create_input(2);
     let mut reactor = Reactor::new();
     let input = reactor.create_input(1);
-    assert_eq!(reactor.create_compute(&[input, dummy_cell], |_| 0), Err(dummy_cell));
-    assert!(reactor.set_value(input, 5).is_ok());
-    assert_eq!(reactor.value(input), Some(5));
+    assert_eq!(reactor.create_compute(&[CellID::Input(input), CellID::Input(dummy_cell)], |_| 0), Err(CellID::Input(dummy_cell)));
+    assert!(reactor.set_value(input, 5));
+    assert_eq!(reactor.value(CellID::Input(input)), Some(5));
 }
 
 #[test]
@@ -71,10 +71,10 @@ fn do_not_break_cell_if_creating_compute_cell_with_valid_and_invalid_input() {
 fn compute_cells_update_value_when_dependencies_are_changed() {
     let mut reactor = Reactor::new();
     let input = reactor.create_input(1);
-    let output = reactor.create_compute(&[input], |v| v[0] + 1).unwrap();
-    assert_eq!(reactor.value(output), Some(2));
-    assert!(reactor.set_value(input, 3).is_ok());
-    assert_eq!(reactor.value(output), Some(4));
+    let output = reactor.create_compute(&[CellID::Input(input)], |v| v[0] + 1).unwrap();
+    assert_eq!(reactor.value(CellID::Compute(output)), Some(2));
+    assert!(reactor.set_value(input, 3));
+    assert_eq!(reactor.value(CellID::Compute(output)), Some(4));
 }
 
 #[test]
@@ -82,21 +82,12 @@ fn compute_cells_update_value_when_dependencies_are_changed() {
 fn compute_cells_can_depend_on_other_compute_cells() {
     let mut reactor = Reactor::new();
     let input = reactor.create_input(1);
-    let times_two = reactor.create_compute(&[input], |v| v[0] * 2).unwrap();
-    let times_thirty = reactor.create_compute(&[input], |v| v[0] * 30).unwrap();
-    let output = reactor.create_compute(&[times_two, times_thirty], |v| v[0] + v[1]).unwrap();
-    assert_eq!(reactor.value(output), Some(32));
-    assert!(reactor.set_value(input, 3).is_ok());
-    assert_eq!(reactor.value(output), Some(96));
-}
-
-#[test]
-#[ignore]
-fn error_setting_a_compute_cell() {
-    let mut reactor = Reactor::new();
-    let input = reactor.create_input(1);
-    let output = reactor.create_compute(&[input], |_| 0).unwrap();
-    assert_eq!(reactor.set_value(output, 3), Err(SetValueError::ComputeCell));
+    let times_two = reactor.create_compute(&[CellID::Input(input)], |v| v[0] * 2).unwrap();
+    let times_thirty = reactor.create_compute(&[CellID::Input(input)], |v| v[0] * 30).unwrap();
+    let output = reactor.create_compute(&[CellID::Compute(times_two), CellID::Compute(times_thirty)], |v| v[0] + v[1]).unwrap();
+    assert_eq!(reactor.value(CellID::Compute(output)), Some(32));
+    assert!(reactor.set_value(input, 3));
+    assert_eq!(reactor.value(CellID::Compute(output)), Some(96));
 }
 
 /// A CallbackRecorder helps tests whether callbacks get called correctly.
@@ -138,9 +129,9 @@ fn compute_cells_fire_callbacks() {
     let cb = CallbackRecorder::new();
     let mut reactor = Reactor::new();
     let input = reactor.create_input(1);
-    let output = reactor.create_compute(&[input], |v| v[0] + 1).unwrap();
+    let output = reactor.create_compute(&[CellID::Input(input)], |v| v[0] + 1).unwrap();
     assert!(reactor.add_callback(output, |v| cb.callback_called(v)).is_some());
-    assert!(reactor.set_value(input, 3).is_ok());
+    assert!(reactor.set_value(input, 3));
     cb.expect_to_have_been_called_with(4);
 }
 
@@ -149,7 +140,7 @@ fn compute_cells_fire_callbacks() {
 fn error_adding_callback_to_nonexistent_cell() {
     let mut dummy_reactor = Reactor::new();
     let input = dummy_reactor.create_input(1);
-    let output = dummy_reactor.create_compute(&[input], |_| 0).unwrap();
+    let output = dummy_reactor.create_compute(&[CellID::Input(input)], |_| 0).unwrap();
     assert_eq!(Reactor::new().add_callback(output, |_: usize| println!("hi")), None);
 }
 
@@ -159,12 +150,12 @@ fn callbacks_only_fire_on_change() {
     let cb = CallbackRecorder::new();
     let mut reactor = Reactor::new();
     let input = reactor.create_input(1);
-    let output = reactor.create_compute(&[input], |v| if v[0] < 3 { 111 } else { 222 }).unwrap();
+    let output = reactor.create_compute(&[CellID::Input(input)], |v| if v[0] < 3 { 111 } else { 222 }).unwrap();
     assert!(reactor.add_callback(output, |v| cb.callback_called(v)).is_some());
 
-    assert!(reactor.set_value(input, 2).is_ok());
+    assert!(reactor.set_value(input, 2));
     cb.expect_not_to_have_been_called();
-    assert!(reactor.set_value(input, 4).is_ok());
+    assert!(reactor.set_value(input, 4));
     cb.expect_to_have_been_called_with(222);
 }
 
@@ -177,19 +168,19 @@ fn callbacks_can_be_added_and_removed() {
 
     let mut reactor = Reactor::new();
     let input = reactor.create_input(11);
-    let output = reactor.create_compute(&[input], |v| v[0] + 1).unwrap();
+    let output = reactor.create_compute(&[CellID::Input(input)], |v| v[0] + 1).unwrap();
 
     let callback = reactor.add_callback(output, |v| cb1.callback_called(v)).unwrap();
     assert!(reactor.add_callback(output, |v| cb2.callback_called(v)).is_some());
 
-    assert!(reactor.set_value(input, 31).is_ok());
+    assert!(reactor.set_value(input, 31));
     cb1.expect_to_have_been_called_with(32);
     cb2.expect_to_have_been_called_with(32);
 
     assert!(reactor.remove_callback(output, callback).is_ok());
     assert!(reactor.add_callback(output, |v| cb3.callback_called(v)).is_some());
 
-    assert!(reactor.set_value(input, 41).is_ok());
+    assert!(reactor.set_value(input, 41));
     cb1.expect_not_to_have_been_called();
     cb2.expect_to_have_been_called_with(42);
     cb3.expect_to_have_been_called_with(42);
@@ -203,7 +194,7 @@ fn removing_a_callback_multiple_times_doesnt_interfere_with_other_callbacks() {
 
     let mut reactor = Reactor::new();
     let input = reactor.create_input(1);
-    let output = reactor.create_compute(&[input], |v| v[0] + 1).unwrap();
+    let output = reactor.create_compute(&[CellID::Input(input)], |v| v[0] + 1).unwrap();
     let callback = reactor.add_callback(output, |v| cb1.callback_called(v)).unwrap();
     assert!(reactor.add_callback(output, |v| cb2.callback_called(v)).is_some());
     // We want the first remove to be Ok, but the others should be errors.
@@ -212,7 +203,7 @@ fn removing_a_callback_multiple_times_doesnt_interfere_with_other_callbacks() {
         assert_eq!(reactor.remove_callback(output, callback), Err(RemoveCallbackError::NonexistentCallback));
     }
 
-    assert!(reactor.set_value(input, 2).is_ok());
+    assert!(reactor.set_value(input, 2));
     cb1.expect_not_to_have_been_called();
     cb2.expect_to_have_been_called_with(3);
 }
@@ -223,12 +214,12 @@ fn callbacks_should_only_be_called_once_even_if_multiple_dependencies_change() {
     let cb = CallbackRecorder::new();
     let mut reactor = Reactor::new();
     let input = reactor.create_input(1);
-    let plus_one = reactor.create_compute(&[input], |v| v[0] + 1).unwrap();
-    let minus_one1 = reactor.create_compute(&[input], |v| v[0] - 1).unwrap();
-    let minus_one2 = reactor.create_compute(&[minus_one1], |v| v[0] - 1).unwrap();
-    let output = reactor.create_compute(&[plus_one, minus_one2], |v| v[0] * v[1]).unwrap();
+    let plus_one = reactor.create_compute(&[CellID::Input(input)], |v| v[0] + 1).unwrap();
+    let minus_one1 = reactor.create_compute(&[CellID::Input(input)], |v| v[0] - 1).unwrap();
+    let minus_one2 = reactor.create_compute(&[CellID::Compute(minus_one1)], |v| v[0] - 1).unwrap();
+    let output = reactor.create_compute(&[CellID::Compute(plus_one), CellID::Compute(minus_one2)], |v| v[0] * v[1]).unwrap();
     assert!(reactor.add_callback(output, |v| cb.callback_called(v)).is_some());
-    assert!(reactor.set_value(input, 4).is_ok());
+    assert!(reactor.set_value(input, 4));
     cb.expect_to_have_been_called_with(10);
 }
 
@@ -238,12 +229,12 @@ fn callbacks_should_not_be_called_if_dependencies_change_but_output_value_doesnt
     let cb = CallbackRecorder::new();
     let mut reactor = Reactor::new();
     let input = reactor.create_input(1);
-    let plus_one = reactor.create_compute(&[input], |v| v[0] + 1).unwrap();
-    let minus_one = reactor.create_compute(&[input], |v| v[0] - 1).unwrap();
-    let always_two = reactor.create_compute(&[plus_one, minus_one], |v| v[0] - v[1]).unwrap();
+    let plus_one = reactor.create_compute(&[CellID::Input(input)], |v| v[0] + 1).unwrap();
+    let minus_one = reactor.create_compute(&[CellID::Input(input)], |v| v[0] - 1).unwrap();
+    let always_two = reactor.create_compute(&[CellID::Compute(plus_one), CellID::Compute(minus_one)], |v| v[0] - v[1]).unwrap();
     assert!(reactor.add_callback(always_two, |v| cb.callback_called(v)).is_some());
     for i in 2..5 {
-        assert!(reactor.set_value(input, i).is_ok());
+        assert!(reactor.set_value(input, i));
         cb.expect_not_to_have_been_called();
     }
 }
@@ -258,12 +249,12 @@ fn test_adder_with_boolean_values() {
     let b = reactor.create_input(false);
     let carry_in = reactor.create_input(false);
 
-    let a_xor_b = reactor.create_compute(&[a, b], |v| v[0] ^ v[1]).unwrap();
-    let sum = reactor.create_compute(&[a_xor_b, carry_in], |v| v[0] ^ v[1]).unwrap();
+    let a_xor_b = reactor.create_compute(&[CellID::Input(a), CellID::Input(b)], |v| v[0] ^ v[1]).unwrap();
+    let sum = reactor.create_compute(&[CellID::Compute(a_xor_b), CellID::Input(carry_in)], |v| v[0] ^ v[1]).unwrap();
 
-    let a_xor_b_and_cin = reactor.create_compute(&[a_xor_b, carry_in], |v| v[0] && v[1]).unwrap();
-    let a_and_b = reactor.create_compute(&[a, b], |v| v[0] && v[1]).unwrap();
-    let carry_out = reactor.create_compute(&[a_xor_b_and_cin, a_and_b], |v| v[0] || v[1]).unwrap();
+    let a_xor_b_and_cin = reactor.create_compute(&[CellID::Compute(a_xor_b), CellID::Input(carry_in)], |v| v[0] && v[1]).unwrap();
+    let a_and_b = reactor.create_compute(&[CellID::Input(a), CellID::Input(b)], |v| v[0] && v[1]).unwrap();
+    let carry_out = reactor.create_compute(&[CellID::Compute(a_xor_b_and_cin), CellID::Compute(a_and_b)], |v| v[0] || v[1]).unwrap();
 
     let tests = &[
         (false, false, false, false, false),
@@ -277,11 +268,11 @@ fn test_adder_with_boolean_values() {
     ];
 
     for &(aval, bval, cinval, expected_cout, expected_sum) in tests {
-        assert!(reactor.set_value(a, aval).is_ok());
-        assert!(reactor.set_value(b, bval).is_ok());
-        assert!(reactor.set_value(carry_in, cinval).is_ok());
+        assert!(reactor.set_value(a, aval));
+        assert!(reactor.set_value(b, bval));
+        assert!(reactor.set_value(carry_in, cinval));
 
-        assert_eq!(reactor.value(sum), Some(expected_sum));
-        assert_eq!(reactor.value(carry_out), Some(expected_cout));
+        assert_eq!(reactor.value(CellID::Compute(sum)), Some(expected_sum));
+        assert_eq!(reactor.value(CellID::Compute(carry_out)), Some(expected_cout));
     }
 }

data/tracks/swift/config.json

@@ -438,6 +438,17 @@
         "loops"
       ]
     },
+    {
+      "core": false,
+      "difficulty": 3,
+      "slug": "proverb",
+      "topics": [
+        "algorithms",
+        "strings"
+      ],
+      "unlocked_by": null,
+      "uuid": "9604f1ef-4925-4c28-9c59-b986c1a42c7e"
+    },
     {
       "core": false,
       "difficulty": 4,

data/tracks/swift/exercises/circular-buffer/Sources/CircularBufferExample.swift

@@ -10,29 +10,29 @@ struct CircularBuffer<T: Equatable> {
     let capacity: Int
     var writePoint = 0
     var readPoint = 0
-    
+
     private var isFull: Bool {
         return buffer.flatMap { $0 }.count >= capacity
     }
-    
+
     private var isEmpty: Bool {
         return buffer.flatMap { $0 }.isEmpty
     }
-    
+
     init(capacity: Int) {
         self.capacity = capacity
         buffer = [T?](repeating: nil, count: capacity)
     }
-    
+
     mutating func write(_ data: T) throws {
         guard !isFull else {
             throw CircularBufferError.bufferFull
         }
-        
+
         buffer[writePoint] = data
         updateWritePoint()
     }
-    
+
     mutating func overwrite(_ data: T) {
         buffer[writePoint] = data
         if isFull && writePoint == readPoint {
@@ -40,26 +40,26 @@ struct CircularBuffer<T: Equatable> {
         }
         updateWritePoint()
     }
-    
+
     mutating func read() throws -> T {
         guard let data = buffer[readPoint] else {
             throw CircularBufferError.bufferEmpty
         }
-        
+
         buffer[readPoint] = nil
         updateReadPoint()
-        
+
         return data
     }
-    
+
     mutating func clear() {
         buffer = [T?](repeating: nil, count: capacity)
     }
-    
+
     private mutating func updateWritePoint() {
         writePoint = (writePoint + 1) % capacity
     }
-    
+
     private mutating func updateReadPoint() {
         readPoint = (readPoint + 1) % capacity
     }

data/tracks/swift/exercises/circular-buffer/Tests/CircularBufferTests/CircularBufferTests.swift

@@ -2,7 +2,7 @@ import XCTest
 @testable import CircularBuffer
 
 class CircularBufferTests: XCTestCase {
-    
+
     func testReadEmptyBufferThrowsBufferEmptyException() {
         var buffer = CircularBuffer<Int>(capacity: 1)
 

data/tracks/swift/exercises/proverb/Package.swift

@@ -0,0 +1,5 @@
+import PackageDescription
+
+let package = Package(
+    name: "Proverb"
+)