> For the complete documentation index, see [llms.txt](https://bagus-cahyono.gitbook.io/programming-notes/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://bagus-cahyono.gitbook.io/programming-notes/rust/rustlings_exercise/12_options.md).

# Options

* Type `Option` represents an optional value: every Option is either `Some` and contains a value, or `None`.

  ```rust
  enum Option<T> {
    Some(T),
    None,
  }
  ```
* The `if let` syntax lets you combine `if` and `let` into a less verbose way to handle values that match one pattern while ignoring the rest.
* Using `if let` means less typing, less indentation, and less boilerplate code.
* Similarly `while let` syntax lets you combine `while` and `let`.
* References:
  * [Option Enum Format](https://doc.rust-lang.org/book/ch10-01-syntax.html#in-enum-definitions)
  * [Option Module Documentation](https://doc.rust-lang.org/std/option/)
  * [Option Enum Documentation](https://doc.rust-lang.org/std/option/enum.Option.html)
  * [Concise Control Flow with `if let`](https://doc.rust-lang.org/book/ch06-03-if-let.html)
  * [while let](https://doc.rust-lang.org/rust-by-example/flow_control/while_let.html)

## options1.rs

```rust
// 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> {
    // Complete the function body.
    match hour_of_day {
        0..=21 => Some(5),
        22..=23 => Some(0),
        _ => None,
    }
}

fn main() {
    // You can optionally experiment here.
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn raw_value() {
        // Fix this test. How do you get the value contained in the
        // Option?
        let icecreams = maybe_icecream(12).unwrap();

        assert_eq!(icecreams, 5); // Don't change this line.
    }

    #[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);
    }
}
```

* In this exercise we need to return ice cream left by given hour.
  * Hour `0` until `21` return `5` scoop left.
  * Hour `22` until `23` return `0` scoop left.
  * Hour `24` or more return `None`.
* So based on the condition above we can use `match` syntax like this:

  ```rust
  match hour_of_day {
      0..=21 => Some(5),
      22..=23 => Some(0),
      _ => None,
    }
  }
  ```
* And to get the value we can use `unwrap` method.
* `unwrap` can cause panic if the values is `None` so best not to use, we can use `unwrap_or` instead to provide default value if `None`.

## options2.rs

```rust
fn main() {
    // You can optionally experiment here.
}

#[cfg(test)]
mod tests {
    #[test]
    fn simple_option() {
        let target = "rustlings";
        let optional_target = Some(target);

        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;

        // 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.
        while let Some(Some(integer)) = optional_integers.pop() {
            assert_eq!(integer, cursor);
            cursor -= 1;
        }

        assert_eq!(cursor, 0);
    }
}
```

* In this exercise we need to fix `simple_option` function by using `if let` syntax to safely unwrap/unpack the `Option` value.

  ```rust
  let Some(word) = optional_target {
    assert_eq!(word, target);
  }
  ```
* The code above will unwrap the `optional_target`.
  * If there is `Some` value it will bind it to variable `word` and we can use it inside the block.
  * If `None` then it will ignore it.
* Second task is to fix `simple_option` by using `while let` syntax.

  ```rust
  while let Some(Some(integer)) = optional_integers.pop() {
    assert_eq!(integer, cursor);
    cursor -= 1;
  }
  ```
* The code above will do same thing with `if let`, it will check the returned value of `optional_integers.pop()`.
  * If there is `Some` value there it will bind it to `integer` variable and then goes inside the block.
  * If `None` the loop will stop.

## options3.rs

```rust
#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let optional_point = Some(Point { x: 100, y: 200 });

    // Fix the compiler error by adding something to this match statement.
    match &optional_point { // Add &
        Some(p) => println!("Co-ordinates are {},{}", p.x, p.y),
        _ => panic!("No match!"),
    }

    println!("{optional_point:?}"); // Don't change this line.
}
```

* In this exercise because we want to use the variables `optional_point` further after match we should not move the ownership.
* Instead we should match the reference so it can be borrowed by adding `&`.