trackler 2.2.1.113 → 2.2.1.114

data/tracks/rust/exercises/grade-school/tests/grade-school.rs

@@ -1,6 +1,6 @@
 extern crate grade_school as school;
 
-fn some_strings(v: Vec<&str>) -> Option<Vec<String>> {
+fn some_strings(v: &[&str]) -> Option<Vec<String>> {
     Some(v.iter().map(|s| s.to_string()).collect())
 }
 
@@ -59,7 +59,7 @@ fn test_grade_for_one_student() {
     let mut s = school::School::new();
     s.add(2, "Aimee");
     assert_eq!(s.grade(2),
-                some_strings(vec!["Aimee"]));
+                some_strings(&["Aimee"]));
 }
 
 #[test]
@@ -70,7 +70,7 @@ fn test_grade_returns_students_sorted_by_name() {
     s.add(2, "Blair");
     s.add(2, "Paul");
     assert_eq!(s.grade(2),
-               some_strings(vec!["Blair", "James", "Paul"]));
+               some_strings(&["Blair", "James", "Paul"]));
 }
 
 #[test]
@@ -81,7 +81,7 @@ fn test_add_students_to_different_grades() {
     s.add(7, "Logan");
     assert_eq!(s.grades(), vec!(3, 7));
     assert_eq!(s.grade(3),
-               some_strings(vec!["Chelsea"]));
+               some_strings(&["Chelsea"]));
     assert_eq!(s.grade(7),
-               some_strings(vec!["Logan"]));
+               some_strings(&["Logan"]));
 }

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

