Merge pull request #454 from petertseng/vecs

Use &[T] instead of &Vec<T> where possible

I believe this covers the following Clippy lints:

1. writing `&Vec<_>` instead of `&[_]` involves one more reference and
   cannot be used with non-Vec-based slices.
   * Where this was encountered, the signatures were changed from
    `Vec<T>` to `&[T]` in one commit; the resulting code compiles.
    second commit was additionally made to change uses of `vec!` into
    slices, which is not necessitated by the first commit by the commit
    but is enabled by it.
2. this argument is passed by value, but not consumed in the function
   body
   * Where this was encountered, the signatures were changed from
     `Vec<T>` to `&[T]` and the usages were changed from `vec!` to
     slices in one commit, since both changes need to happen together
     for the tests to compile.
3. useless use of `vec!`
   * Where this was encountered, uses of `vec!` were changed to slices.

Author: petertseng

exercises/allergies/tests/allergies.rs

@@ -2,7 +2,7 @@ extern crate allergies;
 
 use allergies::*;
 
-fn compare_allergy_vectors(expected: &Vec<Allergen>, actual: &Vec<Allergen>) {
+fn compare_allergy_vectors(expected: &[Allergen], actual: &[Allergen]) {
     for element in expected {
         if !actual.contains(element) {
             panic!("Allergen missing\n  {:?} should be in {:?}",
@@ -44,97 +44,97 @@ fn is_allergic_to_egg_shellfish_and_strawberries() {
 #[test]
 #[ignore]
 fn no_allergies_at_all() {
-    let expected: Vec<Allergen> = Vec::new();
+    let expected = &[];
     let allergies = Allergies::new(0).allergies();
 
-    compare_allergy_vectors(&expected, &allergies);
+    compare_allergy_vectors(expected, &allergies);
 }
 
 #[test]
 #[ignore]
 fn allergic_to_just_eggs() {
-    let expected = vec![Allergen::Eggs];
+    let expected = &[Allergen::Eggs];
     let allergies = Allergies::new(1).allergies();
 
-    compare_allergy_vectors(&expected, &allergies);
+    compare_allergy_vectors(expected, &allergies);
 }
 
 #[test]
 #[ignore]
 fn allergic_to_just_peanuts() {
-    let expected = vec![Allergen::Peanuts];
+    let expected = &[Allergen::Peanuts];
     let allergies = Allergies::new(2).allergies();
 
-    compare_allergy_vectors(&expected, &allergies);
+    compare_allergy_vectors(expected, &allergies);
 }
 
 #[test]
 #[ignore]
 fn allergic_to_just_strawberries() {
-    let expected = vec![Allergen::Strawberries];
+    let expected = &[Allergen::Strawberries];
     let allergies = Allergies::new(8).allergies();
 
-    compare_allergy_vectors(&expected, &allergies);
+    compare_allergy_vectors(expected, &allergies);
 }
 
 #[test]
 #[ignore]
 fn allergic_to_eggs_and_peanuts() {
-    let expected = vec![Allergen::Eggs, Allergen::Peanuts];
+    let expected = &[Allergen::Eggs, Allergen::Peanuts];
     let allergies = Allergies::new(3).allergies();
 
-    compare_allergy_vectors(&expected, &allergies);
+    compare_allergy_vectors(expected, &allergies);
 }
 
 #[test]
 #[ignore]
 fn allergic_to_eggs_and_shellfish() {
-    let expected = vec![Allergen::Eggs, Allergen::Shellfish];
+    let expected = &[Allergen::Eggs, Allergen::Shellfish];
     let allergies = Allergies::new(5).allergies();
 
-    compare_allergy_vectors(&expected, &allergies);
+    compare_allergy_vectors(expected, &allergies);
 }
 
 #[test]
 #[ignore]
 fn allergic_to_many_things() {
-    let expected = vec![Allergen::Strawberries,
-                        Allergen::Tomatoes,
-                        Allergen::Chocolate,
-                        Allergen::Pollen,
-                        Allergen::Cats];
+    let expected = &[Allergen::Strawberries,
+                     Allergen::Tomatoes,
+                     Allergen::Chocolate,
+                     Allergen::Pollen,
+                     Allergen::Cats];
     let allergies = Allergies::new(248).allergies();
 
-    compare_allergy_vectors(&expected, &allergies);
+    compare_allergy_vectors(expected, &allergies);
 }
 
 #[test]
 #[ignore]
 fn allergic_to_everything() {
-    let expected = vec![Allergen::Eggs,
-                        Allergen::Peanuts,
-                        Allergen::Shellfish,
-                        Allergen::Strawberries,
-                        Allergen::Tomatoes,
-                        Allergen::Chocolate,
-                        Allergen::Pollen,
-                        Allergen::Cats];
+    let expected = &[Allergen::Eggs,
+                     Allergen::Peanuts,
+                     Allergen::Shellfish,
+                     Allergen::Strawberries,
+                     Allergen::Tomatoes,
+                     Allergen::Chocolate,
+                     Allergen::Pollen,
+                     Allergen::Cats];
     let allergies = Allergies::new(255).allergies();
 
-    compare_allergy_vectors(&expected, &allergies);
+    compare_allergy_vectors(expected, &allergies);
 }
 
 #[test]
 #[ignore]
 fn scores_over_255_do_not_trigger_false_positives() {
-    let expected = vec![Allergen::Eggs,
-                        Allergen::Shellfish,
-                        Allergen::Strawberries,
-                        Allergen::Tomatoes,
-                        Allergen::Chocolate,
-                        Allergen::Pollen,
-                        Allergen::Cats];
+    let expected = &[Allergen::Eggs,
+                     Allergen::Shellfish,
+                     Allergen::Strawberries,
+                     Allergen::Tomatoes,
+                     Allergen::Chocolate,
+                     Allergen::Pollen,
+                     Allergen::Cats];
     let allergies = Allergies::new(509).allergies();
 
-    compare_allergy_vectors(&expected, &allergies);
+    compare_allergy_vectors(expected, &allergies);
 }

exercises/dominoes/example.rs

@@ -68,7 +68,7 @@ impl AvailabilityTable {
     }
 }
 
-pub fn chain(dominoes: &Vec<Domino>) -> Option<Vec<Domino>> {
+pub fn chain(dominoes: &[Domino]) -> Option<Vec<Domino>> {
     match dominoes.len() {
         0 => Some(vec!()),
         1 => if dominoes[0].0 == dominoes[0].1 { Some(vec![dominoes[0]]) } else { None },
@@ -100,8 +100,8 @@ pub fn chain(dominoes: &Vec<Domino>) -> Option<Vec<Domino>> {
     }
 }
 
-fn chain_worker(dominoes: &Vec<Domino>) -> Vec<Domino> {
-    let mut doms = dominoes.clone();
+fn chain_worker(dominoes: &[Domino]) -> Vec<Domino> {
+    let mut doms = dominoes.to_vec();
     let first = doms.pop().unwrap();
     let mut t = AvailabilityTable::new();
     for dom in doms.iter() {

exercises/dominoes/tests/dominoes.rs

@@ -21,7 +21,7 @@ fn normalize(d: &Domino) -> Domino {
     }
 }
 
-fn check(input: &Vec<Domino>) -> CheckResult {
+fn check(input: &[Domino]) -> CheckResult {
     let output = match dominoes::chain(input) {
         None => return GotInvalid,
         Some(o) => o
@@ -64,7 +64,7 @@ fn check(input: &Vec<Domino>) -> CheckResult {
     }
 }
 
-fn assert_correct(input: &Vec<Domino>) {
+fn assert_correct(input: &[Domino]) {
     match check(&input) {
         Correct => (),
         GotInvalid => panic!("Unexpectedly got invalid on input {:?}", input),
@@ -76,83 +76,83 @@ fn assert_correct(input: &Vec<Domino>) {
 
 #[test]
 fn empty_input_empty_output() {
-    let input = vec!();
-    assert_eq!(dominoes::chain(&input), Some(vec!()));
+    let input = &[];
+    assert_eq!(dominoes::chain(input), Some(vec!()));
 }
 
 #[test]
 #[ignore]
 fn singleton_input_singleton_output() {
-    let input = vec!((1, 1));
-    assert_correct(&input);
+    let input = &[(1, 1)];
+    assert_correct(input);
 }
 
 #[test]
 #[ignore]
 fn singleton_that_cant_be_chained() {
-    let input = vec![(1, 2)];
-    assert_eq!(dominoes::chain(&input), None);
+    let input = &[(1, 2)];
+    assert_eq!(dominoes::chain(input), None);
 }
 
 #[test]
 #[ignore]
 fn no_repeat_numbers() {
-    let input = vec!((1, 2), (3, 1), (2, 3));
-    assert_correct(&input);
+    let input = &[(1, 2), (3, 1), (2, 3)];
+    assert_correct(input);
 }
 
 #[test]
 #[ignore]
 fn can_reverse_dominoes() {
-    let input = vec![(1, 2), (1, 3), (2, 3)];
-    assert_correct(&input);
+    let input = &[(1, 2), (1, 3), (2, 3)];
+    assert_correct(input);
 }
 
 #[test]
 #[ignore]
 fn no_chains() {
-    let input = vec!((1, 2), (4, 1), (2, 3));
-    assert_eq!(dominoes::chain(&input), None);
+    let input = &[(1, 2), (4, 1), (2, 3)];
+    assert_eq!(dominoes::chain(input), None);
 }
 
 #[test]
 #[ignore]
 fn disconnected_simple() {
-    let input = vec![(1, 1), (2, 2)];
-    assert_eq!(dominoes::chain(&input), None);
+    let input = &[(1, 1), (2, 2)];
+    assert_eq!(dominoes::chain(input), None);
 }
 
 #[test]
 #[ignore]
 fn disconnected_double_loop() {
-    let input = vec![(1, 2), (2, 1), (3, 4), (4, 3)];
-    assert_eq!(dominoes::chain(&input), None);
+    let input = &[(1, 2), (2, 1), (3, 4), (4, 3)];
+    assert_eq!(dominoes::chain(input), None);
 }
 
 #[test]
 #[ignore]
 fn disconnected_single_isolated() {
-    let input = vec![(1, 2), (2, 3), (3, 1), (4, 4)];
-    assert_eq!(dominoes::chain(&input), None);
+    let input = &[(1, 2), (2, 3), (3, 1), (4, 4)];
+    assert_eq!(dominoes::chain(input), None);
 }
 
 #[test]
 #[ignore]
 fn need_backtrack() {
-    let input = vec![(1, 2), (2, 3), (3, 1), (2, 4), (2, 4)];
-    assert_correct(&input);
+    let input = &[(1, 2), (2, 3), (3, 1), (2, 4), (2, 4)];
+    assert_correct(input);
 }
 
 #[test]
 #[ignore]
 fn separate_loops() {
-    let input = vec![(1, 2), (2, 3), (3, 1), (1, 1), (2, 2), (3, 3)];
-    assert_correct(&input);
+    let input = &[(1, 2), (2, 3), (3, 1), (1, 1), (2, 2), (3, 3)];
+    assert_correct(input);
 }
 
 #[test]
 #[ignore]
 fn nine_elements() {
-    let input = vec!((1, 2), (5, 3), (3, 1), (1, 2), (2, 4), (1, 6), (2, 3), (3, 4), (5, 6));
-    assert_correct(&input);
+    let input = &[(1, 2), (5, 3), (3, 1), (1, 2), (2, 4), (1, 6), (2, 3), (3, 4), (5, 6)];
+    assert_correct(input);
 }

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"]));
 }