• Membuat Enum
• Enum dengan Data
• Enum dengan Struct di Dalamnya
• Pattern Matching dengan match
• Pattern Matching dengan if let
• Kesimpulan

Halo teman-teman semuanya, pada artikel sebelumnya kita sudah belajar tentang struct di Rust. Kita mengetahui bagaimana membuat tipe data kustom dengan field-field tertentu, membuat struct mutable, shorthand initialization, update syntax, hingga tuple struct dan unit-like struct. Struct memungkinkan kita mengelompokkan data yang berbeda ke dalam satu entitas yang lebih bermakna.

Namun, terkadang kita tidak hanya ingin mengelompokkan data, tetapi juga ingin mendefinisikan berbagai kemungkinan nilai yang bisa dimiliki oleh suatu tipe. Misalnya, sebuah status pesanan bisa bernilai Pending, Proses, atau Selesai. Dalam kasus seperti ini, Rust menyediakan enum.

Enum (enumeration) adalah tipe data yang bisa memiliki beberapa varian. Dengan enum, kita bisa merepresentasikan pilihan atau kondisi yang terbatas.

Rust juga menggabungkan enum dengan fitur powerful bernama pattern matching, melalui keyword match. Fitur ini membuat Rust sangat ekspresif sekaligus aman.

Membuat Enum

Kita bisa membuat enum menggunakan keyword enum.

enum OrderStatus {
    Pending,
    Processing,
    Completed,
}

fn main() {
    let status = OrderStatus::Processing;

    match status {
        OrderStatus::Pending => println!("Pesanan sedang menunggu"),
        OrderStatus::Processing => println!("Pesanan sedang diproses"),
        OrderStatus::Completed => println!("Pesanan selesai"),
    }
}

Di sini kita membuat enum OrderStatus dengan tiga kemungkinan varian. Saat nilai status dicek dengan match, Rust memastikan semua kemungkinan varian sudah ditangani. Jika ada yang terlewat, program tidak akan bisa di-compile.

Enum dengan Data

Enum di Rust bisa menyimpan data, mirip dengan struct, tetapi hanya pada salah satu variannya.

enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
}

fn main() {
    let c = Shape::Circle(10.0);
    let r = Shape::Rectangle(5.0, 8.0);

    match c {
        Shape::Circle(radius) => println!("Lingkaran dengan jari-jari {}", radius),
        Shape::Rectangle(_, _) => println!("Bukan lingkaran"),
    }

    match r {
        Shape::Circle(_) => println!("Bukan persegi panjang"),
        Shape::Rectangle(p, l) => println!("Persegi panjang {} x {}", p, l),
    }
}

Enum Shape memiliki dua varian: Circle dengan data f64 dan Rectangle dengan dua data f64. Dengan pattern matching, kita bisa langsung mengekstrak nilai dari enum.

Enum dengan Struct di Dalamnya

Enum juga bisa berisi data kompleks seperti struct.

struct Point {
    x: i32,
    y: i32,
}

enum Message {
    Quit,
    Move(Point),
    Write(String),
}

fn main() {
    let msg1 = Message::Quit;
    let msg2 = Message::Move(Point { x: 10, y: 20 });
    let msg3 = Message::Write(String::from("Halo Rust"));

    match msg2 {
        Message::Quit => println!("Keluar"),
        Message::Move(p) => println!("Pindah ke {}, {}", p.x, p.y),
        Message::Write(text) => println!("Pesan: {}", text),
    }
}

Dengan ini, enum bisa menjadi sangat fleksibel untuk merepresentasikan berbagai bentuk data.

Pattern Matching dengan match

Keyword match digunakan untuk mencocokkan nilai dengan pola. Rust memaksa kita menangani semua kemungkinan pola, sehingga kode menjadi lebih aman.

fn main() {
    let angka = 3;

    match angka {
        1 => println!("Satu"),
        2 | 3 => println!("Dua atau Tiga"), // beberapa pola sekaligus
        4..=10 => println!("Antara 4 sampai 10"), // range
        _ => println!("Selain itu"), // default
    }
}

Simbol _ digunakan sebagai “catch-all” atau default untuk menangani nilai selain pola yang sudah didefinisikan.

Pattern Matching dengan if let

Kadang kita hanya peduli pada satu pola dan mengabaikan sisanya. Untuk kasus ini, Rust menyediakan if let.

fn main() {
    let status = Some(5);

    if let Some(x) = status {
        println!("Angka: {}", x);
    } else {
        println!("Bukan angka");
    }
}

if let membuat kode lebih ringkas dibandingkan match jika hanya ada satu pola yang perlu diperiksa.

Kesimpulan

Pada artikel ini kita sudah belajar tentang enum dan pattern matching di Rust. Kita melihat bagaimana enum bisa digunakan untuk merepresentasikan berbagai kemungkinan nilai, bagaimana enum bisa menyimpan data sederhana maupun kompleks, serta bagaimana match dan if let membantu mencocokkan pola secara aman dan ekspresif.

Di artikel berikutnya, kita akan membahas tentang Option & Result di Rust, yaitu dua enum bawaan yang sangat penting untuk menangani nilai yang mungkin kosong dan error secara aman.

Terima Kasih