Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Konstruksi Alur Kontrol match

Rust punya konstruksi alur kontrol yang sangat powerful bernama match, yang memungkinkan kamu membandingkan sebuah nilai terhadap serangkaian pattern lalu mengeksekusi kode berdasarkan pattern mana yang cocok. Pattern bisa terdiri dari nilai literal, nama variabel, wildcard, dan banyak hal lain; Bab 19 membahas semua jenis pattern dan apa gunanya. Kekuatan match berasal dari ekspresivitas pattern serta fakta bahwa compiler memastikan semua kemungkinan kasus sudah ditangani.

Bayangkan sebuah ekspresi match seperti mesin penghitung koin: koin meluncur di lintasan yang berlubang-lubang dengan berbagai ukuran, dan setiap koin jatuh lewat lubang pertama yang muat baginya. Begitu pula dengan nilai: nilai melewati setiap pattern dalam sebuah match, dan pada pattern pertama yang “muat,” nilai itu jatuh ke blok kode terkait untuk dipakai saat eksekusi.

Soal koin, mari kita gunakan koin sebagai contoh penggunaan match! Kita bisa menulis fungsi yang menerima koin AS yang jenisnya tidak diketahui dan, dengan cara mirip mesin penghitung tadi, menentukan jenis koin itu serta mengembalikan nilainya dalam sen, seperti pada Listing 6-3.

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

fn main() {}
Listing 6-3: Sebuah enum dan ekspresi match yang memakai varian-varian enum tersebut sebagai pattern-nya

Mari kita bedah match di fungsi value_in_cents. Pertama, kita menulis kata kunci match diikuti sebuah ekspresi, yang dalam hal ini adalah nilai coin. Ini tampak sangat mirip dengan ekspresi kondisional yang dipakai bersama if, tapi ada perbedaan besar: dengan if, kondisi harus menghasilkan nilai Boolean, sedangkan di sini bisa bertipe apa pun. Tipe coin pada contoh ini adalah enum Coin yang kita definisikan di baris pertama.

Berikutnya adalah arm-arm match. Sebuah arm terdiri atas dua bagian: sebuah pattern dan beberapa kode. Arm pertama di sini punya pattern berupa nilai Coin::Penny, lalu operator => yang memisahkan pattern dengan kode yang akan dijalankan. Kode di sini hanyalah nilai 1. Setiap arm dipisahkan dari arm berikutnya dengan koma.

Saat ekspresi match dieksekusi, ia membandingkan nilai hasil terhadap pattern setiap arm, secara berurutan. Jika sebuah pattern cocok dengan nilai, kode yang terkait dengan pattern itu dijalankan. Jika pattern tidak cocok, eksekusi berlanjut ke arm berikutnya, mirip seperti pada mesin penghitung koin. Kita boleh punya arm sebanyak yang kita butuhkan: pada Listing 6-3, match kita punya empat arm.

Kode pada setiap arm adalah sebuah ekspresi, dan nilai hasil ekspresi pada arm yang cocok itulah yang menjadi nilai kembalian untuk seluruh ekspresi match.

Biasanya kita tidak memakai kurung kurawal jika kode arm-nya pendek, seperti pada Listing 6-3 yang tiap arm hanya mengembalikan sebuah nilai. Jika kamu ingin menjalankan beberapa baris kode dalam sebuah arm, kamu harus memakai kurung kurawal, dan koma setelah arm itu menjadi opsional. Sebagai contoh, kode berikut mencetak “Lucky penny!” setiap kali method dipanggil dengan Coin::Penny, tapi tetap mengembalikan nilai terakhir dari blok, yaitu 1:

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => {
            println!("Lucky penny!");
            1
        }
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

fn main() {}

Pattern yang Mengikat ke Nilai

Fitur berguna lain dari arm match adalah kemampuannya mengikat ke bagian-bagian nilai yang cocok dengan pattern. Dengan inilah kita bisa mengekstrak nilai dari varian-varian enum.

Sebagai contoh, mari ubah salah satu varian enum kita agar menyimpan data di dalamnya. Mulai tahun 1999 sampai 2008, Amerika Serikat mencetak koin quarter dengan desain berbeda untuk masing-masing dari 50 negara bagian di satu sisinya. Koin lain tidak punya desain negara bagian, jadi hanya quarter yang punya nilai tambahan ini. Kita bisa menambahkan informasi ini ke enum kita dengan mengubah varian Quarter agar memuat sebuah nilai UsState yang tersimpan di dalamnya, seperti yang kita lakukan pada Listing 6-4.

#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn main() {}
Listing 6-4: Enum Coin yang varian Quarter-nya juga menyimpan sebuah nilai UsState

Bayangkan seorang teman sedang berusaha mengumpulkan semua 50 koin quarter negara bagian. Sementara kita memisahkan kembalian menurut jenis koin, kita juga akan menyebutkan nama negara bagian yang terkait dengan setiap quarter, sehingga jika ada yang belum dimiliki teman kita, ia bisa menambahkannya ke koleksinya.

