Module System

BAB 31: Shadowing

Shadowing membuat binding baru dengan nama yang sama, bisa berganti tipe, dan berbeda dari mut karena nilai lama tidak bisa diubah.

Kode berikut mencetak 10, 15, dan 30 dari 1 nama variabel yang sama. Baris let nilai = 10; diikuti let nilai = nilai + 5; tidak menghasilkan kesalahan, karena let kedua membuat binding baru yang membayangi binding pertama, bukan mengubah nilai yang lama. Buku resmi Rust menyebutnya dengan kalimat "the first variable is shadowed by the second, which means that the second variable is what the compiler will see when you use the name of the variable".

Shadowing sering disalahpahami sebagai pengganti mut, padahal keduanya menyelesaikan masalah yang berbeda. mut memberi izin menulis ulang 1 nilai, sedangkan shadowing meninggalkan nilai lama dan membuat nama baru yang menunjuk ke nilai lain, bahkan dengan tipe yang berbeda.

Setelah bab ini selesai, kamu dapat memakai shadowing untuk mengubah tipe di tengah pengolahan data, membedakan shadowing dari mut, membaca peringatan unused_variables yang muncul karena shadowing, dan mengenali E0308 serta E0384 yang sering muncul saat keduanya tertukar. Semua contoh dijalankan dengan rustc 1.100.0 pada folder /tmp/latihan-rust/bab31.

let kedua membayangi let pertama

Contoh pertama memakai 1 nama untuk 3 tahap perhitungan. Setiap tahap memakai nilai dari tahap sebelumnya.

RSRUST
fn main() {
    let nilai = 10;
    println!("{}", nilai);

    let nilai = nilai + 5;
    println!("{}", nilai);

    let nilai = nilai * 2;
    println!("{}", nilai);
}
CodeTEXT
10
15
30

Baris let nilai = nilai + 5; membaca nilai lama (10) di sisi kanan, lalu membuat binding baru bernama nilai yang berisi 15. Binding lama masih ada di memori sampai blok selesai, tetapi namanya sudah tidak bisa dipakai lagi. Karena itu baris ketiga membaca 15, bukan 10.

Kompilator memperlakukan setiap let sebagai deklarasi terpisah. Tidak ada perubahan pada nilai yang sudah ada, dan tidak ada izin tulis yang diberikan ke variabel lama.

Shadowing dan mut mengubah hal berbeda

mut membuat 1 binding boleh ditulis ulang. Shadowing membuat binding baru. Contoh berikut memakai keduanya pada nama yang sama untuk memperlihatkan bedanya.

RSRUST
fn main() {
    let mut hitungan = 1;
    hitungan = hitungan + 1;
    println!("{}", hitungan);

    let hitungan = hitungan + 1;
    println!("{}", hitungan);
}
CodeTEXT
2
3

Baris hitungan = hitungan + 1; adalah penugasan ke binding yang sama, dan itu hanya sah karena hitungan dideklarasikan dengan mut. Baris let hitungan = hitungan + 1; adalah deklarasi binding baru, sehingga mut tidak lagi diperlukan setelah baris itu. Kalau baris pertama diganti menjadi let hitungan = 1; tanpa mut, kompilator menolak penugasan di baris kedua dengan E0384.

Buku resmi Rust menjelaskan bedanya dari sisi kesalahan yang dicegah: "we'll get a compile-time error if we accidentally try to reassign to this variable without using the let keyword". Dengan mut, penulisan ulang yang tidak disengaja lolos kompilasi. Dengan shadowing, penulisan ulang harus ditulis sebagai let baru, sehingga perubahan nilainya terlihat saat membaca kode.

Mengganti tipe dengan nama yang sama

Keuntungan kedua dari shadowing adalah tipe boleh berubah. Variabel data di bawah ini berubah dari &str menjadi &str yang sudah dipangkas, lalu menjadi usize.

RSRUST
fn main() {
    let data = "   teks   ";
    println!("[{}]", data);

    let data = data.trim();
    println!("[{}] panjang {}", data, data.len());

    let data = data.len();
    println!("{}", data);
}
CodeTEXT
[   teks   ]
[teks] panjang 4
4

Binding pertama bertipe &str berisi 10 karakter dengan spasi di kedua sisi. trim() mengembalikan &str baru tanpa spasi, dan binding kedua memakai nama yang sama sehingga tahap berikutnya tidak perlu memikirkan spasi lagi. Binding ketiga menyimpan usize hasil len(). Buku resmi Rust menyebut kemampuan ini dengan kalimat "we can change the type of the value but reuse the same name".

Dengan mut, perubahan tipe seperti ini tidak bisa dilakukan. 1 binding hanya punya 1 tipe, dan let mut data = " teks "; lalu data = data.len(); ditolak kompilator karena usize bukan &str.

