• Option
• Result
• Operator ?
• Kesimpulan

Halo teman-teman semuanya, pada artikel sebelumnya kita sudah mempelajari tentang enum dan pattern matching di Rust. Kita melihat bagaimana enum bisa merepresentasikan berbagai kemungkinan nilai dan bagaimana match serta if let digunakan untuk mencocokkan pola secara aman.

Kali ini kita akan masuk ke dua enum bawaan yang sangat penting di Rust, yaitu Option dan Result. Kedua enum ini begitu sering digunakan sampai bisa dikatakan menjadi bagian inti dari gaya pemrograman Rust.

• Option digunakan untuk merepresentasikan kemungkinan ada atau tidaknya sebuah nilai (mirip konsep nullable di bahasa lain, tetapi lebih aman).
• Result digunakan untuk merepresentasikan hasil yang bisa sukses atau gagal, dan inilah cara Rust menangani error tanpa exception.

Mari kita bahas satu per satu.

Option

Enum Option didefinisikan seperti ini:

enum Option<T> {
    Some(T),
    None,
}

Artinya, sebuah nilai bertipe Option<T> bisa berisi Some(T) jika ada nilai, atau None jika tidak ada.

Contoh penggunaan:

fn main() {
    let angka: Option<i32> = Some(10);
    let kosong: Option<i32> = None;

    match angka {
        Some(n) => println!("Angka: {}", n),
        None => println!("Tidak ada angka"),
    }

    match kosong {
        Some(n) => println!("Angka: {}", n),
        None => println!("Nilai kosong"),
    }
}

Dengan Option, Rust memaksa kita menangani kemungkinan None, sehingga lebih aman dibandingkan bahasa lain yang membiarkan null pointer exception.

Kita juga bisa menggunakan if let agar kode lebih ringkas:

fn main() {
    let nama: Option<&str> = Some("Rustacean");

    if let Some(n) = nama {
        println!("Halo, {}", n);
    }
}

Result

Enum Result didefinisikan seperti ini:

enum Result<T, E> {
    Ok(T),
    Err(E),
}

Result digunakan untuk menandai operasi yang bisa berhasil (Ok) atau gagal (Err).

Contoh sederhana:

fn bagi(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err(String::from("Tidak bisa membagi dengan nol"))
    } else {
        Ok(a / b)
    }
}

fn main() {
    let hasil = bagi(10, 2);
    let gagal = bagi(10, 0);

    match hasil {
        Ok(n) => println!("Hasil: {}", n),
        Err(e) => println!("Error: {}", e),
    }

    match gagal {
        Ok(n) => println!("Hasil: {}", n),
        Err(e) => println!("Error: {}", e),
    }
}

Operator ?

Rust menyediakan cara singkat untuk menyebarkan error dengan operator ?. Jika sebuah fungsi mengembalikan Result, kita bisa menggunakan ? untuk keluar lebih awal jika terjadi error.

fn bagi(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err(String::from("Tidak bisa membagi dengan nol"))
    } else {
        Ok(a / b)
    }
}

fn hitung() -> Result<(), String> {
    let n1 = bagi(10, 2)?; // jika error, langsung return Err
    let n2 = bagi(20, 0)?; // error, fungsi keluar di sini
    println!("Hasil total: {}", n1 + n2);
    Ok(())
}

fn main() {
    let res = hitung();
    println!("{:?}", res);
}

Dengan ?, kode menjadi lebih ringkas sekaligus tetap aman.

Kesimpulan

Pada artikel ini kita sudah mempelajari dua enum bawaan penting di Rust: Option dan Result. Option digunakan untuk merepresentasikan nilai yang mungkin ada atau tidak ada, sementara Result digunakan untuk merepresentasikan operasi yang bisa berhasil atau gagal.

Dengan keduanya, Rust mendorong kita menulis kode yang lebih eksplisit dan aman, tanpa takut null pointer exception atau error yang tidak tertangani.

Pada artikel berikutnya, kita akan membahas tentang Generics, yaitu bagaimana cara menulis kode yang fleksibel dan bisa digunakan untuk berbagai tipe data tanpa duplikasi.

Terima Kasih