Result & Option di Rust

Rust tidak punya null atau exception. Sebagai gantinya, Rust menggunakan dua enum bawaan: Option<T> dan Result<T, E> untuk menangani ketiadaan nilai dan error.

Option<T> — Mungkin Ada, Mungkin Tidak

// Option<T> = Some(T) | None
fn cari_index(v: &[i32], target: i32) -> Option<usize> {
    for (i, &item) in v.iter().enumerate() {
        if item == target {
            return Some(i);
        }
    }
    None
}

fn main() {
    let angka = vec![10, 20, 30, 40];

    match cari_index(&angka, 30) {
        Some(i) => println!("Ditemukan di index {}", i),
        None => println!("Tidak ditemukan"),
    }
}

Method Option yang Berguna

let x: Option<i32> = Some(42);
let y: Option<i32> = None;

// unwrap — ambil nilai, panic jika None
println!("{}", x.unwrap());      // 42
// println!("{}", y.unwrap());   // PANIC!

// unwrap_or — default value jika None
println!("{}", y.unwrap_or(0));  // 0

// is_some / is_none
println!("{}", x.is_some());  // true
println!("{}", y.is_none());  // true

// map — transformasi nilai di dalam Some
let doubled = x.map(|v| v * 2);  // Some(84)

Result<T, E> — Sukses atau Error

use std::num::ParseIntError;

fn parse_angka(s: &str) -> Result<i32, ParseIntError> {
    s.parse::<i32>()
}

fn main() {
    match parse_angka("42") {
        Ok(n) => println!("Berhasil: {}", n),
        Err(e) => println!("Error: {}", e),
    }

    match parse_angka("abc") {
        Ok(n) => println!("Berhasil: {}", n),
        Err(e) => println!("Error: {}", e),
    }
}

if let — Pattern Matching Ringkas

let nilai: Option<i32> = Some(42);

// Daripada match penuh:
if let Some(n) = nilai {
    println!("Nilainya: {}", n);
}

// Untuk Result:
if let Ok(angka) = "123".parse::<i32>() {
    println!("Parsed: {}", angka);
}