Rantai pengolahan masukan

Pola yang paling sering dipakai di kode nyata adalah rantai shadowing untuk membersihkan masukan sebelum dipakai. Setiap langkah memakai nama yang sama supaya tahap sesudahnya tidak perlu memilih nama baru.

RSRUST
fn main() {
    let masukan = "  42 ";
    let masukan = masukan.trim();
    let masukan: i32 = masukan.parse().expect("bukan angka");
    let masukan = masukan * 2;

    println!("{}", masukan);
}
CodeTEXT
84

Baris pertama menyimpan teks mentah, baris kedua memangkas spasi, baris ketiga mengubah teks menjadi i32 dengan anotasi tipe, dan baris keempat menggandakan angkanya. Anotasi : i32 pada baris ketiga diperlukan karena parse bisa menghasilkan banyak tipe, dan tanpa anotasi kompilator tidak tahu tipe mana yang dipilih.

Rantai seperti ini lebih mudah dibaca daripada masukan_mentah, masukan_bersih, masukan_angka, dan masukan_akhir. Setiap nama tambahan menuntut pembaca mengingat bedanya, sementara isi setiap tahap sudah dijelaskan oleh baris let itu sendiri.

Cakupan shadowing berhenti di blok

Shadowing di blok dalam tidak mengubah binding di blok luar. Contoh berikut memakai nama nama di 2 tingkat.

RSRUST
fn main() {
    let nama = "luar";
    println!("{}", nama);

    {
        let nama = "dalam";
        println!("{}", nama);
    }

    println!("{}", nama);
}
CodeTEXT
luar
dalam
luar

Binding di dalam blok hanya berlaku di blok itu. Setelah kurung kurawal penutup, nama nama kembali menunjuk binding pertama yang berisi luar. Buku resmi Rust menulis batas ini sebagai "until either it itself is shadowed or the scope ends".

Perilaku ini berbeda dari mut pada variabel luar. Kalau blok dalam menulis nama = "dalam" pada binding mut di luar, nilai setelah blok ikut berubah. Shadowing tidak bisa mengubah binding luar, dan itu yang membuatnya aman dipakai untuk perhitungan sementara.

Membekukan nilai setelah mut

Pola lain yang lazim adalah memakai mut selama perhitungan, lalu menutupnya dengan let tanpa mut. Setelah baris itu, nilai tidak bisa diubah lagi.

RSRUST
fn main() {
    let mut total = 0;
    for n in 1..=4 {
        total += n;
    }

    let total = total * 100;
    println!("{}", total);
}
CodeTEXT
1000

total harus mut selama loop karena nilainya bertambah di setiap putaran. Setelah loop selesai, baris let total = total * 100; membuat binding baru tanpa mut, sehingga kode sesudahnya tidak bisa menambah atau mengurangi nilainya. Buku resmi Rust menyebut manfaat ini dengan kalimat "we can perform a few transformations on a value but have the variable be immutable after those transformations have completed".

Pola ini berguna pada fungsi panjang: bagian perhitungan boleh memakai mut, dan bagian pemakaian mendapat jaminan bahwa nilai tidak berubah lagi.

Nilai lama yang tidak terbaca

Kompilator bisa menunjukkan binding yang tertimpa tanpa pernah dibaca. Contoh berikut mendeklarasikan nilai 2 kali dan hanya memakai yang kedua.

RSRUST
fn main() {
    let nilai = 10;
    let nilai = 20;

    println!("{}", nilai);
}
CodeTEXT
warning: unused variable: `nilai`
 --> nilai_tak_terbaca.rs:2:9
  |
2 |     let nilai = 10;
  |         ^^^^^ help: if this is intentional, prefix it with an underscore: `_nilai`
  |
  = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default

warning: 1 warning emitted


20

Peringatan menunjuk baris pertama, bukan baris kedua, karena binding pertama itulah yang tidak pernah dipakai. Program tetap berjalan dan mencetak 20. Peringatan unused_variables di sini berguna sebagai penanda bahwa 1 baris let bisa dihapus tanpa mengubah perilaku program.

Perhatikan juga bahwa shadowing tidak menghapus nilai lama dari memori seketika. Binding lama tetap hidup sampai blok selesai, dan pada tipe yang memiliki destruktor, pembebasannya terjadi saat blok berakhir.

2 kesalahan setelah shadowing

Kesalahan pertama muncul saat nama yang sudah dibayangi dipakai dengan tipe lamanya. Kode ini sengaja salah.

RSRUST
fn main() {
    let nilai = 10;
    let nilai = format!("{}", nilai);

    println!("{}", nilai + 1);
}
CodeTEXT
error[E0308]: mismatched types
 --> salah_tipe_setelah_shadow.rs:5:28
  |
