From f53d4589205a5485011a341400eeea0ec3d6b339 Mon Sep 17 00:00:00 2001
From: mo8it <mo8it@proton.me>
Date: Fri, 28 Jun 2024 16:11:14 +0200
Subject: [PATCH] iterators5 solution

---
 exercises/18_iterators/iterators5.rs | 154 +++++++++++++--------------
 solutions/18_iterators/iterators5.rs | 151 +++++++++++++++++++++++++-
 2 files changed, 227 insertions(+), 78 deletions(-)

diff --git a/exercises/18_iterators/iterators5.rs b/exercises/18_iterators/iterators5.rs
index 4f052d51..7e434cc5 100644
--- a/exercises/18_iterators/iterators5.rs
+++ b/exercises/18_iterators/iterators5.rs
@@ -1,10 +1,8 @@
-// Let's define a simple model to track Rustlings exercise progress. Progress
+// Let's define a simple model to track Rustlings' exercise progress. Progress
 // will be modelled using a hash map. The name of the exercise is the key and
 // the progress is the value. Two counting functions were created to count the
 // number of exercises with a given progress. Recreate this counting
-// functionality using iterators. Try not to use imperative loops (for, while).
-// Only the two iterator methods (count_iterator and count_collection_iterator)
-// need to be modified.
+// functionality using iterators. Try to not use imperative loops (for/while).
 
 use std::collections::HashMap;
 