Dalam ekspresi match untuk kode ini, kita menambahkan variabel bernama state ke pattern yang cocok dengan nilai varian Coin::Quarter. Saat sebuah Coin::Quarter cocok, variabel state akan mengikat ke nilai negara bagian dari quarter tersebut. Lalu, kita bisa memakai state di kode arm itu, seperti ini:

#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) => {
            println!("State quarter from {state:?}!");
            25
        }
    }
}

fn main() {
    value_in_cents(Coin::Quarter(UsState::Alaska));
}

Jika kita memanggil value_in_cents(Coin::Quarter(UsState::Alaska)), coin akan bernilai Coin::Quarter(UsState::Alaska). Saat kita membandingkan nilai itu dengan tiap arm match, tidak ada yang cocok sampai kita mencapai Coin::Quarter(state). Saat itu, binding untuk state akan bernilai UsState::Alaska. Binding itu lalu bisa kita pakai dalam ekspresi println!, sehingga nilai negara bagian di dalam varian enum Coin untuk Quarter berhasil kita ambil.

Pattern match pada Option<T>

Di bagian sebelumnya, kita ingin mengambil nilai T di dalam kasus Some saat memakai Option<T>; kita juga bisa menangani Option<T> dengan match, seperti yang kita lakukan pada enum Coin! Alih-alih membandingkan koin, kita akan membandingkan varian-varian Option<T>, tapi cara kerja ekspresi match tetap sama.

Katakanlah kita ingin menulis fungsi yang menerima sebuah Option<i32> dan, jika ada nilai di dalamnya, menambahkan 1 ke nilai itu. Jika tidak ada nilai di dalamnya, fungsi harus mengembalikan nilai None dan tidak mencoba melakukan operasi apa pun.

Fungsi ini sangat mudah ditulis berkat match, dan akan tampak seperti Listing 6-5.

