Merge remote-tracking branch 'upstream/main' into fix-enum-variant-inconsistency

5 files changed, 124 insertions, 164 deletions

diff --git a/exercises/18_iterators/iterators1.rs b/exercises/18_iterators/iterators1.rs
index 31076bb..ca937ed 100644
--- a/exercises/18_iterators/iterators1.rs
+++ b/exercises/18_iterators/iterators1.rs
@@ -1,26 +1,25 @@
-// iterators1.rs
-//
 // When performing operations on elements within a collection, iterators are
 // essential. This module helps you get familiar with the structure of using an
 // iterator and how to go through elements within an iterable collection.
-//
-// Make me compile by filling in the `???`s
-//
-// Execute `rustlings hint iterators1` or use the `hint` watch subcommand for a
-// hint.
 
-// I AM NOT DONE
-
-#[test]
 fn main() {
-    let my_fav_fruits = vec!["banana", "custard apple", "avocado", "peach", "raspberry"];
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn iterators() {
+        let my_fav_fruits = ["banana", "custard apple", "avocado", "peach", "raspberry"];
 
-    let mut my_iterable_fav_fruits = ???;   // TODO: Step 1
+        // TODO: Create an iterator over the array.
+        let mut fav_fruits_iterator = todo!();
 
-    assert_eq!(my_iterable_fav_fruits.next(), Some(&"banana"));
-    assert_eq!(my_iterable_fav_fruits.next(), ???);     // TODO: Step 2
-    assert_eq!(my_iterable_fav_fruits.next(), Some(&"avocado"));
-    assert_eq!(my_iterable_fav_fruits.next(), ???);     // TODO: Step 3
-    assert_eq!(my_iterable_fav_fruits.next(), Some(&"raspberry"));
-    assert_eq!(my_iterable_fav_fruits.next(), ???);     // TODO: Step 4
+        assert_eq!(fav_fruits_iterator.next(), Some(&"banana"));
+        assert_eq!(fav_fruits_iterator.next(), todo!()); // TODO: Replace `todo!()`
+        assert_eq!(fav_fruits_iterator.next(), Some(&"avocado"));
+        assert_eq!(fav_fruits_iterator.next(), todo!()); // TODO: Replace `todo!()`
+        assert_eq!(fav_fruits_iterator.next(), Some(&"raspberry"));
+        assert_eq!(fav_fruits_iterator.next(), todo!()); // TODO: Replace `todo!()`
+    }
 }
diff --git a/exercises/18_iterators/iterators2.rs b/exercises/18_iterators/iterators2.rs
index dda82a0..5903e65 100644
--- a/exercises/18_iterators/iterators2.rs
+++ b/exercises/18_iterators/iterators2.rs
@@ -1,38 +1,32 @@
-// iterators2.rs
-//
 // In this exercise, you'll learn some of the unique advantages that iterators
-// can offer. Follow the steps to complete the exercise.
-//
-// Execute `rustlings hint iterators2` or use the `hint` watch subcommand for a
-// hint.
+// can offer.
 
-// I AM NOT DONE
-
-// Step 1.
-// Complete the `capitalize_first` function.
+// TODO: Complete the `capitalize_first` function.
 // "hello" -> "Hello"