5 |     println!("{}", nilai + 1);
  |                            ^ expected `&str`, found integer

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0308`.

format! mengembalikan String, sehingga nilai yang dipakai di baris kelima bertipe String, bukan i32 lagi. Operator + pada String hanya menerima &str di sisi kanan, dan itulah yang dilaporkan kompilator: expected &str, found integer. Shadowing tidak mengubah tipe nilai lama dan tidak menambahkan konversi otomatis. Perbaikannya adalah memakai nilai.parse::<i32>() sebelum penjumlahan, atau memakai format! untuk seluruh hasil.

Kesalahan kedua muncul saat binding hasil shadowing dicoba ditimpa tanpa let.

RSRUST
fn main() {
    let nilai = 5;
    let nilai = nilai + 1;
    nilai = 0;

    println!("{}", nilai);
}
CodeTEXT
error[E0384]: cannot assign twice to immutable variable `nilai`
 --> salah_timpa_shadow.rs:4:5
  |
3 |     let nilai = nilai + 1;
  |         ----- first assignment to `nilai`
4 |     nilai = 0;
  |     ^^^^^^^^^ cannot assign twice to immutable variable
  |
help: consider making this binding mutable
  |
3 |     let mut nilai = nilai + 1;
  |         +++

warning: value assigned to `nilai` is never read
 --> salah_timpa_shadow.rs:3:17
  |
3 |     let nilai = nilai + 1;
  |                 ^^^^^^^^^ this value is reassigned later and never used
4 |     nilai = 0;
  |     --------- `nilai` is overwritten here before the previous value is read
  |
  = note: `#[warn(unused_assignments)]` (part of `#[warn(unused)]`) on by default

error: aborting due to 1 previous error; 1 warning emitted

For more information about this error, try `rustc --explain E0384`.

Kompilator menunjuk baris let nilai = nilai + 1; sebagai pemberian nilai pertama, lalu menolak nilai = 0; karena binding itu tidak mut. Saran yang muncul adalah menambahkan mut, tetapi pilihan lain yang lebih sesuai maksud kode adalah memakai let nilai = 0; kalau memang ingin nilai baru. Perhatikan juga peringatan unused_assignments yang menyebut nilai 6 tidak pernah terbaca, tanda bahwa baris penugasan itu memang salah sejak awal.

Kapan shadowing dipakai

Shadowing cocok dipakai saat 1 nilai melewati beberapa tahap dan setiap tahap mengubah bentuknya. Contoh yang sudah dibahas, yaitu trim lalu parse lalu perkalian, adalah bentuk paling umum: masukan mentah tidak dibutuhkan lagi setelah dibersihkan.

Shadowing kurang cocok dipakai saat nilai lama masih dibutuhkan bersama nilai baru. Kalau 2 nilai harus dibandingkan, beri nama yang berbeda seperti harga_asli dan harga_diskon, karena nama yang sama akan menyembunyikan nilai pertama dan memaksa pembaca menelusuri urutan baris.

Batasan lain adalah jarak. Shadowing yang dipisahkan 30 baris membuat pembaca sulit tahu binding mana yang sedang dipakai. Simpan rantai shadowing dalam 1 bagian pendek, dan hentikan rantainya saat nilai itu mulai dipakai untuk hal lain.

Latihan

  1. Ubah shadow_dasar.rs supaya nilai terakhir dicetak sebagai teks memakai format!, lalu jelaskan tipe nilai di setiap baris.
  2. Tambahkan 1 blok di dalam scope_shadow.rs yang membayangi nama 2 kali, lalu pastikan cetakan terakhir tetap luar.
  3. Ganti let mut total pada bekukan.rs menjadi let total dan catat pesan kesalahan yang muncul.
  4. Buat rantai shadowing yang mengubah " 1,5 " menjadi f64 bernilai 1.5 memakai trim, replace(',', "."), dan parse.

Ringkasan

Shadowing adalah deklarasi let baru dengan nama yang sudah dipakai, dan binding lama berhenti terlihat sampai bloknya selesai. Karena binding-nya baru, tipe boleh berubah dan nilai lama tidak bisa ditimpa tanpa let baru, berbeda dari mut yang memberi izin tulis pada 1 binding dengan 1 tipe. Shadowing di blok dalam tidak mengubah binding di blok luar, dan kompilator menandai binding lama yang tidak pernah terbaca lewat unused_variables. 2 kesalahan yang sering muncul adalah E0308 saat nama yang sudah berganti tipe dipakai dengan tipe lama, dan E0384 saat binding hasil shadowing dicoba ditimpa tanpa mut.

Referensi

  1. The Rust Programming Language. Variables and Mutability.
  2. The Rust Reference. Scopes.
  3. Rust By Example. Scope and Shadowing.