Module System

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.

RSRUST
fn main() {
    let luas = {
        let panjang = 4;
        let lebar = 3;
        panjang * lebar
    };

    println!("{}", luas);
}
CodeTEXT
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 ().

RSRUST
fn main() {
    let hasil = {
        let panjang = 4;
        panjang * 3;
    };

    println!("{:?}", hasil);
}
CodeTEXT
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.

RSRUST
fn main() {
    println!("sebelum blok");

    let hasil = {
        println!("di dalam blok");
        let sementara = 40;
        sementara + 2
    };

    println!("setelah blok, hasil {}", hasil);
}
CodeTEXT
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.

RSRUST
fn main() {
    let total = { 10 } + { 5 };
    println!("{}", total);

    let diskon = 2;
    let bayar = { total } - diskon;
    println!("{}", bayar);
}
CodeTEXT
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.

RSRUST
fn kuadrat(n: i32) -> i32 {
    n * n
}

fn main() {
    let hasil = kuadrat({
        let sisi = 5;
        sisi + 1
    });

    println!("{}", hasil);
    println!("{}", kuadrat({ 3 }));
}
CodeTEXT
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.

RSRUST
fn main() {
    let luar = 100;

    {
        let dalam = 7;
        println!("{}", luar + dalam);
    }

    println!("{}", luar);
}
CodeTEXT
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.

RSRUST
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));
}
CodeTEXT
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.

RSRUST
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));
}
CodeTEXT
()
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.

RSRUST
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));
}
CodeTEXT
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.

RSRUST
fn main() {
    let angka: i32 = {
        let a = 2;
        a * 3;
    };

    println!("{}", angka);
}
CodeTEXT
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.

RSRUST
fn main() {
    let hasil = {
        let a = 2
        let b = 3;
        a * b
    };

    println!("{}", hasil);
}
CodeTEXT
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

  1. Ubah blok_dasar.rs supaya blok mengembalikan f64 dengan membagi panjang dengan lebar memakai panjang as f64 / lebar as f64, lalu cetak hasilnya.
  2. Tambahkan titik koma pada baris terakhir blok_dasar.rs, lalu jelaskan kenapa println!("{}", luas) gagal dikompilasi sementara println!("{:?}", luas) berhasil.
  3. Buat fungsi harga_akhir(harga: i32, member: bool) -> i32 yang memakai blok berisi if untuk memilih diskon 10 persen untuk member dan 0 persen untuk non-member.
  4. Pindahkan isi cek pada bagian sebelumnya ke blok bersarang 2 tingkat, lalu pastikan batas masih 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

  1. The Rust Reference. Block expressions.
  2. The Rust Reference. Statements.
  3. Rust By Example. Expressions.
  4. Rust Standard Library. type_name_of_val.