BAB 30: Block Expression
Blok di Rust menghasilkan nilai dari ekspresi terakhirnya, dan titik koma di baris akhir mengubah hasil blok menjadi unit.
Blok { ... } di Rust bukan pembungkus baris kode. Reference Rust menyebut blok sebagai "a control flow expression and anonymous namespace scope for items and variable declarations", dan 2 peran itu menjelaskan hampir seluruh perilakunya: blok menjalankan isinya berurutan, lalu meneruskan nilai ekspresi terakhir, sementara nama yang dideklarasikan di dalamnya berhenti terlihat setelah kurung kurawal penutup.
Peran pertama langsung terlihat pada contoh terkecil. Baris let luas = { let panjang = 4; let lebar = 3; panjang * lebar }; mengisi luas dengan 12, bukan dengan unit, karena baris terakhir blok tidak diakhiri titik koma. Menambah 1 titik koma di baris yang salah mengubah tipe blok, dan itu sumber kesalahan E0308 yang paling sering muncul saat pemula mulai memecah fungsi menjadi blok.
Setelah bab ini selesai, kamu dapat memakai blok sebagai nilai, membaca pengaruh titik koma terhadap tipe hasil blok, menjelaskan urutan eksekusi di dalam blok, memakai return dari dalam blok, dan mengenali 2 kesalahan titik koma yang dilaporkan kompilator. Semua contoh dijalankan dengan rustc 1.100.0 pada folder /tmp/latihan-rust/bab30.
Blok menghasilkan nilai
Contoh pertama menaruh 2 binding di dalam blok, lalu memakai hasil darabnya sebagai nilai luas.
fn main() {
let luas = {
let panjang = 4;
let lebar = 3;
panjang * lebar
};
println!("{}", luas);
}
12
Baris panjang * lebar tidak diakhiri titik koma, sehingga baris itu menjadi ekspresi terakhir blok dan nilainya diteruskan keluar. Variabel panjang dan lebar hanya hidup selama blok berjalan, tetapi luas tetap memegang angka 12 setelah blok selesai, karena yang keluar dari blok adalah nilai, bukan nama variabelnya.
Bentuk ini dipakai saat 1 perhitungan butuh beberapa langkah antara yang tidak layak menjadi fungsi terpisah. Blok memberi tempat untuk binding sementara tanpa menambah nama ke fungsi induk.
Titik koma terakhir menentukan hasil
Versi berikut hanya menambah 1 titik koma di baris panjang * 3, dan hasil blok berubah dari angka menjadi unit ().
fn main() {
let hasil = {
let panjang = 4;
panjang * 3;
};
println!("{:?}", hasil);
}
warning: unused arithmetic operation that must be used
--> titik_koma.rs:4:9
|
4 | panjang * 3;
| ^^^^^^^^^^^ the arithmetic operation produces a value
|
= note: `#[warn(unused_must_use)]` (part of `#[warn(unused)]`) on by default
help: use `let _ = ...` to ignore the resulting value
|
4 | let _ = panjang * 3;
| +++++++
warning: 1 warning emitted
()
Kompilator tidak menolak program ini, karena hasil darab yang dibuang memang sah. Yang dilaporkan hanya peringatan unused_must_use dengan keterangan "the arithmetic operation produces a value". Baris yang berakhir titik koma menjadi expression statement, dan Reference menyebut expression statement sebagai ekspresi yang "evaluates an expression and ignores its result". Karena hasilnya dibuang, tipe blok menjadi (), dan println!("{:?}", hasil) mencetak ().
Pembedaan ini yang perlu dipegang: titik koma pada baris terakhir blok bukan pilihan gaya penulisan, melainkan penentu tipe. Selama blok dipakai sebagai nilai, baris terakhirnya tidak boleh diakhiri titik koma.
Urutan eksekusi di dalam blok
Blok berjalan dari baris pertama ke baris terakhir. Contoh berikut mencetak penanda di 3 titik untuk membuktikan urutannya.
fn main() {
println!("sebelum blok");
let hasil = {
println!("di dalam blok");
let sementara = 40;
sementara + 2
};
println!("setelah blok, hasil {}", hasil);
}
sebelum blok
di dalam blok
setelah blok, hasil 42
Reference menulis blok "sequentially executes its component non-item declaration statements and then its final optional expression", dan keluaran di atas memperlihatkan 3 hal: baris sebelum blok berjalan lebih dulu, println! di dalam blok berjalan saat blok dievaluasi, dan nilai 42 baru dipakai setelah blok selesai.
Perhatikan juga bahwa println! di dalam blok tidak memengaruhi nilai blok. Ia expression statement bertipe (), sedangkan nilai blok datang dari sementara + 2 di baris terakhir.
Blok di tengah ekspresi lain
Blok bisa muncul di setiap posisi yang menerima ekspresi. Contoh berikut menjumlahkan 2 blok, lalu mengurangkan variabel biasa dari blok lain.
fn main() {
let total = { 10 } + { 5 };
println!("{}", total);
let diskon = 2;
let bayar = { total } - diskon;
println!("{}", bayar);
}
15
13
Bentuk { 10 } + { 5 } sah karena kedua blok bertipe i32, dan hasilnya 15. Baris let bayar = { total } - diskon; menunjukkan hal yang sama pada posisi berbeda: blok boleh memuat 1 ekspresi saja, dan nilai total keluar dari blok tanpa berubah.
Posisi argumen fungsi juga menerima blok. Di situ blok berguna untuk menghitung nilai sebelum fungsi dipanggil.
fn kuadrat(n: i32) -> i32 {
n * n
}
fn main() {
let hasil = kuadrat({
let sisi = 5;
sisi + 1
});
println!("{}", hasil);
println!("{}", kuadrat({ 3 }));
}
warning: unnecessary braces around function argument
--> blok_argumen.rs:12:28
|
12 | println!("{}", kuadrat({ 3 }));
| ^^ ^^
|
= note: `#[warn(unused_braces)]` (part of `#[warn(unused)]`) on by default
help: remove these braces
|
12 - println!("{}", kuadrat({ 3 }));
12 + println!("{}", kuadrat(3));
|
warning: 1 warning emitted
36
9
Kompilator menerima kedua panggilan, tetapi memberi peringatan unused_braces untuk kuadrat({ 3 }) karena kurung kurawal yang hanya membungkus 1 literal tidak menambah apa pun. Peringatan itu tidak muncul untuk argumen pertama yang memuat 2 statement di dalam blok. Aturan praktisnya: pakai blok saat ada binding sementara di dalamnya, dan hapus kurung kurawal saat isinya hanya 1 ekspresi.
Scope lokal di dalam blok
Nama yang dideklarasikan di dalam blok berhenti terlihat setelah blok ditutup. Contoh berikut memakai 1 variabel dari luar blok dan 1 variabel di dalam blok.
fn main() {
let luar = 100;
{
let dalam = 7;
println!("{}", luar + dalam);
}
println!("{}", luar);
}
107
100
Variabel dalam hanya bisa dipakai di dalam blok, sedangkan luar tetap terlihat di dalam blok karena deklarasinya berada di scope induk. Setelah blok selesai, baris println!("{}", luar) mencetak 100, bukan 107, karena dalam sudah tidak ada dan luar tidak pernah berubah.
Reference menjelaskan batas ini dengan kalimat "variables declared by let statements are in scope from the next statement until the end of the block". Kalimat itu memuat 2 hal: nama baru terlihat mulai statement berikutnya, bukan pada baris let itu sendiri, dan cakupannya berakhir di kurung kurawal penutup.
Blok menentukan batas lewat if
Blok sering dipakai untuk memilih 1 nilai dari beberapa cabang. Fungsi berikut memakai blok berisi if untuk menentukan batas kelulusan, lalu membandingkan nilai dengan batas itu.
fn cek(nilai: i32) -> &'static str {
let batas = {
if nilai > 70 {
70
} else {
60
}
};
if nilai >= batas {
"lulus"
} else {
"belum"
}
}
fn main() {
println!("{}", cek(75));
println!("{}", cek(55));
}
lulus
belum
Blok mengembalikan 70 untuk nilai di atas 70 dan 60 untuk nilai lainnya, sehingga cek(75) mencetak lulus dan cek(55) mencetak belum. Kedua cabang if sama-sama bertipe i32, dan itu syarat agar blok punya 1 tipe yang pasti. Kalau 1 cabang mengembalikan angka dan cabang lain mengembalikan teks, kompilator menolak blok itu dengan E0308, sama seperti if di luar blok.
Blok kosong dan tipe unit
Blok kosong tetap punya tipe. Contoh berikut menanyakan nama tipe 3 nilai yang berbeda dengan std::any::type_name_of_val.
fn main() {
let kosong = {};
println!("{:?}", kosong);
let nama = { "budi" };
println!("{} {}", nama, std::any::type_name_of_val(&kosong));
let nilai = { 2 + 3 };
println!("{} {}", nilai, std::any::type_name_of_val(&nilai));
}
()
budi ()
5 i32
Keluaran itu memperlihatkan 3 hal: blok kosong {} bertipe (), blok berisi literal string bertipe &str dengan nilai budi, dan blok berisi 2 + 3 bertipe i32. type_name_of_val berguna saat belajar karena menampilkan tipe yang dipilih kompilator, termasuk tipe yang tidak pernah ditulis di kode.
Dokumentasi fungsi itu menyatakan "intended for diagnostic use and the exact output is not guaranteed", dan menambahkan bahwa keluarannya bisa berubah antar versi kompilator. Karena itu namanya dipakai untuk membaca tipe saat belajar, bukan untuk logika program.
return dari dalam blok
return di dalam blok menghentikan seluruh fungsi, bukan berhenti di batas blok. Contoh berikut memakai return di dalam blok untuk kasus suhu di bawah nol.
fn kategori(suhu: i32) -> &'static str {
{
if suhu < 0 {
return "beku";
}
}
if suhu > 35 {
"panas"
} else {
"sedang"
}
}
fn main() {
println!("{}", kategori(-5));
println!("{}", kategori(40));
println!("{}", kategori(25));
}
beku
panas
sedang
Pada kategori(-5), if di dalam blok langsung mengembalikan "beku", sehingga baris setelah blok tidak pernah dievaluasi. Untuk suhu 40 dan 25, blok selesai tanpa return, dan fungsi memakai if terakhir sebagai nilai hasil. Perbedaan ini penting: return keluar dari fungsi, sedangkan nilai blok hanya berlaku kalau eksekusi sampai ke kurung kurawal penutup.
2 kesalahan titik koma
Kesalahan pertama muncul saat blok diberi anotasi i32 tetapi baris terakhirnya diakhiri titik koma, sehingga blok bertipe (). Kode ini sengaja salah.
fn main() {
let angka: i32 = {
let a = 2;
a * 3;
};
println!("{}", angka);
}
error[E0308]: mismatched types
--> salah_titik_koma.rs:2:22
|
2 | let angka: i32 = {
| ______________________^
3 | | let a = 2;
4 | | a * 3;
| | - help: remove this semicolon to return this value
5 | | };
| |_____^ expected `i32`, found `()`
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0308`.
Pesan expected i32, found () menunjuk inti masalahnya, dan kompilator menambahkan saran tepat di baris yang harus diubah, yaitu "remove this semicolon to return this value". Perbaikannya 1 karakter: hapus titik koma pada baris a * 3. Tanpa anotasi tipe, kesalahan yang sama muncul lebih jauh dari sumbernya, misalnya saat angka dipakai dalam penjumlahan dengan bilangan lain.
Kesalahan kedua adalah kebalikannya: titik koma hilang di antara 2 statement.
fn main() {
let hasil = {
let a = 2
let b = 3;
a * b
};
println!("{}", hasil);
}
error: expected `;`, found keyword `let`
--> salah_tanpa_titik_koma.rs:3:18
|
3 | let a = 2
| ^ help: add `;` here
4 | let b = 3;
| --- unexpected token
error: aborting due to 1 previous error
Kompilator melaporkan baris let a = 2 sebagai tempat kesalahan, lalu menyebut let di baris berikutnya sebagai token yang tidak diharapkan. Saran help: add ; here menunjuk posisi tepat yang perlu ditambal. Setelah titik koma ditambahkan, blok kembali bertipe i32 karena baris terakhirnya a * b tanpa titik koma.
Latihan
- Ubah
blok_dasar.rssupaya blok mengembalikanf64dengan membagipanjangdenganlebarmemakaipanjang as f64 / lebar as f64, lalu cetak hasilnya. - Tambahkan titik koma pada baris terakhir
blok_dasar.rs, lalu jelaskan kenapaprintln!("{}", luas)gagal dikompilasi sementaraprintln!("{:?}", luas)berhasil. - Buat fungsi
harga_akhir(harga: i32, member: bool) -> i32yang memakai blok berisiifuntuk memilih diskon 10 persen untuk member dan 0 persen untuk non-member. - Pindahkan isi
cekpada bagian sebelumnya ke blok bersarang 2 tingkat, lalu pastikanbatasmasih terbaca dari tingkat terdalam.
Ringkasan
Blok di Rust adalah ekspresi, sehingga nilainya bisa dipakai langsung sebagai isi variabel, operand, atau argumen fungsi. Nilai itu datang dari ekspresi terakhir tanpa titik koma, dan menambahkan titik koma mengubah tipe blok menjadi (). Isi blok dieksekusi berurutan, sedangkan nama yang dideklarasikan di dalamnya hanya terlihat sampai kurung kurawal penutup, kecuali return yang langsung keluar dari fungsi. 2 kesalahan yang paling sering muncul adalah E0308 karena titik koma pada baris terakhir dan expected ;, found keyword let karena titik koma yang hilang di antara statement.
Referensi
- The Rust Reference. Block expressions.
- The Rust Reference. Statements.
- Rust By Example. Expressions.
- Rust Standard Library. type_name_of_val.