6 files changed, 359 insertions, 0 deletions
diff --git a/rustlings/exercises/18_iterators/README.md b/rustlings/exercises/18_iterators/README.md
new file mode 100644
index 0000000..0e8b671
--- /dev/null
+++ b/rustlings/exercises/18_iterators/README.md
@@ -0,0 +1,8 @@
+# Iterators
+
+This section will teach you about Iterators.
+
+## Further information
+
+- [Iterator](https://doc.rust-lang.org/book/ch13-02-iterators.html)
+- [Iterator documentation](https://doc.rust-lang.org/stable/std/iter/)
diff --git a/rustlings/exercises/18_iterators/iterators1.rs b/rustlings/exercises/18_iterators/iterators1.rs
new file mode 100644
index 0000000..ca937ed
--- /dev/null
+++ b/rustlings/exercises/18_iterators/iterators1.rs
@@ -0,0 +1,25 @@
+// 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.
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn iterators() {
+        let my_fav_fruits = ["banana", "custard apple", "avocado", "peach", "raspberry"];
+
+        // TODO: Create an iterator over the array.
+        let mut fav_fruits_iterator = todo!();
+
+        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/rustlings/exercises/18_iterators/iterators2.rs b/rustlings/exercises/18_iterators/iterators2.rs
new file mode 100644
index 0000000..5903e65
--- /dev/null
+++ b/rustlings/exercises/18_iterators/iterators2.rs
@@ -0,0 +1,57 @@
+// In this exercise, you'll learn some of the unique advantages that iterators
+// can offer.
+
+// TODO: Complete the `capitalize_first` function.
+// "hello" -> "Hello"
+fn capitalize_first(input: &str) -> String {
+    let mut chars = input.chars();
+    match chars.next() {
+        None => String::new(),
+        Some(first) => todo!(),
+    }
+}
+
+// TODO: Apply the `capitalize_first` function to a slice of string slices.
+// Return a vector of strings.
+// ["hello", "world"] -> ["Hello", "World"]
+fn capitalize_words_vector(words: &[&str]) -> Vec<String> {
+    // ???
+}
+
+// TODO: Apply the `capitalize_first` function again to a slice of string
+// slices. Return a single string.
+// ["hello", " ", "world"] -> "Hello World"
+fn capitalize_words_string(words: &[&str]) -> String {
+    // ???
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_success() {
+        assert_eq!(capitalize_first("hello"), "Hello");
+    }
+
+    #[test]
+    fn test_empty() {
+        assert_eq!(capitalize_first(""), "");
+    }
+
+    #[test]
+    fn test_iterate_string_vec() {
+        let words = vec!["hello", "world"];
+        assert_eq!(capitalize_words_vector(&words), ["Hello", "World"]);
+    }
+
+    #[test]
+    fn test_iterate_into_string() {
+        let words = vec!["hello", " ", "world"];
+        assert_eq!(capitalize_words_string(&words), "Hello World");
+    }
+}
diff --git a/rustlings/exercises/18_iterators/iterators3.rs b/rustlings/exercises/18_iterators/iterators3.rs
new file mode 100644
index 0000000..dce0905
--- /dev/null
+++ b/rustlings/exercises/18_iterators/iterators3.rs
@@ -0,0 +1,75 @@
+#[derive(Debug, PartialEq, Eq)]
+enum DivisionError {
+    // Example: 42 / 0
+    DivideByZero,
+    // Only case for `i64`: `i64::MIN / -1` because the result is `i64::MAX + 1`
+    IntegerOverflow,
+    // Example: 5 / 2 = 2.5
+    NotDivisible,
+}
+
+// TODO: Calculate `a` divided by `b` if `a` is evenly divisible by `b`.
+// Otherwise, return a suitable error.
+fn divide(a: i64, b: i64) -> Result<i64, DivisionError> {
+    todo!();
+}
+
+// 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));
+}
+
+// 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::*;
+
+    #[test]
+    fn test_success() {
+        assert_eq!(divide(81, 9), Ok(9));
+        assert_eq!(divide(81, -1), Ok(-81));
+        assert_eq!(divide(i64::MIN, i64::MIN), Ok(1));
+    }
+
+    #[test]
+    fn test_divide_by_0() {
+        assert_eq!(divide(81, 0), Err(DivisionError::DivideByZero));
+    }
+
+    #[test]
+    fn test_integer_overflow() {
+        assert_eq!(divide(i64::MIN, -1), Err(DivisionError::IntegerOverflow));
+    }
+
+    #[test]
+    fn test_not_divisible() {
+        assert_eq!(divide(81, 6), Err(DivisionError::NotDivisible));
+    }
+
+    #[test]
+    fn test_divide_0_by_something() {
+        assert_eq!(divide(0, 81), Ok(0));
+    }
+
+    #[test]
+    fn test_result_with_list() {
+        assert_eq!(result_with_list().unwrap(), [1, 11, 1426, 3]);
+    }
+
+    #[test]
+    fn test_list_of_results() {
+        assert_eq!(list_of_results(), [Ok(1), Ok(11), Ok(1426), Ok(3)]);
+    }
+}
diff --git a/rustlings/exercises/18_iterators/iterators4.rs b/rustlings/exercises/18_iterators/iterators4.rs
new file mode 100644
index 0000000..c296f0e
--- /dev/null
+++ b/rustlings/exercises/18_iterators/iterators4.rs
@@ -0,0 +1,41 @@
+fn factorial(num: u64) -> u64 {
+    // TODO: Complete this function to return the factorial of `num` which is
+    // defined as `1 * 2 * 3 * … * num`.
+    // https://en.wikipedia.org/wiki/Factorial
+    //
+    // Do not use:
+    // - early returns (using the `return` keyword explicitly)
+    // Try not to use:
+    // - imperative style loops (for/while)
+    // - additional variables
+    // For an extra challenge, don't use:
+    // - recursion
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn factorial_of_0() {
+        assert_eq!(factorial(0), 1);
+    }
+
+    #[test]
+    fn factorial_of_1() {
+        assert_eq!(factorial(1), 1);
+    }
+    #[test]
+    fn factorial_of_2() {
+        assert_eq!(factorial(2), 2);
+    }
+
+    #[test]
+    fn factorial_of_4() {
+        assert_eq!(factorial(4), 24);
+    }
+}
diff --git a/rustlings/exercises/18_iterators/iterators5.rs b/rustlings/exercises/18_iterators/iterators5.rs
new file mode 100644
index 0000000..7e434cc
--- /dev/null
+++ b/rustlings/exercises/18_iterators/iterators5.rs
@@ -0,0 +1,153 @@
+// 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
+}
+
+// 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 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 {
+                count += 1;
+            }
+        }
+    }
+    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 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!(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),
+            );
+        }
+    }
+}