fn main() {
    fn plus_one(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}
Listing 6-5: Fungsi yang memakai ekspresi match pada sebuah Option<i32>

Mari kita telusuri eksekusi pertama plus_one lebih rinci. Saat kita memanggil plus_one(five), variabel x di badan plus_one akan bernilai Some(5). Lalu kita bandingkan nilai itu dengan tiap arm match:

fn main() {
    fn plus_one(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

Nilai Some(5) tidak cocok dengan pattern None, jadi kita lanjut ke arm berikutnya:

fn main() {
    fn plus_one(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

Apakah Some(5) cocok dengan Some(i)? Cocok! Varian kita sama. i mengikat ke nilai yang terkandung dalam Some, sehingga i bernilai 5. Kode di arm match lalu dijalankan, jadi kita menambahkan 1 ke nilai i dan membuat nilai Some baru yang berisi total 6.

Kini pertimbangkan panggilan kedua plus_one pada Listing 6-5, di mana x adalah None. Kita masuk ke match dan bandingkan dengan arm pertama:

fn main() {
    fn plus_one(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

Cocok! Tidak ada nilai untuk ditambahkan, jadi program berhenti dan mengembalikan nilai None di sisi kanan =>. Karena arm pertama yang cocok, tidak ada arm lain yang dibandingkan.

Kombinasi match dan enum berguna dalam banyak situasi. Kamu akan sering melihat pola ini dalam kode Rust: match terhadap sebuah enum, mengikat sebuah variabel ke data di dalamnya, lalu mengeksekusi kode berdasarkan data itu. Awalnya sedikit membingungkan, tapi begitu terbiasa, kamu akan berharap semua bahasa punya hal seperti ini. Ini memang konsisten jadi favorit para pengguna.

Match Bersifat Ekshaustif

Ada satu aspek lain dari match yang perlu kita bahas: pattern pada arm-armnya harus menutupi semua kemungkinan. Pertimbangkan versi fungsi plus_one kita berikut ini, yang punya bug dan tidak akan mengompilasi:

fn main() {
    fn plus_one(x: Option<i32>) -> Option<i32> {
        match x {
            Some(i) => Some(i + 1),
        }
    }

    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

Kita tidak menangani kasus None, jadi kode ini akan menyebabkan bug. Untungnya, Rust tahu cara menangkap bug semacam ini. Jika kita mencoba mengompilasi kode ini, kita akan mendapatkan error berikut:

$ cargo run
   Compiling enums v0.1.0 (file:///projects/enums)
error[E0004]: non-exhaustive patterns: `None` not covered
 --> src/main.rs:3:15
  |
3 |         match x {
  |               ^ pattern `None` not covered
  |
note: `Option<i32>` defined here
 --> /rustc/58cf8f9c35b355199727627d07ae34a4e2846d67/library/core/src/option.rs:598:0
 ::: /rustc/58cf8f9c35b355199727627d07ae34a4e2846d67/library/core/src/option.rs:602:4
  |
  = note: not covered
  = note: the matched value is of type `Option<i32>`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
  |
4 ~             Some(i) => Some(i + 1),
5 ~             None => todo!(),
  |

For more information about this error, try `rustc --explain E0004`.
error: could not compile `enums` (bin "enums") due to 1 previous error

Rust tahu kita belum menutupi setiap kemungkinan kasus, dan bahkan tahu pattern mana yang kita lupakan! Match di Rust bersifat ekshaustif: kita harus menghabiskan setiap kemungkinan terakhir agar kode itu valid. Terutama pada kasus Option<T>, saat Rust mencegah kita lupa menangani kasus None secara eksplisit, Rust melindungi kita dari asumsi bahwa kita punya nilai padahal bisa jadi kita punya null, sehingga kesalahan senilai satu miliar dolar yang dibahas sebelumnya menjadi mustahil terjadi.

Pattern Catch-All dan Placeholder _

Dengan enum, kita juga bisa mengambil tindakan khusus untuk beberapa nilai tertentu, tapi untuk semua nilai lain mengambil satu tindakan default. Bayangkan kita sedang membuat sebuah game di mana, jika kamu melempar angka 3 pada dadu, pemainmu tidak bergerak tapi malah mendapat topi baru yang bagus. Jika melempar 7, pemain kehilangan topi bagus. Untuk semua nilai lain, pemain bergerak sebanyak angka itu di papan permainan. Berikut sebuah match yang mengimplementasikan logika itu, dengan hasil lemparan dadu ditulis mati alih-alih nilai acak, dan semua logika lain direpresentasikan sebagai fungsi tanpa badan karena mengimplementasikannya di luar cakupan contoh ini:

fn main() {
    let dice_roll = 9;
    match dice_roll {
        3 => add_fancy_hat(),
        7 => remove_fancy_hat(),
        other => move_player(other),
    }

    fn add_fancy_hat() {}
    fn remove_fancy_hat() {}
    fn move_player(num_spaces: u8) {}
}

Pada dua arm pertama, pattern-nya adalah nilai literal 3 dan 7. Untuk arm terakhir yang menutupi semua kemungkinan nilai lain, pattern-nya adalah variabel yang kita beri nama other. Kode yang dijalankan untuk arm other memakai variabel itu dengan meneruskannya ke fungsi move_player.

Kode ini mengompilasi meskipun kita belum mendaftar semua nilai yang mungkin dimiliki sebuah u8, karena pattern terakhir akan cocok dengan semua nilai yang tidak disebutkan secara khusus. Pattern catch-all ini memenuhi syarat bahwa match harus ekshaustif. Perhatikan bahwa kita harus menaruh arm catch-all di akhir karena pattern dievaluasi secara berurutan. Jika kita menaruh arm catch-all lebih awal, arm-arm lain tidak akan pernah dijalankan, jadi Rust akan memberi peringatan jika kita menambahkan arm setelah sebuah catch-all!

Rust juga punya pattern yang bisa kita pakai saat menginginkan catch-all tapi tidak ingin memakai nilai dalam pattern catch-all itu: _ adalah pattern khusus yang cocok dengan nilai apa pun dan tidak mengikat nilai tersebut. Ini memberi tahu Rust bahwa kita tidak akan memakai nilai itu, sehingga Rust tidak akan memperingatkan kita tentang variabel yang tidak terpakai.

Kita ubah aturan permainannya: Sekarang, jika kamu melempar angka selain 3 atau 7, kamu harus melempar lagi. Kita tidak perlu lagi memakai nilai catch-all, jadi kita bisa mengubah kode untuk memakai _ alih-alih variabel bernama other:

fn main() {
    let dice_roll = 9;
    match dice_roll {
        3 => add_fancy_hat(),
        7 => remove_fancy_hat(),
        _ => reroll(),
    }

    fn add_fancy_hat() {}
    fn remove_fancy_hat() {}
    fn reroll() {}
}

Contoh ini juga memenuhi syarat ekshaustif karena kita secara eksplisit mengabaikan semua nilai lain pada arm terakhir; tidak ada yang kita lupakan.

Terakhir, kita akan mengubah aturan permainan sekali lagi agar tidak terjadi apa pun pada giliranmu jika kamu melempar angka selain 3 atau 7. Kita bisa mengungkapkan hal itu dengan memakai nilai unit (tipe tuple kosong yang kita sebutkan di bagian “Tipe Tuple”) sebagai kode yang menyertai arm _:

fn main() {
    let dice_roll = 9;
    match dice_roll {
        3 => add_fancy_hat(),
        7 => remove_fancy_hat(),
        _ => (),
    }

    fn add_fancy_hat() {}
    fn remove_fancy_hat() {}
}

Di sini, kita secara eksplisit memberi tahu Rust bahwa kita tidak akan memakai nilai lain yang tidak cocok dengan pattern pada arm sebelumnya, dan kita tidak ingin menjalankan kode apa pun pada kasus ini.

Masih banyak lagi tentang pattern dan pencocokan pola yang akan kita bahas di Bab 19. Untuk sekarang, kita lanjut ke sintaks if let, yang bisa berguna saat ekspresi match terasa terlalu bertele-tele.