@@ -18,24 +16,25 @@ enum Progress {
 fn count_for(map: &HashMap<String, Progress>, value: Progress) -> usize {
     let mut count = 0;
     for val in map.values() {
-        if val == &value {
+        if *val == value {
             count += 1;
         }
     }
     count
 }
 
+// TODO: Implement the functionality of `count_for` but with an iterator instead
+// of a `for` loop.
 fn count_iterator(map: &HashMap<String, Progress>, value: Progress) -> usize {
-    // map is a hashmap with String keys and Progress values.
-    // map = { "variables1": Complete, "from_str": None, ... }
-    todo!();
+    // `map` is a hash map with `String` keys and `Progress` values.
+    // map = { "variables1": Complete, "from_str": None, … }
 }
 
 fn count_collection_for(collection: &[HashMap<String, Progress>], value: Progress) -> usize {
     let mut count = 0;
     for map in collection {
         for val in map.values() {
-            if val == &value {
+            if *val == value {
                 count += 1;
             }
         }
@@ -43,11 +42,12 @@ fn count_collection_for(collection: &[HashMap<String, Progress>], value: Progres
     count
 }
 
+// TODO: Implement the functionality of `count_collection_for` but with an
+// iterator instead of a `for` loop.
 fn count_collection_iterator(collection: &[HashMap<String, Progress>], value: Progress) -> usize {
-    // collection is a slice of hashmaps.
-    // collection = [{ "variables1": Complete, "from_str": None, ... },
-    //     { "variables2": Complete, ... }, ... ]
-    todo!();
+    // `collection` is a slice of hash maps.
+    // collection = [{ "variables1": Complete, "from_str": None, … },
+    //               { "variables2": Complete, … }, … ]
 }
 
 fn main() {
@@ -58,70 +58,6 @@ fn main() {
 mod tests {
     use super::*;
 
-    #[test]
-    fn count_complete() {
-        let map = get_map();
-        assert_eq!(3, count_iterator(&map, Progress::Complete));
-    }
-
-    #[test]
-    fn count_some() {
-        let map = get_map();
-        assert_eq!(1, count_iterator(&map, Progress::Some));
-    }
-
-    #[test]
-    fn count_none() {
-        let map = get_map();
-        assert_eq!(2, count_iterator(&map, Progress::None));
-    }
-
-    #[test]
-    fn count_complete_equals_for() {
-        let map = get_map();
-        let progress_states = vec![Progress::Complete, Progress::Some, Progress::None];
-        for progress_state in progress_states {
-            assert_eq!(
-                count_for(&map, progress_state),
-                count_iterator(&map, progress_state)
-            );
-        }
-    }
-
-    #[test]
-    fn count_collection_complete() {
-        let collection = get_vec_map();
-        assert_eq!(
-            6,
-            count_collection_iterator(&collection, Progress::Complete)
-        );
-    }
-
-    #[test]
-    fn count_collection_some() {
-        let collection = get_vec_map();
-        assert_eq!(1, count_collection_iterator(&collection, Progress::Some));
-    }
-
-    #[test]
-    fn count_collection_none() {
-        let collection = get_vec_map();
-        assert_eq!(4, count_collection_iterator(&collection, Progress::None));
-    }
-
-    #[test]
-    fn count_collection_equals_for() {
-        let progress_states = vec![Progress::Complete, Progress::Some, Progress::None];
-        let collection = get_vec_map();
-
-        for progress_state in progress_states {
-            assert_eq!(
-                count_collection_for(&collection, progress_state),
-                count_collection_iterator(&collection, progress_state)
-            );
-        }
-    }
-
     fn get_map() -> HashMap<String, Progress> {
         use Progress::*;
 
@@ -150,4 +86,68 @@ mod tests {
 
         vec![map, other]
     }
+
+    #[test]
+    fn count_complete() {
+        let map = get_map();
+        assert_eq!(count_iterator(&map, Progress::Complete), 3);
+    }
+
+    #[test]
+    fn count_some() {
+        let map = get_map();
+        assert_eq!(count_iterator(&map, Progress::Some), 1);
+    }
+
+    #[test]
+    fn count_none() {
+        let map = get_map();
+        assert_eq!(count_iterator(&map, Progress::None), 2);
+    }
+
+    #[test]
+    fn count_complete_equals_for() {
+        let map = get_map();
+        let progress_states = [Progress::Complete, Progress::Some, Progress::None];
+        for progress_state in progress_states {
+            assert_eq!(
+                count_for(&map, progress_state),
+                count_iterator(&map, progress_state),
+            );
+        }
+    }
+
+    #[test]
+    fn count_collection_complete() {
+        let collection = get_vec_map();
+        assert_eq!(
+            count_collection_iterator(&collection, Progress::Complete),
+            6,
+        );
+    }
+
+    #[test]
+    fn count_collection_some() {
+        let collection = get_vec_map();
+        assert_eq!(count_collection_iterator(&collection, Progress::Some), 1);
+    }
+
+    #[test]
+    fn count_collection_none() {
+        let collection = get_vec_map();
+        assert_eq!(count_collection_iterator(&collection, Progress::None), 4);
+    }
+
+    #[test]
+    fn count_collection_equals_for() {
+        let collection = get_vec_map();
+        let progress_states = [Progress::Complete, Progress::Some, Progress::None];
+
+        for progress_state in progress_states {
+            assert_eq!(
+                count_collection_for(&collection, progress_state),
+                count_collection_iterator(&collection, progress_state),
+            );
+        }
+    }
 }
diff --git a/solutions/18_iterators/iterators5.rs b/solutions/18_iterators/iterators5.rs
index 4e181989..402c81b0 100644
--- a/solutions/18_iterators/iterators5.rs
+++ b/solutions/18_iterators/iterators5.rs
@@ -1 +1,150 @@
-// Solutions will be available before the stable release. Thank you for testing the beta version 🥰
+// Let's define a simple model to track Rustlings' exercise progress. Progress
+// will be modelled using a hash map. The name of the exercise is the key and
+// the progress is the value. Two counting functions were created to count the
+// number of exercises with a given progress. Recreate this counting
+// functionality using iterators. Try to not use imperative loops (for/while).
+
+use std::collections::HashMap;
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Progress {
+    None,
+    Some,
+    Complete,
+}
+
+fn count_for(map: &HashMap<String, Progress>, value: Progress) -> usize {
+    let mut count = 0;
+    for val in map.values() {
+        if *val == value {
+            count += 1;
+        }
+    }
+    count
+}
+
+fn count_iterator(map: &HashMap<String, Progress>, value: Progress) -> usize {
+    // `map` is a hash map with `String` keys and `Progress` values.
+    // map = { "variables1": Complete, "from_str": None, … }
+    map.values().filter(|val| **val == value).count()
+}
+
+fn count_collection_for(collection: &[HashMap<String, Progress>], value: Progress) -> usize {
+    let mut count = 0;
+    for map in collection {
+        count += count_for(map, value);
+    }
+    count
+}
+
+fn count_collection_iterator(collection: &[HashMap<String, Progress>], value: Progress) -> usize {
+    // `collection` is a slice of hash maps.
+    // collection = [{ "variables1": Complete, "from_str": None, … },
+    //               { "variables2": Complete, … }, … ]
+    collection
+        .iter()
+        .map(|map| count_iterator(map, value))
+        .sum()
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn get_map() -> HashMap<String, Progress> {
+        use Progress::*;
+
+        let mut map = HashMap::new();
+        map.insert(String::from("variables1"), Complete);
+        map.insert(String::from("functions1"), Complete);
+        map.insert(String::from("hashmap1"), Complete);
+        map.insert(String::from("arc1"), Some);
+        map.insert(String::from("as_ref_mut"), None);
+        map.insert(String::from("from_str"), None);
+
+        map
+    }
+
+    fn get_vec_map() -> Vec<HashMap<String, Progress>> {
+        use Progress::*;
+
+        let map = get_map();
+
+        let mut other = HashMap::new();
+        other.insert(String::from("variables2"), Complete);
+        other.insert(String::from("functions2"), Complete);
+        other.insert(String::from("if1"), Complete);
+        other.insert(String::from("from_into"), None);
+        other.insert(String::from("try_from_into"), None);
+
+        vec![map, other]
+    }
+
+    #[test]
+    fn count_complete() {
+        let map = get_map();
+        assert_eq!(count_iterator(&map, Progress::Complete), 3);
+    }
+
+    #[test]
+    fn count_some() {
+        let map = get_map();
+        assert_eq!(count_iterator(&map, Progress::Some), 1);
+    }
+
+    #[test]
+    fn count_none() {
+        let map = get_map();
+        assert_eq!(count_iterator(&map, Progress::None), 2);
+    }
+
+    #[test]
+    fn count_complete_equals_for() {
+        let map = get_map();
+        let progress_states = [Progress::Complete, Progress::Some, Progress::None];
+        for progress_state in progress_states {
+            assert_eq!(
+                count_for(&map, progress_state),
+                count_iterator(&map, progress_state),
+            );
+        }
+    }
+
+    #[test]
+    fn count_collection_complete() {
+        let collection = get_vec_map();
+        assert_eq!(
+            count_collection_iterator(&collection, Progress::Complete),
+            6,
+        );
+    }
+
+    #[test]
+    fn count_collection_some() {
+        let collection = get_vec_map();
+        assert_eq!(count_collection_iterator(&collection, Progress::Some), 1);
+    }
+
+    #[test]
+    fn count_collection_none() {
+        let collection = get_vec_map();
+        assert_eq!(count_collection_iterator(&collection, Progress::None), 4);
+    }
+
+    #[test]
+    fn count_collection_equals_for() {
+        let collection = get_vec_map();
+        let progress_states = [Progress::Complete, Progress::Some, Progress::None];
+
+        for progress_state in progress_states {
+            assert_eq!(
+                count_collection_for(&collection, progress_state),
+                count_collection_iterator(&collection, progress_state),
+            );
+        }
+    }
+}