BAB 22: Module System: Scope & Akses Item
Scope menentukan di mana sebuah nama hidup, dan akses menentukan path apa yang harus ditulis untuk memakainya dari module lain.
Nama diskon yang ditulis di dalam blok hilang begitu blok ditutup, sedangkan fungsi yang ditulis di baris terakhir berkas sudah bisa dipanggil dari baris pertama. 2 kenyataan itu berasal dari aturan scope yang berbeda, dan keduanya dijalankan oleh kompilator yang sama.
Scope adalah wilayah tempat sebuah nama bisa dipakai. Setiap blok kurung kurawal, setiap fungsi, dan setiap module membuka scope sendiri, dan nama hanya hidup selama scope itu terbuka. Akses adalah hal kedua: walaupun nama masih hidup, kode di module lain belum tentu boleh menyebutnya, dan untuk itu dibutuhkan path serta pub.
Bab ini membahas 3 jenis scope di Rust, yaitu blok, module, dan crate, lalu menunjukkan 4 error yang muncul saat batas scope dilanggar. Setelah bab ini selesai, kamu dapat memprediksi apakah sebuah nama terlihat di baris tertentu, memilih antara super:: dan crate::, serta membaca E0425, E0618, dan E0433 sebagai kesalahan scope. Semua contoh dijalankan dengan rustc 1.100.0 pada package kasir di /tmp/latihan-rust/bab22.
Scope blok: nama lahir dan mati di blok
Blok kurung kurawal membuka scope baru. Variabel yang ditulis di dalamnya hanya hidup sampai kurung tutup, dan let di dalam blok boleh memakai nama yang sama dengan variabel luar.
fn main() {
let total = 100;
{
let total = total + 50;
println!("dalam blok: {}", total);
}
println!("luar blok: {}", total);
}
dalam blok: 150
luar blok: 100
Baris let total = total + 50 membuat binding baru, bukan menimpa binding luar. Binding dalam memakai nilai total luar sebagai bahan, lalu menutupinya sampai blok selesai. Begitu blok tutup, nama total kembali menunjuk nilai 100, dan itulah yang dicetak baris terakhir.
Sifat ini berguna untuk perhitungan sementara. Kamu bisa memakai nama pendek di dalam blok tanpa mengubah nilai yang dipakai di luar blok, dan pembaca tidak perlu mencari nama lain hanya karena ada perhitungan antara.
Nama di blok tidak bisa dipakai di luar: E0425
Kesalahan pertama muncul saat variabel dalam blok dipakai setelah blok tutup. Program berikut menghapus deklarasi diskon di scope luar.
fn main() {
{
let diskon = 500;
println!("diskon: {}", diskon);
}
println!("diskon: {}", diskon);
}
error[E0425]: cannot find value `diskon` in this scope
--> uji1.rs:7:28
|
7 | println!("diskon: {}", diskon);
| ^^^^^^
|
help: the binding `diskon` is available in a different scope in the same function
--> uji1.rs:3:13
|
3 | let diskon = 500;
| ^^^^^^
error: aborting due to 1 previous error
Pesan bantuan kompilator menyebut "in a different scope in the same function", dan itu menjelaskan semuanya: variabelnya ada, hanya tidak di scope itu. Scope bersifat tekstual, bukan berdasarkan urutan eksekusi. Blok di atas memang berjalan lebih dulu, tetapi namanya tetap tidak terlihat di baris 7 karena baris itu berada di luar kurung kurawal.
Kompilator Rust juga tidak menebak maksudmu dan tidak menaikkan variabel ke scope luar secara otomatis seperti beberapa bahasa lain. Perbaikannya memindahkan let diskon ke scope yang memang membutuhkannya, atau mengembalikan nilainya dari blok lewat ekspresi.
Item berlaku untuk seluruh module
Aturan berbeda berlaku untuk item seperti fungsi, konstanta, dan struct. Item yang dideklarasikan langsung di dalam module bisa dipakai dari baris mana pun di module itu, termasuk baris yang muncul sebelum deklarasinya.
fn main() {
println!("total: {}", total(10000));
}
const PAJAK: u32 = 11;
fn total(harga: u32) -> u32 {
harga + harga * PAJAK / 100
}
total: 11100
Program itu memanggil total sebelum fungsinya ditulis, dan kompilator menerimanya tanpa peringatan. Reference Rust menyebut cakupan nama item yang dideklarasikan langsung di dalam module berlangsung dari awal module sampai akhir module, jadi urutan baris tidak menentukan.
Aturan ini berbeda dari variabel lokal, yang cakupannya baru mulai setelah baris let dijalankan. Perbedaan itu masuk akal saat dipikirkan sebagai 2 fase: item didaftarkan lebih dulu saat kompilasi, sedangkan variabel baru ada saat eksekusi. Karena itu, memindahkan fungsi ke atas atau ke bawah berkas tidak pernah mengubah perilaku program.
Nama lokal menutupi nama item: E0618
Karena fungsi dan variabel sama-sama hidup di namespace nilai, sebuah variabel lokal bisa menutupi nama fungsi. Kesalahan kedua muncul saat nama fungsi dipakai setelah ditutupi variabel dengan nama yang sama.
fn total(harga: u32) -> u32 {
harga + 1
}
fn main() {
let total = 3;
println!("{}", total(10000));
}
error[E0618]: expected function, found `{integer}`
--> uji2.rs:7:20
|
1 | fn total(harga: u32) -> u32 {
| --------------------------- this function of the same name is available here, but it's shadowed by the local binding
...
6 | let total = 3;
| ----- `total` has type `{integer}`
7 | println!("{}", total(10000));
| ^^^^^-------
| |
| call expression requires function
error: aborting due to 1 previous error
Kompilator tidak menganggap total sebagai fungsi di baris 7, karena nama itu sudah dipakai variabel bertipe integer. Pesan "shadowed by the local binding" adalah istilah untuk kondisi ini: binding lokal menutupi item lain dengan nama sama. Perbaikannya memberi nama variabel yang berbeda, misalnya jumlah, atau memanggil fungsi lewat path yang tidak tertutupi.
Module anak tidak mewarisi nama induk: E0425
Module anak boleh memakai item induk, tetapi tidak otomatis. Nama induk tidak masuk ke scope anak, sehingga pemakaian langsung menghasilkan error yang sama seperti variabel di luar blok.
const PAJAK: u32 = 11;
mod kasir {
pub fn total(harga: u32) -> u32 {
harga + harga * PAJAK / 100
}
}
fn main() {
println!("{}", kasir::total(10000));
}
error[E0425]: cannot find value `PAJAK` in this scope
--> uji5.rs:5:25
|
5 | harga + harga * PAJAK / 100
| ^^^^^ not found in this scope
|
help: consider importing this constant
|
4 + use PAJAK;
|
error: aborting due to 1 previous error
Kompilator menawarkan use PAJAK; di dalam module, dan saran itu bekerja karena use dengan 1 nama dicari mulai dari crate root, tempat PAJAK berada. Cara lain yang lebih eksplisit adalah menulis crate::PAJAK langsung di dalam ekspresi, atau super::PAJAK kalau konstanta itu berada di module induk langsung.
Yang perlu diingat, arah aksesnya 1 arah: anak bisa melihat induk, sedangkan induk tidak bisa melihat isi anak tanpa pub. Aturan ini menjaga detail implementasi anak tetap tersembunyi, dan pengecualiannya hanya dibuka lewat penanda akses.
use hanya berlaku di module tempat ia ditulis
use tidak mengubah isi module, ia hanya menambahkan nama ke scope tempat baris itu ditulis. Kalau use diletakkan di dalam blok, namanya hanya hidup selama blok itu.
mod kasir {
pub const PAJAK: u32 = 11;
pub fn total(harga: u32) -> u32 {
harga + harga * PAJAK / 100
}
}
fn main() {
{
use kasir::total;
println!("dalam blok: {}", total(10000));
}
println!("luar blok: {}", total(10000));
}
error[E0425]: cannot find function `total` in this scope
--> uji6.rs:15:31
|
15 | println!("luar blok: {}", total(10000));
| ^^^^^ not found in this scope
|
help: consider importing this function
|
1 + use kasir::total;
|
error: aborting due to 1 previous error
Pemanggilan di dalam blok berhasil, sedangkan pemanggilan setelah blok gagal. Itu bukti bahwa use mengikuti aturan scope yang sama seperti variabel: ia hidup di blok tempat ia ditulis. Kalau use kasir::total; dipindah ke awal main, kedua pemanggilan berhasil.
Sifat ini dipakai untuk membatasi nama pendek pada bagian berkas yang memang memakainya. Di berkas besar, use di dalam fungsi lebih mudah ditelusuri daripada use di puncak berkas yang berlaku untuk seluruh isi.
crate dan super untuk menyeberang scope
Ada 2 kata kunci untuk menyeberang batas module tanpa mengimpor nama, yaitu super untuk naik 1 tingkat dan crate untuk mulai dari akar crate. Program berikut memakai keduanya dari module anak.
mod kasir {
pub const PAJAK: u32 = 11;
pub fn total(harga: u32) -> u32 {
harga + pajak_dari(harga)
}
fn pajak_dari(harga: u32) -> u32 {
harga * PAJAK / 100
}
pub mod laporan {
pub fn baris() {
println!("pajak: {} persen", super::PAJAK);
println!("total: {}", crate::kasir::total(10000));
}
}
}
fn main() {
kasir::laporan::baris();
}
pajak: 11 persen
total: 11100
Fungsi pajak_dari tetap privat, tetapi masih bisa dipanggil oleh total karena keduanya berada di module kasir. Module laporan memakai super::PAJAK untuk membaca konstanta induk, lalu crate::kasir::total untuk memanggil fungsi publik dari akar crate. Keduanya path langsung, jadi tidak ada nama baru yang masuk ke scope laporan.
Pilihan antara keduanya bergantung pada posisi: super:: lebih pendek dan tetap benar kalau module induk dipindah bersama anaknya, sedangkan crate:: tetap benar walaupun kedalaman module berubah. Untuk module yang dalam, crate:: biasanya lebih mudah dibaca karena pembaca tidak perlu menghitung berapa tingkat ia harus naik.
E0433 saat module belum ada di crate
Kesalahan keempat berbeda sifat: yang tidak ditemukan bukan item di dalam module, melainkan module atau crate-nya sendiri. Program berikut memakai kasir tanpa mendeklarasikan module itu.
fn main() {
println!("total: {}", kasir::total(10000));
}
error[E0433]: cannot find module or crate `kasir` in this scope
--> uji7.rs:2:27
|
2 | println!("total: {}", kasir::total(10000));
| ^^^^^ use of unresolved module or unlinked crate `kasir`
|
= help: you might be missing a crate named `kasir`
error: aborting due to 1 previous error
Perbedaan E0433 dan E0425 berguna saat membaca error: E0433 berarti segmen pertama path tidak dikenal, sedangkan E0425 berarti nama terakhir tidak ditemukan di scope. Pada kasus di atas, crate kasir memang tidak punya module bernama kasir, dan kompilator menebak mungkin ada crate eksternal yang belum ditambahkan ke Cargo.toml.
Penyebab yang paling sering adalah lupa menulis mod kasir; atau mod kasir { }, atau salah menulis nama module. Perbaikannya menambahkan deklarasi module, bukan mengubah Cargo.toml, kecuali memang module itu berasal dari crate lain.
Latihan
- Tulis blok di dalam
mainyang mendeklarasikanlet harga = 2500;, cetak nilainya di dalam blok, lalu cetak lagi setelah blok dengan menambahkanlet hargadi scope luar. Jelaskan mengapa versi pertama gagal. - Pindahkan fungsi
totalke bawahmaindan pastikan program tetap mencetak hasil yang sama. Catat bahwa tidak ada peringatan dari kompilator. - Buat module
kasirberisi konstanta privatPAJAKdan fungsipub fn total. Panggil konstanta itu dari module anak memakaisuper::PAJAK, lalu ganti dengancrate::PAJAKdan pastikan keluarannya sama. - Tulis
use kasir::total;di dalam blok, lalu panggiltotalsetelah blok. Kutip kode error yang muncul dan sebutkan 1 cara memperbaikinya.
Ringkasan
Scope di Rust punya 3 tingkat yang harus dibedakan: blok untuk variabel lokal, module untuk item, dan crate untuk seluruh program. Variabel hidup dari baris let sampai akhir blok, sedangkan item hidup di seluruh module tanpa peduli urutan baris, dan use hanya menambah nama pada scope tempat ia ditulis. Batas itu ditegakkan lewat E0425 untuk nama yang tidak ada di scope, E0618 untuk nama yang tertutupi binding lokal, dan E0433 untuk module yang belum dideklarasikan.
Referensi
- The Rust Reference. Scopes.
- The Rust Programming Language. Paths for Referring to an Item in the Module Tree.
- The Rust Programming Language. Bringing Paths Into Scope with the use Keyword.
- The Rust Reference. Paths.