Memisahkan Module ke File yang Berbeda
Sejauh ini, semua contoh di bab ini mendefinisikan beberapa module dalam satu file. Ketika module sudah besar, kamu mungkin ingin memindahkan definisinya ke file terpisah agar kode lebih mudah dinavigasi.
Sebagai contoh, kita mulai dari kode pada Listing 7-17 yang berisi beberapa module restoran. Kita akan mengekstrak module-module itu ke dalam file, alih-alih mendefinisikan semuanya di file root crate. Dalam kasus ini, file root crate adalah src/lib.rs, tetapi prosedur ini juga berlaku untuk crate binary yang file root-nya adalah src/main.rs.
Pertama, kita ekstrak module front_of_house ke file-nya sendiri. Hapus kode di
dalam kurung kurawal untuk module front_of_house, sisakan hanya deklarasi
mod front_of_house;, sehingga src/lib.rs berisi kode seperti pada Listing
7-21. Perhatikan bahwa ini belum bisa dikompilasi sampai kita membuat file
src/front_of_house.rs seperti pada Listing 7-22.
mod front_of_house;
pub use crate::front_of_house::hosting;
pub fn eat_at_restaurant() {
hosting::add_to_waitlist();
}
front_of_house yang body-nya akan berada di src/front_of_house.rsSelanjutnya, letakkan kode yang tadi ada di dalam kurung kurawal ke file baru
bernama src/front_of_house.rs, seperti pada Listing 7-22. Compiler tahu untuk
mencari di file ini karena ia menemukan deklarasi module di root crate dengan
nama front_of_house.
pub mod hosting {
pub fn add_to_waitlist() {}
}
front_of_house di src/front_of_house.rsPerhatikan bahwa kamu hanya perlu memuat file menggunakan deklarasi mod
satu kali di pohon module-mu. Setelah compiler tahu file itu bagian dari
proyek (dan tahu di mana kode itu berada di pohon module berkat penempatan
pernyataan mod-mu), file lain di proyekmu sebaiknya merujuk ke kode file
tersebut lewat path ke tempat ia dideklarasikan, seperti yang dibahas di bagian
“Path untuk Merujuk ke Item di Pohon Module”. Dengan
kata lain, mod bukan operasi “include” seperti yang mungkin kamu lihat di
bahasa pemrograman lain.
Berikutnya, kita ekstrak module hosting ke file-nya sendiri. Prosesnya sedikit
berbeda karena hosting adalah child module dari front_of_house, bukan dari
module root. Kita akan menempatkan file untuk hosting di direktori baru yang
dinamai berdasarkan leluhurnya di pohon module, dalam kasus ini
src/front_of_house.
Untuk mulai memindahkan hosting, kita ubah src/front_of_house.rs agar
berisi hanya deklarasi module hosting:
pub mod hosting;
Lalu, kita buat direktori src/front_of_house dan file hosting.rs untuk
menampung definisi yang dibuat di module hosting:
pub fn add_to_waitlist() {}
Jika kita malah menaruh hosting.rs di direktori src, compiler akan
mengharapkan kode hosting.rs berada di module hosting yang dideklarasikan
di root crate, bukan sebagai child dari module front_of_house. Aturan compiler
tentang file mana yang harus diperiksa untuk kode module tertentu membuat
direktori dan file lebih cocok dengan pohon module.
Path File Alternatif
Sejauh ini kita sudah membahas path file paling idiomatik yang dipakai
compiler Rust, tetapi Rust juga mendukung gaya path file yang lebih lama.
Untuk module bernama front_of_house yang dideklarasikan di root crate,
compiler akan mencari kode module itu di:
- src/front_of_house.rs (yang kita bahas)
- src/front_of_house/mod.rs (gaya lama, path yang masih didukung)
Untuk module bernama hosting yang merupakan submodule dari
front_of_house, compiler akan mencari kode module itu di:
- src/front_of_house/hosting.rs (yang kita bahas)
- src/front_of_house/hosting/mod.rs (gaya lama, path yang masih didukung)
Jika kamu memakai kedua gaya untuk module yang sama, kamu akan mendapat error compiler. Memadukan kedua gaya untuk module yang berbeda dalam proyek yang sama itu boleh, tetapi bisa membingungkan bagi orang yang menelusuri proyekmu.
Kekurangan utama gaya yang memakai file bernama mod.rs adalah proyekmu bisa berakhir dengan banyak file bernama mod.rs, yang bisa membingungkan saat kamu membukanya bersamaan di editor.
Kita sudah memindahkan kode setiap module ke file terpisah, dan pohon module
tetap sama. Pemanggilan fungsi di eat_at_restaurant akan tetap berfungsi
tanpa perubahan apa pun, meskipun definisinya hidup di file yang berbeda.
Teknik ini memungkinkan kamu memindahkan module ke file baru seiring
bertambah besar ukurannya.
Perhatikan bahwa pernyataan pub use crate::front_of_house::hosting di
src/lib.rs juga tidak berubah, dan use pun tidak berdampak pada file mana
yang dikompilasi sebagai bagian dari crate. Kata kunci mod mendeklarasikan
module, dan Rust mencari kode yang masuk ke module itu di file dengan nama
sama dengan module tersebut.
Ringkasan
Rust memungkinkan kamu memecah package menjadi beberapa crate dan sebuah crate
menjadi module, sehingga kamu bisa merujuk ke item yang didefinisikan di satu
module dari module lain. Kamu bisa melakukan ini dengan menentukan path absolut
atau relatif. Path-path itu bisa dibawa ke scope dengan pernyataan use
sehingga kamu bisa memakai path yang lebih pendek saat item itu dipakai
berulang kali di scope tersebut. Kode module bersifat private secara default,
tetapi kamu bisa membuat definisinya publik dengan menambahkan kata kunci pub.
Di bab berikutnya, kita akan melihat beberapa struktur data collection di standard library yang bisa kamu pakai dalam kode yang sudah tersusun rapi.