@@ -26,15 +26,15 @@ fn test<'a, 'b>(input: &[&'a str], expected: &[&'b str]) {
 
 #[test]
 fn test_single_hand_always_wins() {
-    test(&vec!["4S 5S 7H 8D JC"], &vec!["4S 5S 7H 8D JC"])
+    test(&["4S 5S 7H 8D JC"], &["4S 5S 7H 8D JC"])
 }
 
 #[test]
 #[ignore]
 fn test_highest_card_of_all_hands_wins() {
     test(
-        &vec!["4D 5S 6S 8D 3C", "2S 4C 7S 9H 10H", "3S 4S 5D 6H JH"],
-        &vec!["3S 4S 5D 6H JH"],
+        &["4D 5S 6S 8D 3C", "2S 4C 7S 9H 10H", "3S 4S 5D 6H JH"],
+        &["3S 4S 5D 6H JH"],
     )
 }
 
@@ -42,13 +42,13 @@ fn test_highest_card_of_all_hands_wins() {
 #[ignore]
 fn test_a_tie_has_multiple_winners() {
     test(
-        &vec![
+        &[
             "4D 5S 6S 8D 3C",
             "2S 4C 7S 9H 10H",
             "3S 4S 5D 6H JH",
             "3H 4H 5C 6C JD",
         ],
-        &vec!["3S 4S 5D 6H JH", "3H 4H 5C 6C JD"],
+        &["3S 4S 5D 6H JH", "3H 4H 5C 6C JD"],
     )
 }
 
@@ -58,8 +58,8 @@ fn test_high_card_can_be_low_card_in_an_otherwise_tie() {
     // multiple hands with the same high cards, tie compares next highest ranked,
     // down to last card
     test(
-        &vec!["3S 5H 6S 8D 7H", "2S 5D 6D 8C 7S"],
-        &vec!["3S 5H 6S 8D 7H"],
+        &["3S 5H 6S 8D 7H", "2S 5D 6D 8C 7S"],
+        &["3S 5H 6S 8D 7H"],
     )
 }
 
@@ -67,8 +67,8 @@ fn test_high_card_can_be_low_card_in_an_otherwise_tie() {
 #[ignore]
 fn test_one_pair_beats_high_card() {
     test(
-        &vec!["4S 5H 6C 8D KH", "2S 4H 6S 4D JH"],
-        &vec!["2S 4H 6S 4D JH"],
+        &["4S 5H 6C 8D KH", "2S 4H 6S 4D JH"],
+        &["2S 4H 6S 4D JH"],
     )
 }
 
@@ -76,8 +76,8 @@ fn test_one_pair_beats_high_card() {
 #[ignore]
 fn test_highest_pair_wins() {
     test(
-        &vec!["4S 2H 6S 2D JH", "2S 4H 6C 4D JD"],
-        &vec!["2S 4H 6C 4D JD"],
+        &["4S 2H 6S 2D JH", "2S 4H 6C 4D JD"],
+        &["2S 4H 6C 4D JD"],
     )
 }
 
@@ -85,8 +85,8 @@ fn test_highest_pair_wins() {
 #[ignore]
 fn test_two_pairs_beats_one_pair() {
     test(
-        &vec!["2S 8H 6S 8D JH", "4S 5H 4C 8C 5C"],
-        &vec!["4S 5H 4C 8C 5C"],
+        &["2S 8H 6S 8D JH", "4S 5H 4C 8C 5C"],
+        &["4S 5H 4C 8C 5C"],
     )
 }
 
@@ -95,8 +95,8 @@ fn test_two_pairs_beats_one_pair() {
 fn test_two_pair_ranks() {
     // both hands have two pairs, highest ranked pair wins
     test(
-        &vec!["2S 8H 2D 8D 3H", "4S 5H 4C 8S 5D"],
-        &vec!["2S 8H 2D 8D 3H"],
+        &["2S 8H 2D 8D 3H", "4S 5H 4C 8S 5D"],
+        &["2S 8H 2D 8D 3H"],
     )
 }
 
@@ -106,8 +106,8 @@ fn test_two_pairs_second_pair_cascade() {
     // both hands have two pairs, with the same highest ranked pair,
     // tie goes to low pair
     test(
-        &vec!["2S QS 2C QD JH", "JD QH JS 8D QC"],
-        &vec!["JD QH JS 8D QC"],
+        &["2S QS 2C QD JH", "JD QH JS 8D QC"],
+        &["JD QH JS 8D QC"],
     )
 }
 
@@ -117,8 +117,8 @@ fn test_two_pairs_last_card_cascade() {
     // both hands have two identically ranked pairs,
     // tie goes to remaining card (kicker)
     test(
-        &vec!["JD QH JS 8D QC", "JS QS JC 2D QD"],
-        &vec!["JD QH JS 8D QC"],
+        &["JD QH JS 8D QC", "JS QS JC 2D QD"],
+        &["JD QH JS 8D QC"],
     )
 }
 
@@ -126,8 +126,8 @@ fn test_two_pairs_last_card_cascade() {
 #[ignore]
 fn test_three_of_a_kind_beats_two_pair() {
     test(
-        &vec!["2S 8H 2H 8D JH", "4S 5H 4C 8S 4H"],
-        &vec!["4S 5H 4C 8S 4H"],
+        &["2S 8H 2H 8D JH", "4S 5H 4C 8S 4H"],
+        &["4S 5H 4C 8S 4H"],
     )
 }
 
@@ -136,8 +136,8 @@ fn test_three_of_a_kind_beats_two_pair() {
 fn test_three_of_a_kind_ranks() {
     //both hands have three of a kind, tie goes to highest ranked triplet
     test(
-        &vec!["2S 2H 2C 8D JH", "4S AH AS 8C AD"],
-        &vec!["4S AH AS 8C AD"],
+        &["2S 2H 2C 8D JH", "4S AH AS 8C AD"],
+        &["4S AH AS 8C AD"],
     )
 }
 
@@ -147,8 +147,8 @@ fn test_three_of_a_kind_cascade_ranks() {
     // with multiple decks, two players can have same three of a kind,
     // ties go to highest remaining cards
     test(
-        &vec!["4S AH AS 7C AD", "4S AH AS 8C AD"],
-        &vec!["4S AH AS 8C AD"],
+        &["4S AH AS 7C AD", "4S AH AS 8C AD"],
+        &["4S AH AS 8C AD"],
     )
 }
 
@@ -156,8 +156,8 @@ fn test_three_of_a_kind_cascade_ranks() {
 #[ignore]
 fn test_straight_beats_three_of_a_kind() {
     test(
-        &vec!["4S 5H 4C 8D 4H", "3S 4D 2S 6D 5C"],
-        &vec!["3S 4D 2S 6D 5C"],
+        &["4S 5H 4C 8D 4H", "3S 4D 2S 6D 5C"],
+        &["3S 4D 2S 6D 5C"],
     )
 }
 
@@ -166,8 +166,8 @@ fn test_straight_beats_three_of_a_kind() {
 fn test_aces_can_end_a_straight_high() {
     // aces can end a straight (10 J Q K A)
     test(
-        &vec!["4S 5H 4C 8D 4H", "10D JH QS KD AC"],
-        &vec!["10D JH QS KD AC"],
+        &["4S 5H 4C 8D 4H", "10D JH QS KD AC"],
+        &["10D JH QS KD AC"],
     )
 }
 
@@ -176,8 +176,8 @@ fn test_aces_can_end_a_straight_high() {
 fn test_aces_can_end_a_straight_low() {
     // aces can start a straight (A 2 3 4 5)
     test(
-        &vec!["4S 5H 4C 8D 4H", "4D AH 3S 2D 5C"],
-        &vec!["4D AH 3S 2D 5C"],
+        &["4S 5H 4C 8D 4H", "4D AH 3S 2D 5C"],
+        &["4D AH 3S 2D 5C"],
     )
 }
 
@@ -186,8 +186,8 @@ fn test_aces_can_end_a_straight_low() {
 fn test_straight_cascade() {
     // both hands with a straight, tie goes to highest ranked card
     test(
-        &vec!["4S 6C 7S 8D 5H", "5S 7H 8S 9D 6H"],
-        &vec!["5S 7H 8S 9D 6H"],
+        &["4S 6C 7S 8D 5H", "5S 7H 8S 9D 6H"],
+        &["5S 7H 8S 9D 6H"],
     )
 }
 
@@ -196,8 +196,8 @@ fn test_straight_cascade() {
 fn test_straight_scoring() {
     // even though an ace is usually high, a 5-high straight is the lowest-scoring straight
     test(
-        &vec!["2H 3C 4D 5D 6H", "4S AH 3S 2D 5H"],
-        &vec!["2H 3C 4D 5D 6H"],
+        &["2H 3C 4D 5D 6H", "4S AH 3S 2D 5H"],
+        &["2H 3C 4D 5D 6H"],
     )
 }
 
@@ -205,8 +205,8 @@ fn test_straight_scoring() {
 #[ignore]
 fn test_flush_beats_a_straight() {
     test(
-        &vec!["4C 6H 7D 8D 5H", "2S 4S 5S 6S 7S"],
-        &vec!["2S 4S 5S 6S 7S"],
+        &["4C 6H 7D 8D 5H", "2S 4S 5S 6S 7S"],
+        &["2S 4S 5S 6S 7S"],
     )
 }
 
@@ -215,8 +215,8 @@ fn test_flush_beats_a_straight() {
 fn test_flush_cascade() {
     // both hands have a flush, tie goes to high card, down to the last one if necessary
     test(
-        &vec!["4H 7H 8H 9H 6H", "2S 4S 5S 6S 7S"],
-        &vec!["4H 7H 8H 9H 6H"],
+        &["4H 7H 8H 9H 6H", "2S 4S 5S 6S 7S"],
+        &["4H 7H 8H 9H 6H"],
     )
 }
 
@@ -224,8 +224,8 @@ fn test_flush_cascade() {
 #[ignore]
 fn test_full_house_beats_a_flush() {
     test(
-        &vec!["3H 6H 7H 8H 5H", "4S 5C 4C 5D 4H"],
-        &vec!["4S 5C 4C 5D 4H"],
+        &["3H 6H 7H 8H 5H", "4S 5C 4C 5D 4H"],
+        &["4S 5C 4C 5D 4H"],
     )
 }
 
@@ -234,8 +234,8 @@ fn test_full_house_beats_a_flush() {
 fn test_full_house_ranks() {
     // both hands have a full house, tie goes to highest-ranked triplet
     test(
-        &vec!["4H 4S 4D 9S 9D", "5H 5S 5D 8S 8D"],
-        &vec!["5H 5S 5D 8S 8D"],
+        &["4H 4S 4D 9S 9D", "5H 5S 5D 8S 8D"],
+        &["5H 5S 5D 8S 8D"],
     )
 }
 
@@ -244,8 +244,8 @@ fn test_full_house_ranks() {
 fn test_full_house_cascade() {
     // with multiple decks, both hands have a full house with the same triplet, tie goes to the pair
     test(
-        &vec!["5H 5S 5D 9S 9D", "5H 5S 5D 8S 8D"],
-        &vec!["5H 5S 5D 9S 9D"],
+        &["5H 5S 5D 9S 9D", "5H 5S 5D 8S 8D"],
+        &["5H 5S 5D 9S 9D"],
     )
 }
 
@@ -253,8 +253,8 @@ fn test_full_house_cascade() {
 #[ignore]
 fn test_four_of_a_kind_beats_full_house() {
     test(
-        &vec!["4S 5H 4D 5D 4H", "3S 3H 2S 3D 3C"],
-        &vec!["3S 3H 2S 3D 3C"],
+        &["4S 5H 4D 5D 4H", "3S 3H 2S 3D 3C"],
+        &["3S 3H 2S 3D 3C"],
     )
 }
 
@@ -263,8 +263,8 @@ fn test_four_of_a_kind_beats_full_house() {
 fn test_four_of_a_kind_ranks() {
     // both hands have four of a kind, tie goes to high quad
     test(
-        &vec!["2S 2H 2C 8D 2D", "4S 5H 5S 5D 5C"],
-        &vec!["4S 5H 5S 5D 5C"],
+        &["2S 2H 2C 8D 2D", "4S 5H 5S 5D 5C"],
+        &["4S 5H 5S 5D 5C"],
     )
 }
 
@@ -273,8 +273,8 @@ fn test_four_of_a_kind_ranks() {
 fn test_four_of_a_kind_cascade() {
     // with multiple decks, both hands with identical four of a kind, tie determined by kicker
     test(
-        &vec!["3S 3H 2S 3D 3C", "3S 3H 4S 3D 3C"],
-        &vec!["3S 3H 4S 3D 3C"],
+        &["3S 3H 2S 3D 3C", "3S 3H 4S 3D 3C"],
+        &["3S 3H 4S 3D 3C"],
     )
 }
 
@@ -282,8 +282,8 @@ fn test_four_of_a_kind_cascade() {
 #[ignore]
 fn test_straight_flush_beats_four_of_a_kind() {
     test(
-        &vec!["4S 5H 5S 5D 5C", "7S 8S 9S 6S 10S"],
-        &vec!["7S 8S 9S 6S 10S"],
+        &["4S 5H 5S 5D 5C", "7S 8S 9S 6S 10S"],
+        &["7S 8S 9S 6S 10S"],
     )
 }
 
@@ -292,7 +292,7 @@ fn test_straight_flush_beats_four_of_a_kind() {
 fn test_straight_flush_ranks() {
     // both hands have straight flush, tie goes to highest-ranked card
     test(
-        &vec!["4H 6H 7H 8H 5H", "5S 7S 8S 9S 6S"],
-        &vec!["5S 7S 8S 9S 6S"],
+        &["4H 6H 7H 8H 5H", "5S 7S 8S 9S 6S"],
+        &["5S 7S 8S 9S 6S"],
     )
 }

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

@@ -31,7 +31,7 @@ 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(&vec![input], |v| v[0] + 1).unwrap();
+    let output = reactor.create_compute(&[input], |v| v[0] + 1).unwrap();
     assert_eq!(reactor.value(output), Some(2));
 }
 
@@ -41,7 +41,7 @@ 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(&vec![one, two], |v| v[0] + v[1] * 10).unwrap();
+    let output = reactor.create_compute(&[one, two], |v| v[0] + v[1] * 10).unwrap();
     assert_eq!(reactor.value(output), Some(21));
 }
 
@@ -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!(Reactor::new().create_compute(&vec![input], |_| 0).is_err());
+    assert!(Reactor::new().create_compute(&[input], |_| 0).is_err());
 }
 
 #[test]
@@ -61,7 +61,7 @@ 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!(reactor.create_compute(&vec![input, dummy_cell], |_| 0).is_err());
+    assert!(reactor.create_compute(&[input, dummy_cell], |_| 0).is_err());
     assert!(reactor.set_value(input, 5).is_ok());
     assert_eq!(reactor.value(input), Some(5));
 }
@@ -71,7 +71,7 @@ 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(&vec![input], |v| v[0] + 1).unwrap();
+    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));
@@ -82,9 +82,9 @@ 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(&vec![input], |v| v[0] * 2).unwrap();
-    let times_thirty = reactor.create_compute(&vec![input], |v| v[0] * 30).unwrap();
-    let output = reactor.create_compute(&vec![times_two, times_thirty], |v| v[0] + v[1]).unwrap();
+    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));
@@ -95,7 +95,7 @@ fn compute_cells_can_depend_on_other_compute_cells() {
 fn error_setting_a_compute_cell() {
     let mut reactor = Reactor::new();
     let input = reactor.create_input(1);
-    let output = reactor.create_compute(&vec![input], |_| 0).unwrap();
+    let output = reactor.create_compute(&[input], |_| 0).unwrap();
     assert!(reactor.set_value(output, 3).is_err());
 }
 
@@ -108,7 +108,7 @@ fn compute_cells_fire_callbacks() {
     {
         let mut reactor = Reactor::new();
         let input = reactor.create_input(1);
-        let output = reactor.create_compute(&vec![input], |v| v[0] + 1).unwrap();
+        let output = reactor.create_compute(&[input], |v| v[0] + 1).unwrap();
         assert!(reactor.add_callback(output, |v| values.push(v)).is_ok());
         assert!(reactor.set_value(input, 3).is_ok());
     }
@@ -120,7 +120,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(&vec![input], |_| 0).unwrap();
+    let output = dummy_reactor.create_compute(&[input], |_| 0).unwrap();
     assert!(Reactor::new().add_callback(output, |_: usize| println!("hi")).is_err());
 }
 
@@ -131,7 +131,7 @@ fn callbacks_only_fire_on_change() {
     {
         let mut reactor = Reactor::new();
         let input = reactor.create_input(1);
-        let output = reactor.create_compute(&vec![input], |v| if v[0] < 3 { 111 } else { 222 }).unwrap();
+        let output = reactor.create_compute(&[input], |v| if v[0] < 3 { 111 } else { 222 }).unwrap();
         assert!(reactor.add_callback(output, |v| values.push(v)).is_ok());
         assert!(reactor.set_value(input, 2).is_ok());
         assert!(reactor.set_value(input, 4).is_ok());
@@ -148,7 +148,7 @@ fn callbacks_can_be_added_and_removed() {
     {
         let mut reactor = Reactor::new();
         let input = reactor.create_input(11);
-        let output = reactor.create_compute(&vec![input], |v| v[0] + 1).unwrap();
+        let output = reactor.create_compute(&[input], |v| v[0] + 1).unwrap();
         let callback = reactor.add_callback(output, |v| values1.push(v)).unwrap();
         assert!(reactor.add_callback(output, |v| values2.push(v)).is_ok());
         assert!(reactor.set_value(input, 31).is_ok());
@@ -169,7 +169,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(&vec![input], |v| v[0] + 1).unwrap();
+        let output = reactor.create_compute(&[input], |v| v[0] + 1).unwrap();
         let callback = reactor.add_callback(output, |v| values1.push(v)).unwrap();
         assert!(reactor.add_callback(output, |v| values2.push(v)).is_ok());
         // We want the first remove to be Ok, but we don't care about the others.
@@ -190,10 +190,10 @@ fn callbacks_should_only_be_called_once_even_if_multiple_dependencies_change() {
     {
         let mut reactor = Reactor::new();
         let input = reactor.create_input(1);
-        let plus_one = reactor.create_compute(&vec![input], |v| v[0] + 1).unwrap();
-        let minus_one1 = reactor.create_compute(&vec![input], |v| v[0] - 1).unwrap();
-        let minus_one2 = reactor.create_compute(&vec![minus_one1], |v| v[0] - 1).unwrap();
-        let output = reactor.create_compute(&vec![plus_one, minus_one2], |v| v[0] * v[1]).unwrap();
+        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();
         assert!(reactor.add_callback(output, |v| values.push(v)).is_ok());
         assert!(reactor.set_value(input, 4).is_ok());
     }
@@ -207,9 +207,9 @@ fn callbacks_should_not_be_called_if_dependencies_change_but_output_value_doesnt
     {
         let mut reactor = Reactor::new();
         let input = reactor.create_input(1);
-        let plus_one = reactor.create_compute(&vec![input], |v| v[0] + 1).unwrap();
-        let minus_one = reactor.create_compute(&vec![input], |v| v[0] - 1).unwrap();
-        let always_two = reactor.create_compute(&vec![plus_one, minus_one], |v| v[0] - v[1]).unwrap();
+        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();
         assert!(reactor.add_callback(always_two, |v| values.push(v)).is_ok());
         for i in 2..5 {
             assert!(reactor.set_value(input, i).is_ok());
@@ -228,14 +228,14 @@ 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(&vec![a, b], |v| v[0] ^ v[1]).unwrap();
-    let sum = reactor.create_compute(&vec![a_xor_b, carry_in], |v| v[0] ^ v[1]).unwrap();
+    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_and_cin = reactor.create_compute(&vec![a_xor_b, carry_in], |v| v[0] && v[1]).unwrap();
-    let a_and_b = reactor.create_compute(&vec![a, b], |v| v[0] && v[1]).unwrap();
-    let carry_out = reactor.create_compute(&vec![a_xor_b_and_cin, a_and_b], |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 tests = vec![
+    let tests = &[
         (false, false, false, false, false),
         (false, false, true, false, true),
         (false, true, false, false, true),
@@ -246,7 +246,7 @@ fn test_adder_with_boolean_values() {
         (true, true, true, true, true),
     ];
 
-    for (aval, bval, cinval, expected_cout, expected_sum) in tests {
+    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());