-pub fn capitalize_first(input: &str) -> String {
-    let mut c = input.chars();
-    match c.next() {
+fn capitalize_first(input: &str) -> String {
+    let mut chars = input.chars();
+    match chars.next() {
         None => String::new(),
-        Some(first) => ???,
+        Some(first) => todo!(),
     }
 }
 
-// Step 2.
-// Apply the `capitalize_first` function to a slice of string slices.
+// TODO: Apply the `capitalize_first` function to a slice of string slices.
 // Return a vector of strings.
 // ["hello", "world"] -> ["Hello", "World"]
-pub fn capitalize_words_vector(words: &[&str]) -> Vec<String> {
-    vec![]
+fn capitalize_words_vector(words: &[&str]) -> Vec<String> {
+    // ???
 }
 
-// Step 3.
-// Apply the `capitalize_first` function again to a slice of string slices.
-// Return a single string.
+// TODO: Apply the `capitalize_first` function again to a slice of string
+// slices. Return a single string.
 // ["hello", " ", "world"] -> "Hello World"
-pub fn capitalize_words_string(words: &[&str]) -> String {
-    String::new()
+fn capitalize_words_string(words: &[&str]) -> String {
+    // ???
+}
+
+fn main() {
+    // You can optionally experiment here.
 }
 
 #[cfg(test)]
diff --git a/exercises/18_iterators/iterators3.rs b/exercises/18_iterators/iterators3.rs
index 29fa23a..65a0573 100644
--- a/exercises/18_iterators/iterators3.rs
+++ b/exercises/18_iterators/iterators3.rs
@@ -1,50 +1,33 @@
-// iterators3.rs
-//
-// This is a bigger exercise than most of the others! You can do it! Here is
-// your mission, should you choose to accept it:
-// 1. Complete the divide function to get the first four tests to pass.
-// 2. Get the remaining tests to pass by completing the result_with_list and
-//    list_of_results functions.
-//
-// Execute `rustlings hint iterators3` or use the `hint` watch subcommand for a
-// hint.
-
-// I AM NOT DONE
-
 #[derive(Debug, PartialEq, Eq)]
-pub enum DivisionError {
-    NotDivisible(NotDivisibleError),
+enum DivisionError {
     DivideByZero,
+    NotDivisible,
 }
 
-#[derive(Debug, PartialEq, Eq)]
-pub struct NotDivisibleError {
-    dividend: i32,
-    divisor: i32,
-}
-
-// Calculate `a` divided by `b` if `a` is evenly divisible by `b`.
+// TODO: Calculate `a` divided by `b` if `a` is evenly divisible by `b`.
 // Otherwise, return a suitable error.
-pub fn divide(a: i32, b: i32) -> Result<i32, DivisionError> {
+fn divide(a: i32, b: i32) -> Result<i32, DivisionError> {
     todo!();
 }
 
-// Complete the function and return a value of the correct type so the test
-// passes.
-// Desired output: Ok([1, 11, 1426, 3])
-fn result_with_list() -> () {
-    let numbers = vec![27, 297, 38502, 81];
+// TODO: Add the correct return type and complete the function body.
+// Desired output: `Ok([1, 11, 1426, 3])`
+fn result_with_list() {
+    let numbers = [27, 297, 38502, 81];
     let division_results = numbers.into_iter().map(|n| divide(n, 27));
 }
 
-// Complete the function and return a value of the correct type so the test
-// passes.
-// Desired output: [Ok(1), Ok(11), Ok(1426), Ok(3)]
-fn list_of_results() -> () {
-    let numbers = vec![27, 297, 38502, 81];
+// TODO: Add the correct return type and complete the function body.
+// Desired output: `[Ok(1), Ok(11), Ok(1426), Ok(3)]`
+fn list_of_results() {
+    let numbers = [27, 297, 38502, 81];
     let division_results = numbers.into_iter().map(|n| divide(n, 27));
 }
 
+fn main() {
+    // You can optionally experiment here.
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -55,19 +38,13 @@ mod tests {
     }
 
     #[test]
-    fn test_not_divisible() {
-        assert_eq!(
-            divide(81, 6),
-            Err(DivisionError::NotDivisible(NotDivisibleError {
-                dividend: 81,
-                divisor: 6
-            }))
-        );
+    fn test_divide_by_0() {
+        assert_eq!(divide(81, 0), Err(DivisionError::DivideByZero));
     }
 
     #[test]
-    fn test_divide_by_0() {
-        assert_eq!(divide(81, 0), Err(DivisionError::DivideByZero));
+    fn test_not_divisible() {
+        assert_eq!(divide(81, 6), Err(DivisionError::NotDivisible));
     }
 
     #[test]
@@ -77,14 +54,11 @@ mod tests {
 
     #[test]
     fn test_result_with_list() {
-        assert_eq!(format!("{:?}", result_with_list()), "Ok([1, 11, 1426, 3])");
+        assert_eq!(result_with_list().unwrap(), [1, 11, 1426, 3]);
     }
 
     #[test]
     fn test_list_of_results() {
-        assert_eq!(
-            format!("{:?}", list_of_results()),
-            "[Ok(1), Ok(11), Ok(1426), Ok(3)]"
-        );
+        assert_eq!(list_of_results(), [Ok(1), Ok(11), Ok(1426), Ok(3)]);
     }
 }
diff --git a/exercises/18_iterators/iterators4.rs b/exercises/18_iterators/iterators4.rs
index 79e1692..8381dbb 100644
--- a/exercises/18_iterators/iterators4.rs
+++ b/exercises/18_iterators/iterators4.rs
@@ -1,20 +1,16 @@
-// iterators4.rs
-//
-// Execute `rustlings hint iterators4` or use the `hint` watch subcommand for a
-// hint.
-
-// I AM NOT DONE
-
-pub fn factorial(num: u64) -> u64 {
-    // Complete this function to return the factorial of num
+fn factorial(num: u64) -> u64 {
+    // TODO: Complete this function to return the factorial of `num`.
     // Do not use:
-    // - return
+    // - early returns (using the `return` keyword explicitly)
     // Try not to use:
-    // - imperative style loops (for, while)
+    // - imperative style loops (for/while)
     // - additional variables
     // For an extra challenge, don't use:
     // - recursion
-    // Execute `rustlings hint iterators4` for hints.
+}
+
+fn main() {
+    // You can optionally experiment here.
 }
 
 #[cfg(test)]
@@ -23,20 +19,20 @@ mod tests {
 
     #[test]
     fn factorial_of_0() {
-        assert_eq!(1, factorial(0));
+        assert_eq!(factorial(0), 1);
     }
 
     #[test]
     fn factorial_of_1() {
-        assert_eq!(1, factorial(1));
+        assert_eq!(factorial(1), 1);
     }
     #[test]
     fn factorial_of_2() {
-        assert_eq!(2, factorial(2));
+        assert_eq!(factorial(2), 2);
     }
 
     #[test]
     fn factorial_of_4() {
-        assert_eq!(24, factorial(4));
+        assert_eq!(factorial(4), 24);
     }
 }
diff --git a/exercises/18_iterators/iterators5.rs b/exercises/18_iterators/iterators5.rs
index a062ee4..7e434cc 100644
--- a/exercises/18_iterators/iterators5.rs
+++ b/exercises/18_iterators/iterators5.rs
@@ -1,17 +1,8 @@
-// iterators5.rs
-//
-// 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.
-//
-// Execute `rustlings hint iterators5` or use the `hint` watch subcommand for a
-// hint.
-
-// I AM NOT DONE
+// functionality using iterators. Try to not use imperative loops (for/while).
 
 use std::collections::HashMap;
 
@@ -25,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;
             }
         }
@@ -50,43 +42,77 @@ 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() {
+    // 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!(3, count_iterator(&map, Progress::Complete));
+        assert_eq!(count_iterator(&map, Progress::Complete), 3);
     }
 
     #[test]
     fn count_some() {
         let map = get_map();
-        assert_eq!(1, count_iterator(&map, Progress::Some));
+        assert_eq!(count_iterator(&map, Progress::Some), 1);
     }
 
     #[test]
     fn count_none() {
         let map = get_map();
-        assert_eq!(2, count_iterator(&map, Progress::None));
+        assert_eq!(count_iterator(&map, Progress::None), 2);
     }
 
     #[test]
     fn count_complete_equals_for() {
         let map = get_map();
-        let progress_states = vec![Progress::Complete, Progress::Some, Progress::None];
+        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)
+                count_iterator(&map, progress_state),
             );
         }
     }
@@ -95,62 +121,33 @@ mod tests {
     fn count_collection_complete() {
         let collection = get_vec_map();
         assert_eq!(
+            count_collection_iterator(&collection, Progress::Complete),
             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));
+        assert_eq!(count_collection_iterator(&collection, Progress::Some), 1);
     }
 
     #[test]
     fn count_collection_none() {
         let collection = get_vec_map();
-        assert_eq!(4, count_collection_iterator(&collection, Progress::None));
+        assert_eq!(count_collection_iterator(&collection, Progress::None), 4);
     }
 
     #[test]
     fn count_collection_equals_for() {
-        let progress_states = vec![Progress::Complete, Progress::Some, Progress::None];
         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)
+                count_collection_iterator(&collection, progress_state),
             );
         }
     }
-
-    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]
-    }
 }