Options | Faisal Affan

Versi Bahasa Indonesia. Baca dalam Bahasa Inggris

Tipe Option mewakili nilai opsional: setiap Option bisa berupa Some dan berisi nilai, atau None.
```
enum Option<T> {
  Some(T),
  None,
}
```
Sintaks if let memungkinkan kamu menggabungkan if dan let menjadi cara yang lebih ringkas untuk menangani nilai yang cocok dengan satu pola sementara mengabaikan sisanya.
Menggunakan if let berarti lebih sedikit pengetikan, lebih sedikit indentasi, dan lebih sedikit kode boilerplate.
Demikian pula sintaks while let memungkinkan kamu menggabungkan while dan let.
Referensi:

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> {
    // 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);
    }
}

Di latihan ini kita perlu mengembalikan sisa es krim berdasarkan jam yang diberikan.
- Jam 0 hingga 21 mengembalikan sisa 5 scoop.
- Jam 22 hingga 23 mengembalikan sisa 0 scoop.
- Jam 24 atau lebih mengembalikan None.

Jadi berdasarkan kondisi di atas kita dapat menggunakan sintaks match seperti ini:

match hour_of_day {
    0..=21 => Some(5),
    22..=23 => Some(0),
    _ => None,
  }
}

Dan untuk mendapatkan nilainya kita dapat menggunakan method unwrap.
unwrap dapat menyebabkan panic jika nilainya None jadi sebaiknya tidak digunakan, kita dapat menggunakan unwrap_or sebagai gantinya untuk memberikan nilai default jika None.

options2.rs

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);
    }
}

Di latihan ini kita perlu memperbaiki fungsi simple_option dengan menggunakan sintaks if let untuk membuka (unwrap/unpack) nilai Option dengan aman.
```
if let Some(word) = optional_target {
  assert_eq!(word, target);
}
```
Kode di atas akan membuka optional_target.
- Jika ada nilai Some, ia akan mengikatnya ke variabel word dan kita dapat menggunakannya di dalam block.
- Jika None maka akan diabaikan.

Tugas kedua adalah memperbaiki layered_option dengan menggunakan sintaks while let.

while let Some(Some(integer)) = optional_integers.pop() {
  assert_eq!(integer, cursor);
  cursor -= 1;
}

Kode di atas akan melakukan hal yang sama dengan if let, ia akan memeriksa nilai yang dikembalikan dari optional_integers.pop().
- Jika ada nilai Some di sana, ia akan mengikatnya ke variabel integer dan kemudian masuk ke dalam block.
- Jika None maka loop akan berhenti.

options3.rs

#[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.
}

Di latihan ini karena kita ingin menggunakan variabel optional_point lebih lanjut setelah match, kita tidak boleh memindahkan kepemilikan (ownership).
Sebaliknya kita harus mencocokkan referensi sehingga dapat dipinjam (borrowed) dengan menambahkan &.