Use trait to increase flexibility

By using IntoIterator, the changed functions become more flexible in
what input they accept.

1 files changed, 12 insertions, 9 deletions

diff --git a/2021/rust/day01/src/main.rs b/2021/rust/day01/src/main.rs
index a3a6e73..559f98c 100644
--- a/2021/rust/day01/src/main.rs
+++ b/2021/rust/day01/src/main.rs
@@ -31,16 +31,16 @@ enum Change {
     Identical,
 }
 
-fn count_increases(values: &[usize]) -> usize {
-    let changes: Vec<Change> = values.iter().scan(None, |state, val| {
+fn count_increases<'a, I: IntoIterator<Item = &'a usize>>(values: I) -> usize {
+    let changes: Vec<Change> = values.into_iter().scan(None, |state, val| {
         let next = match state {
             None => Change::NoPrevVal,
-            Some(prev) if val < prev => Change::Decreased,
-            Some(prev) if val > prev => Change::Increased,
-            Some(prev) if val == prev => Change::Identical,
+            Some(prev) if val < *prev => Change::Decreased,
+            Some(prev) if val > *prev => Change::Increased,
+            Some(prev) if val == *prev => Change::Identical,
             Some(_) => unreachable!(),
         };
-        *state = Some(*val);
+        *state = Some(val);
         Some(next)
     }).collect();
 
@@ -49,14 +49,17 @@ fn count_increases(values: &[usize]) -> usize {
     )
 }
 
-fn part1(input: &[usize]) -> Result<usize> {
+fn part1<'a, I: IntoIterator<Item = &'a usize>>(input: I) -> Result<usize> {
     let count = count_increases(input);
 
     Ok(count)
 }
 
-fn part2(input: &[usize]) -> Result<usize> {
-    let slidesums: Vec<_> = input.iter().zip(input[1..].iter()).zip(input[2..].iter()).map(|n| {
+fn part2<'a, I: IntoIterator<Item = &'a usize> + Copy>(input: I) -> Result<usize> {
+    let left_iter = input.into_iter();
+    let middle_iter = input.into_iter().skip(1);
+    let right_iter = input.into_iter().skip(2);
+    let slidesums: Vec<_> = left_iter.zip(middle_iter).zip(right_iter).map(|n| {
         let ((first, second), third) = n;
         first + second + third
     }).collect();