Implement unique as Iterator

Similar in spirit to
https://docs.rs/itertools/latest/src/itertools/unique_impl.rs.html
but ofc less sophisticated

Author: ochsnerd

src/day02.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::fs;
 use std::hash::Hash;
 
@@ -43,32 +43,33 @@ fn is_safe_part1(report: &Vec<i32>) -> bool {
         .all(|x| x < 4);
 
     let is_strictly_monotonic = 1
-        == unique(
-            report
-                .windows(2)
-                .map(|pair| {
-                    let [a, b] = pair else { unreachable!() };
-                    i32::signum(a - b)
-                })
-                .collect(),
-        )
-        .len();
-    steps_small_enough && is_strictly_monotonic
-}
+        == report
+            .windows(2)
+            .map(|pair| {
+                let [a, b] = pair else { unreachable!() };
+                i32::signum(a - b)
+            })
+            .uniques()
+            .count();
+    // instead of
+    // let is_strictly_monotonic = 1
+    //     == unique(
+    //         report
+    //             .windows(2)
+    //             .map(|pair| {
+    //                 let [a, b] = pair else { unreachable!() };
+    //                 i32::signum(a - b)
+    //             })
+    //             .collect(),
+    //     )
+    //     .len();
 
-fn unique<T>(v: Vec<T>) -> Vec<T>
-where
-    T: Eq + Hash,
-{
-    v.into_iter()
-        .collect::<std::collections::HashSet<T>>()
-        .into_iter()
-        .collect()
+    steps_small_enough && is_strictly_monotonic
 }
 
 fn is_safe_part2(mut report: Vec<i32>) -> bool {
-    if is_safe_part2_(report.clone()){
-	return true;
+    if is_safe_part2_(report.clone()) {
+        return true;
     }
     report.reverse();
     is_safe_part2_(report)
@@ -124,3 +125,95 @@ where
         condition(a, b)
     })
 }
+
+#[allow(dead_code)]
+fn unique<T>(v: Vec<T>) -> Vec<T>
+where
+    T: Eq + Hash,
+{
+    v.into_iter()
+        .collect::<std::collections::HashSet<T>>()
+        .into_iter()
+        .collect()
+}
+
+
+// upside: can be chained nicely, is lazy
+// downside: need clonable, up to 2x memory requirements
+struct Uniques<I, T>
+where
+    T: Eq + Hash + Clone,
+    I: Iterator<Item = T>,
+{
+    input: I,
+    seen: HashSet<T>,
+}
+
+impl<I, T> Uniques<I, T>
+where
+    T: Eq + Hash + Clone,
+    I: Iterator<Item = T>,
+{
+    fn new(input: I) -> Self {
+        Self {
+            input,
+            seen: HashSet::new(),
+        }
+    }
+}
+
+impl<I, T> Iterator for Uniques<I, T>
+where
+    T: Eq + Hash + Clone,
+    I: Iterator<Item = T>,
+{
+    type Item = T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while let Some(item) = self.input.next() {
+            if self.seen.insert(item.clone()) {
+                return Some(item);
+            }
+        }
+        None
+    }
+}
+
+// Extension trait to make it convenient to use
+trait IteratorExt: Iterator {
+    fn uniques(self) -> Uniques<Self, Self::Item>
+    where
+        Self: Sized,
+        Self::Item: Eq + Hash + Clone,
+    {
+        Uniques::new(self)
+    }
+}
+
+impl<I: Iterator> IteratorExt for I {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_uniques() {
+        let input = vec![1, 2, 3, 2, 4, 1, 5];
+        let result: Vec<i32> = input.into_iter().uniques().collect();
+        assert_eq!(result, vec![1, 2, 3, 4, 5]);
+    }
+
+    #[test]
+    fn test_uniques_strings() {
+        let input = vec!["a", "b", "c", "b", "a", "d"];
+        let result: Vec<&str> = input.into_iter().uniques().collect();
+        assert_eq!(result, vec!["a", "b", "c", "d"]);
+    }
+
+    #[test]
+    fn test_empty() {
+        let input: Vec<i32> = vec![];
+        let result: Vec<i32> = input.into_iter().uniques().collect();
+        assert_eq!(result, vec![]);
+    }
+}