Semua Tempat Pattern Bisa Digunakan
Pattern muncul di banyak tempat dalam Rust, dan kamu sudah sering menggunakannya tanpa sadar! Bagian ini membahas semua tempat yang membolehkan penggunaan pattern.
Cabang-cabang match
Seperti yang kita bahas di Bab 6, kita memakai pattern pada cabang-cabang ekspresi match. Secara formal, ekspresi match terdiri dari keyword match, sebuah nilai yang akan dicocokkan, dan satu atau lebih cabang match yang berisi sebuah pattern serta ekspresi yang dijalankan jika nilai itu cocok dengan pattern cabang tersebut, seperti ini:
match VALUE {
PATTERN => EXPRESSION,
PATTERN => EXPRESSION,
PATTERN => EXPRESSION,
}
Misalnya, ini ekspresi match dari Listing 6-5 yang mencocokkan nilai Option<i32> dalam variabel x:
match x {
None => None,
Some(i) => Some(i + 1),
}
Pattern dalam ekspresi match ini adalah None dan Some(i) di sebelah kiri setiap panah.
Salah satu syarat ekspresi match adalah harus bersifat exhaustif, artinya semua kemungkinan nilai dalam ekspresi match harus tercakup. Salah satu cara untuk memastikan kamu telah mencakup semua kemungkinan adalah dengan menaruh pattern catch-all pada cabang terakhir. Misalnya, nama variabel yang mencocokkan nilai apa pun tidak akan pernah gagal, sehingga mencakup semua kasus yang tersisa.
Pattern khusus _ akan mencocokkan apa pun, tetapi tidak pernah mengikat nilai ke sebuah variabel, jadi pattern ini sering dipakai pada cabang match terakhir. Pattern _ bisa berguna, misalnya, ketika kamu ingin mengabaikan nilai apa pun yang tidak disebutkan. Kita akan membahas pattern _ lebih lanjut di “Mengabaikan Nilai dalam Pattern” nanti dalam bab ini.
Statement let
Sebelum bab ini, kita baru secara eksplisit membahas penggunaan pattern bersama match dan if let, tetapi sebenarnya kita juga sudah memakai pattern di tempat lain, termasuk dalam statement let. Misalnya, perhatikan penugasan variabel sederhana dengan let ini:
#![allow(unused)]
fn main() {
let x = 5;
}
Setiap kali kamu memakai statement let seperti ini, kamu sebenarnya memakai pattern, meski mungkin tidak menyadarinya! Secara lebih formal, statement let terlihat seperti ini:
let PATTERN = EXPRESSION;
Pada statement seperti let x = 5; yang memuat nama variabel di slot PATTERN, nama variabel itu hanyalah bentuk pattern yang sangat sederhana. Rust membandingkan ekspresi dengan pattern lalu menetapkan nama-nama yang ditemukannya. Jadi, pada contoh let x = 5;, x adalah pattern yang artinya “ikat apa yang cocok di sini ke variabel x.” Karena nama x merupakan keseluruhan pattern, pattern ini pada dasarnya berarti “ikat semuanya ke variabel x, apa pun nilainya.”
Untuk melihat sisi pencocokan pola dari let dengan lebih jelas, perhatikan Listing 19-1, yang memakai pattern bersama let untuk mendestrukturisasi sebuah tuple.
fn main() {
let (x, y, z) = (1, 2, 3);
}
Di sini, kita mencocokkan sebuah tuple dengan sebuah pattern. Rust membandingkan nilai (1, 2, 3) dengan pattern (x, y, z) dan mendapati bahwa nilainya cocok dengan pattern itu—artinya, jumlah elemennya sama pada keduanya—lalu Rust mengikat 1 ke x, 2 ke y, dan 3 ke z. Kamu bisa membayangkan tuple pattern ini sebagai tiga pattern variabel tersendiri yang bersarang di dalamnya.
Jika jumlah elemen dalam pattern tidak sama dengan jumlah elemen dalam tuple, tipe secara keseluruhan tidak akan cocok dan kita akan mendapat error dari compiler. Misalnya, Listing 19-2 menunjukkan percobaan mendestrukturisasi tuple dengan tiga elemen menjadi dua variabel, yang tidak akan berhasil.
fn main() {
let (x, y) = (1, 2, 3);
}
Mencoba mengompilasi kode ini menghasilkan error tipe berikut:
$ cargo run
Compiling patterns v0.1.0 (file:///projects/patterns)
error[E0308]: mismatched types
--> src/main.rs:2:9
|
2 | let (x, y) = (1, 2, 3);
| ^^^^^^ --------- this expression has type `({integer}, {integer}, {integer})`
| |
| expected a tuple with 3 elements, found one with 2 elements
|
= note: expected tuple `({integer}, {integer}, {integer})`
found tuple `(_, _)`
For more information about this error, try `rustc --explain E0308`.
error: could not compile `patterns` (bin "patterns") due to 1 previous error
Untuk memperbaiki error ini, kita bisa mengabaikan satu atau lebih nilai dalam tuple memakai _ atau .., seperti yang akan kamu lihat di bagian “Mengabaikan Nilai dalam Pattern”. Jika masalahnya adalah terlalu banyak variabel dalam pattern, solusinya adalah menyamakan tipenya dengan menghapus variabel sampai jumlah variabel sama dengan jumlah elemen dalam tuple.
Ekspresi if let Bersyarat
Di Bab 6, kita membahas cara memakai ekspresi if let terutama sebagai cara lebih singkat untuk menulis match yang hanya mencocokkan satu kasus. Secara opsional, if let bisa disertai else yang berisi kode untuk dijalankan jika pattern pada if let tidak cocok.
Listing 19-3 menunjukkan bahwa kita juga bisa mencampur ekspresi if let, else if, dan else if let. Dengan begitu, kita punya lebih banyak keluwesan dibanding ekspresi match, yang hanya bisa menyatakan satu nilai untuk dibandingkan dengan pattern-pattern tersebut. Selain itu, Rust tidak mensyaratkan agar kondisi dalam rangkaian cabang if let, else if, dan else if let saling berkaitan.
Kode di Listing 19-3 menentukan warna latar belakangmu berdasarkan serangkaian pemeriksaan terhadap beberapa kondisi. Untuk contoh ini, kita membuat variabel dengan nilai yang ditulis langsung di kode, padahal dalam program nyata nilainya bisa berasal dari input pengguna.
fn main() {
let favorite_color: Option<&str> = None;
let is_tuesday = false;
let age: Result<u8, _> = "34".parse();
if let Some(color) = favorite_color {
println!("Using your favorite color, {color}, as the background");
} else if is_tuesday {
println!("Tuesday is green day!");
} else if let Ok(age) = age {
if age > 30 {
println!("Using purple as the background color");
} else {
println!("Using orange as the background color");
}
} else {
println!("Using blue as the background color");
}
}
if let, else if, else if let, dan elseJika pengguna menentukan warna favorit, warna itulah yang dipakai sebagai latar. Jika tidak ada warna favorit yang ditentukan dan hari ini Selasa, warna latarnya hijau. Jika tidak, ketika pengguna memberikan usia sebagai string dan kita berhasil menguraikannya menjadi angka, warnanya ungu atau oranye, tergantung nilai angkanya. Jika tidak ada kondisi yang terpenuhi, warna latarnya biru.
Struktur bersyarat ini memungkinkan kita menangani kebutuhan yang kompleks. Dengan nilai yang ditulis langsung di kode seperti di sini, contoh ini akan mencetak Using purple as the background color.
Kamu bisa melihat bahwa if let juga bisa memperkenalkan variabel baru yang menutupi (shadow) variabel yang sudah ada, sama seperti yang bisa dilakukan cabang match: baris if let Ok(age) = age memperkenalkan variabel age baru yang berisi nilai di dalam variant Ok, sehingga menutupi variabel age yang lama. Ini berarti kita perlu menaruh kondisi if age > 30 di dalam blok itu: kita tidak bisa menggabungkan kedua kondisi tersebut menjadi if let Ok(age) = age && age > 30. Variabel age baru yang ingin kita bandingkan dengan 30 belum berlaku sampai scope baru dimulai dengan kurung kurawal.
Kelemahan memakai ekspresi if let adalah compiler tidak memeriksa apakah semua kasus tercakup (exhaustiveness), sedangkan pada ekspresi match compiler melakukannya. Jika kita menghilangkan blok else terakhir dan dengan demikian ada kasus yang tidak tertangani, compiler tidak akan memberi tahu kita tentang kemungkinan bug logika tersebut.
Loop while let Bersyarat
Serupa dalam pembentukannya dengan if let, loop bersyarat while let memungkinkan loop while berjalan selama sebuah pattern terus cocok. Di Listing 19-4, kita menunjukkan loop while let yang menunggu pesan yang dikirim antar-thread, tetapi kali ini memeriksa Result, bukan Option.
fn main() {
let (tx, rx) = std::sync::mpsc::channel();
std::thread::spawn(move || {
for val in [1, 2, 3] {
tx.send(val).unwrap();
}
});
while let Ok(value) = rx.recv() {
println!("{value}");
}
}
while let untuk mencetak nilai selama rx.recv() mengembalikan OkContoh ini mencetak 1, 2, lalu 3. Metode recv mengambil pesan pertama dari sisi penerima channel dan mengembalikan Ok(value). Saat pertama kali kita melihat recv di Bab 16, kita membuka error-nya secara langsung, atau berinteraksi dengannya sebagai iterator memakai loop for. Namun, seperti yang ditunjukkan Listing 19-4, kita juga bisa memakai while let, karena metode recv mengembalikan Ok setiap kali ada pesan yang tiba, selama pengirim masih ada, lalu menghasilkan Err setelah sisi pengirim terputus.
Loop for
Dalam loop for, nilai yang langsung mengikuti keyword for adalah sebuah pattern. Misalnya, pada for x in y, x-lah pattern-nya. Listing 19-5 menunjukkan cara memakai pattern dalam loop for untuk mendestrukturisasi, atau memecah, tuple sebagai bagian dari loop for.
fn main() {
let v = vec!['a', 'b', 'c'];
for (index, value) in v.iter().enumerate() {
println!("{value} is at index {index}");
}
}
for untuk mendestrukturisasi tupleKode di Listing 19-5 akan mencetak hal berikut:
$ cargo run
Compiling patterns v0.1.0 (file:///projects/patterns)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.52s
Running `target/debug/patterns`
a is at index 0
b is at index 1
c is at index 2
Kita menyesuaikan sebuah iterator dengan metode enumerate agar menghasilkan nilai dan indeksnya, yang ditempatkan dalam sebuah tuple. Nilai pertama yang dihasilkan adalah tuple (0, 'a'). Saat nilai ini dicocokkan dengan pattern (index, value), index akan bernilai 0 dan value akan bernilai 'a', sehingga mencetak baris pertama dari keluaran.
Parameter Fungsi
Parameter fungsi juga bisa berupa pattern. Kode di Listing 19-6, yang mendeklarasikan fungsi bernama foo dengan satu parameter bernama x bertipe i32, pasti sudah terasa akrab bagimu sekarang.
fn foo(x: i32) {
// code goes here
}
fn main() {}
Bagian x itu adalah sebuah pattern! Sama seperti yang kita lakukan dengan let, kita bisa mencocokkan tuple pada argumen fungsi dengan sebuah pattern. Listing 19-7 memecah nilai-nilai dalam tuple saat kita meneruskannya ke sebuah fungsi.
fn print_coordinates(&(x, y): &(i32, i32)) {
println!("Current location: ({x}, {y})");
}
fn main() {
let point = (3, 5);
print_coordinates(&point);
}
Kode ini mencetak Current location: (3, 5). Nilai &(3, 5) cocok dengan pattern &(x, y), sehingga x bernilai 3 dan y bernilai 5.
Kita juga bisa memakai pattern dalam daftar parameter closure dengan cara yang sama seperti pada daftar parameter fungsi, karena closure mirip dengan fungsi, seperti yang kita bahas di Bab 13.
Pada titik ini, kamu sudah melihat beberapa cara memakai pattern, tetapi pattern tidak bekerja dengan cara yang sama di semua tempat. Di beberapa tempat, pattern harus bersifat irrefutable (tidak bisa gagal); dalam situasi lain, pattern boleh bersifat refutable (bisa gagal). Kita akan membahas kedua konsep ini selanjutnya.