ex(12): options

options3 is a little harder to grok: the key is to understand that pattern
matching is a form of assignment, so matching on optional_point to Some(p)
actually moves the Point out of the Option into the variable `p`.

Of the two solutions, I think I'd prefer matching on &optional_point because it
feels more explicit that we are borrowing during the Some(p) pattern matching.

.rustlings-state.txt

···
 DON'T EDIT THIS FILE!
 
-options1
+errors1
 
 intro1
 intro2
···
 hashmaps1
 hashmaps2
 hashmaps3
-quiz2
+quiz2
+options1
+options2
+options3

exercises/12_options/options1.rs

···
 // `hour_of_day` is higher than 23.
 fn maybe_icecream(hour_of_day: u16) -> Option<u16> {
     // TODO: Complete the function body.
+    match hour_of_day {
+        0..=21 => Some(5),
+        22..=23 => Some(0),
+        _ => None,
+    }
 }
 
 fn main() {
···
     fn raw_value() {
         // TODO: Fix this test. How do you get the value contained in the
         // Option?
-        let icecreams = maybe_icecream(12);
+        let icecreams = maybe_icecream(12).unwrap();
 
         assert_eq!(icecreams, 5); // Don't change this line.
     }

exercises/12_options/options2.rs

···
         let optional_target = Some(target);
 
         // TODO: Make this an if-let statement whose value is `Some`.
-        word = optional_target {
+        if let Some(word) = optional_target {
             assert_eq!(word, target);
         }
     }
···
         // TODO: Make this a while-let statement. Remember that `Vec::pop()`
         // adds another layer of `Option`. You can do nested pattern matching
         // in if-let and while-let statements.
-        integer = optional_integers.pop() {
-            assert_eq!(integer, cursor);
-            cursor -= 1;
+        while let Some(integer) = optional_integers.pop() {
+            if let Some(integer) = integer {
+                assert_eq!(integer, cursor);
+                cursor -= 1;
+            }
         }
 
         assert_eq!(cursor, 0);

exercises/12_options/options3.rs

···
     let optional_point = Some(Point { x: 100, y: 200 });
 
     // TODO: Fix the compiler error by adding something to this match statement.
-    match optional_point {
+    match &optional_point {
         Some(p) => println!("Co-ordinates are {},{}", p.x, p.y),
         _ => panic!("No match!"),
     }

solutions/12_options/options1.rs

···
+// This function returns how much icecream there is left in the fridge.
+// If it's before 22:00 (24-hour system), then 5 scoops are left. At 22:00,
+// someone eats it all, so no icecream is left (value 0). Return `None` if
+// `hour_of_day` is higher than 23.
+fn maybe_icecream(hour_of_day: u16) -> Option<u16> {
+    match hour_of_day {
+        0..=21 => Some(5),
+        22..=23 => Some(0),
+        _ => None,
+    }
+}
+
 fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn raw_value() {
+        // Using `unwrap` is fine in a test.
+        let icecreams = maybe_icecream(12).unwrap();
+
+        assert_eq!(icecreams, 5);
+    }
+
+    #[test]
+    fn check_icecream() {
+        assert_eq!(maybe_icecream(0), Some(5));
+        assert_eq!(maybe_icecream(9), Some(5));
+        assert_eq!(maybe_icecream(18), Some(5));
+        assert_eq!(maybe_icecream(22), Some(0));
+        assert_eq!(maybe_icecream(23), Some(0));
+        assert_eq!(maybe_icecream(24), None);
+        assert_eq!(maybe_icecream(25), None);
+    }
 }

solutions/12_options/options2.rs

···
 fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn simple_option() {
+        let target = "rustlings";
+        let optional_target = Some(target);
+
+        // if-let
+        if let Some(word) = optional_target {
+            assert_eq!(word, target);
+        }
+    }
+
+    #[test]
+    fn layered_option() {
+        let range = 10;
+        let mut optional_integers: Vec<Option<i8>> = vec![None];
+
+        for i in 1..=range {
+            optional_integers.push(Some(i));
+        }
+
+        let mut cursor = range;
+
+        // while-let with nested pattern matching
+        while let Some(Some(integer)) = optional_integers.pop() {
+            assert_eq!(integer, cursor);
+            cursor -= 1;
+        }
+
+        assert_eq!(cursor, 0);
+    }
 }

solutions/12_options/options3.rs

···
+#[derive(Debug)]
+struct Point {
+    x: i32,
+    y: i32,
+}
+
 fn main() {
-    // DON'T EDIT THIS SOLUTION FILE!
-    // It will be automatically filled after you finish the exercise.
+    let optional_point = Some(Point { x: 100, y: 200 });
+
+    // Solution 1: Matching over the `Option` (not `&Option`) but without moving
+    // out of the `Some` variant.
+    match optional_point {
+        Some(ref p) => println!("Co-ordinates are {},{}", p.x, p.y),
+        //   ^^^ added
+        _ => panic!("No match!"),
+    }
+
+    // Solution 2: Matching over a reference (`&Option`) by added `&` before
+    // `optional_point`.
+    match &optional_point {
+        Some(p) => println!("Co-ordinates are {},{}", p.x, p.y),
+        _ => panic!("No match!"),
+    }
+
+    println!("{optional_point:?}");
 }