Improved iterators5.rs explanation.

exercises/standard_library_types/iterators5.rs

@@ -1,11 +1,14 @@
 // iterators5.rs
 
-// Rustling progress is modelled using a hash map. The name of the exercise is
+// Let's define a simple model to track Rustlings exercise progress. Progress
-// the key and the progress is the value. Two counting functions were created
+// will be modelled using a hash map. The name of the exercise is the key and
-// to count the number of exercises with a given progress. These counting
+// the progress is the value. Two counting functions were created to count the
-// functions use imperative style for loops. Recreate this counting
+// number of exercises with a given progress. These counting functions use
-// functionality using iterators.
+// imperative style for loops. Recreate this counting functionality using
-// Execute `rustlings hint iterators5` for hints.
+// iterators. Only the two iterator methods (count_iterator and
+// count_collection_iterator) need to be modified.
+// Execute `rustlings hint
+// iterators5` for hints.
 //
 // Make the code compile and the tests pass.
 
@@ -30,12 +33,14 @@ fn count_for(map: &HashMap<String, Progress>, value: Progress) -> usize {
     count
 }
 
-fn count(map: &HashMap<String, Progress>, value: Progress) -> usize {
+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, ... }
 }
 
-fn count_stack_for(stack: &[HashMap<String, Progress>], value: Progress) -> usize {
+fn count_collection_for(collection: &[HashMap<String, Progress>], value: Progress) -> usize {
     let mut count = 0;
-    for map in stack {
+    for map in collection {
         for val in map.values() {
             if val == &value {
                 count += 1;
@@ -45,7 +50,10 @@ fn count_stack_for(stack: &[HashMap<String, Progress>], value: Progress) -> usiz
     count
 }
 
-fn count_stack(stack: &[HashMap<String, Progress>], value: Progress) -> usize {
+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, ... }, ... ]
 }
 
 #[cfg(test)]
@@ -55,7 +63,7 @@ mod tests {
     #[test]
     fn count_complete() {
         let map = get_map();
-        assert_eq!(3, count(&map, Progress::Complete));
+        assert_eq!(3, count_iterator(&map, Progress::Complete));
     }
 
     #[test]
@@ -63,22 +71,25 @@ mod tests {
         let map = get_map();
         assert_eq!(
             count_for(&map, Progress::Complete),
-            count(&map, Progress::Complete)
+            count_iterator(&map, Progress::Complete)
         );
     }
 
     #[test]
-    fn count_stack_complete() {
+    fn count_collection_complete() {
-        let stack = get_map_stack();
+        let collection = get_vec_map();
-        assert_eq!(6, count_stack(&stack, Progress::Complete));
+        assert_eq!(
+            6,
+            count_collection_iterator(&collection, Progress::Complete)
+        );
     }
 
     #[test]
-    fn count_stack_equals_for() {
+    fn count_collection_equals_for() {
-        let stack = get_map_stack();
+        let collection = get_vec_map();
         assert_eq!(
-            count_stack_for(&stack, Progress::Complete),
+            count_collection_for(&collection, Progress::Complete),
-            count_stack(&stack, Progress::Complete)
+            count_collection_iterator(&collection, Progress::Complete)
         );
     }
 
@@ -96,7 +107,7 @@ mod tests {
         map
     }
 
-    fn get_map_stack() -> Vec<HashMap<String, Progress>> {
+    fn get_vec_map() -> Vec<HashMap<String, Progress>> {
         use Progress::*;
 
         let map = get_map();

info.toml

@@ -694,7 +694,7 @@ Step 2 & step 2.1:
 Very similar to the lines above and below. You've got this!
 Step 3:
 An iterator goes through all elements in a collection, but what if we've run out of
-elements? What should we expect here? If you're stuck, take a look at 
+elements? What should we expect here? If you're stuck, take a look at
 https://doc.rust-lang.org/std/iter/trait.Iterator.html for some ideas.
 """
 
@@ -749,12 +749,13 @@ hint = """
 The documentation for the std::iter::Iterator trait contains numerous methods
 that would be helpful here.
 
-Return 0 from count_stack to make the code compile in order to test count.
+Return 0 from count_collection_iterator to make the code compile in order to
+test count_iterator.
 
-The stack variable in count_stack is a slice of HashMaps. It needs to be
+The collection variable in count_collection_iterator is a slice of HashMaps. It
-converted into an iterator in order to use the iterator methods.
+needs to be converted into an iterator in order to use the iterator methods.
 
-The fold method can be useful in the count_stack function."""
+The fold method can be useful in the count_collection_iterator function."""
 
 # THREADS