Mengontrol Scope dan Privasi dengan Module
Di bagian ini, kita akan membahas module dan bagian lain dari module system,
yaitu path, yang memungkinkan kamu menamai item; kata kunci use yang
membawa sebuah path ke dalam scope; serta kata kunci pub untuk membuat item
menjadi publik. Kita juga akan membahas kata kunci as, package eksternal,
dan operator glob.
Cheat Sheet Module
Sebelum masuk ke detail module dan path, berikut kami sajikan referensi cepat
tentang cara module, path, kata kunci use, dan kata kunci pub bekerja di
compiler, serta cara sebagian besar developer mengorganisasi kode mereka.
Sepanjang bab ini kita akan menelusuri contoh untuk setiap aturan tersebut,
tetapi bagian ini adalah tempat yang bagus untuk dikunjungi kembali sebagai
pengingat cara kerja module.
- Mulai dari crate root: Saat mengompilasi sebuah crate, compiler pertama kali mencari kode yang akan dikompilasi di file crate root (biasanya src/lib.rs untuk library crate dan src/main.rs untuk binary crate).
- Mendeklarasikan module: Di file crate root, kamu bisa mendeklarasikan
module baru; misalnya kamu mendeklarasikan module “garden” dengan
mod garden;. Compiler akan mencari kode module itu di tempat-tempat berikut:- Inline, di dalam kurung kurawal yang menggantikan titik koma setelah
mod garden - Di file src/garden.rs
- Di file src/garden/mod.rs
- Inline, di dalam kurung kurawal yang menggantikan titik koma setelah
- Mendeklarasikan submodule: Di file mana pun selain crate root, kamu bisa
mendeklarasikan submodule. Sebagai contoh, kamu mungkin mendeklarasikan
mod vegetables;di src/garden.rs. Compiler akan mencari kode submodule itu di dalam direktori yang dinamai sesuai module induknya, tepatnya di tempat-tempat berikut:- Inline, tepat setelah
mod vegetables, di dalam kurung kurawal sebagai pengganti titik koma - Di file src/garden/vegetables.rs
- Di file src/garden/vegetables/mod.rs
- Inline, tepat setelah
- Path ke kode di dalam module: Setelah sebuah module menjadi bagian dari
crate kamu, kamu bisa merujuk ke kode di module itu dari mana pun di dalam
crate yang sama, selama aturan privasi mengizinkan, dengan memakai path ke
kode tersebut. Sebagai contoh, tipe
Asparagusdi module garden vegetables akan ditemukan dicrate::garden::vegetables::Asparagus. - Privat vs. publik: Kode di dalam sebuah module bersifat privat terhadap
module induknya secara default. Untuk membuat sebuah module publik,
deklarasikan dengan
pub modalih-alihmod. Agar item di dalam module publik juga ikut publik, gunakanpubsebelum deklarasinya. - Kata kunci
use: Di dalam sebuah scope, kata kunciusemembuat jalan pintas ke suatu item agar kamu tidak perlu mengulang path yang panjang. Di scope mana pun yang bisa merujuk kecrate::garden::vegetables::Asparagus, kamu bisa membuat jalan pintas denganuse crate::garden::vegetables::Asparagus;, dan setelahnya kamu cukup menulisAsparagusuntuk memakai tipe itu di scope tersebut.
Di sini, kita membuat binary crate bernama backyard yang mengilustrasikan
aturan-aturan ini. Direktori crate, yang juga bernama backyard, berisi file
dan direktori berikut:
backyard
├── Cargo.lock
├── Cargo.toml
└── src
├── garden
│ └── vegetables.rs
├── garden.rs
└── main.rs
Dalam kasus ini, file crate root-nya adalah src/main.rs, dan isinya:
use crate::garden::vegetables::Asparagus;
pub mod garden;
fn main() {
let plant = Asparagus {};
println!("I'm growing {plant:?}!");
}
Baris pub mod garden; memberi tahu compiler untuk menyertakan kode yang ia
temukan di src/garden.rs, yaitu:
pub mod vegetables;
Di sini, pub mod vegetables; berarti kode di src/garden/vegetables.rs juga
ikut disertakan. Kode tersebut adalah:
#[derive(Debug)]
pub struct Asparagus {}
Sekarang, mari kita masuk ke detail aturan-aturan itu dan membuktikannya secara langsung!
Mengelompokkan Kode yang Berkaitan dalam Module
Module memungkinkan kita mengorganisasi kode di dalam sebuah crate agar mudah dibaca dan mudah dipakai ulang. Module juga mengontrol privasi sebuah item karena kode di dalam module bersifat privat secara default. Item yang privat adalah detail implementasi internal yang tidak tersedia untuk dipakai dari luar. Kita bisa memilih membuat module dan isinya menjadi publik, sehingga kode eksternal bisa memakai dan bergantung padanya.
Sebagai contoh, kita tulis sebuah library crate yang menyediakan fungsionalitas sebuah restoran. Kita akan mendefinisikan signature fungsi-fungsi tersebut tetapi membiarkan body-nya kosong, supaya fokus kita pada organisasi kode, bukan pada implementasi sebuah restoran.
Di dunia restoran, sebagian bagian restoran disebut front of house dan sisanya back of house. Front of house adalah area yang didapati pelanggan; di situ penerima tamu menempatkan pelanggan, pelayan menerima pesanan dan pembayaran, dan bartender meracik minuman. Back of house adalah area tempat chef dan koki bekerja di dapur, tukang cuci piring membersihkan peralatan, dan manajer mengurus pekerjaan administratif.
Untuk menata crate kita seperti itu, kita bisa mengorganisasi fungsi-fungsi ke
dalam module bersarang. Buat library baru bernama restaurant dengan
menjalankan cargo new restaurant --lib. Lalu, masukkan kode pada Listing 7-1
ke dalam src/lib.rs untuk mendefinisikan beberapa module dan signature
fungsi; kode ini adalah bagian front of house.
mod front_of_house {
mod hosting {
fn add_to_waitlist() {}
fn seat_at_table() {}
}
mod serving {
fn take_order() {}
fn serve_order() {}
fn take_payment() {}
}
}
front_of_house yang berisi module lain yang di dalamnya terdapat fungsiKita mendefinisikan sebuah module dengan kata kunci mod diikuti nama module
(dalam kasus ini, front_of_house). Lalu body module diletakkan di dalam
kurung kurawal. Di dalam module, kita bisa menempatkan module lain, seperti
pada kasus ini dengan module hosting dan serving. Module juga bisa
menyimpan definisi item lain, seperti struct, enum, konstanta, trait, dan
seperti pada Listing 7-1, fungsi.
Dengan memakai module, kita bisa mengelompokkan definisi yang berkaitan, lalu menamai alasan definisi itu berkaitan. Programmer yang memakai kode ini bisa menelusuri kode berdasarkan kelompok tersebut alih-alih harus membaca semua definisi, sehingga lebih mudah menemukan definisi yang relevan bagi mereka. Programmer yang menambahkan fungsionalitas baru ke kode ini pun tahu di mana harus menaruh kode agar program tetap terorganisasi.
Tadi, kita menyebut src/main.rs dan src/lib.rs sebagai crate root.
Penamaan itu karena isi kedua file tersebut membentuk module bernama crate di
root struktur module crate, yang dikenal sebagai pohon module.
Listing 7-2 menunjukkan pohon module untuk struktur pada Listing 7-1.
crate
└── front_of_house
├── hosting
│ ├── add_to_waitlist
│ └── seat_at_table
└── serving
├── take_order
├── serve_order
└── take_payment
Pohon ini menunjukkan bagaimana beberapa module bersarang di dalam module
lain; misalnya, hosting bersarang di dalam front_of_house. Pohon ini juga
menunjukkan bahwa beberapa module bersifat siblings, artinya mereka
didefinisikan di module yang sama; hosting dan serving adalah siblings yang
didefinisikan di dalam front_of_house. Jika module A berada di dalam module
B, kita menyebut module A sebagai child dari module B dan module B sebagai
parent dari module A. Perhatikan bahwa seluruh pohon module berakar pada
module implisit bernama crate.
Pohon module mungkin mengingatkan kamu pada pohon direktori di filesystem komputermu; perbandingan ini memang sangat tepat! Sama seperti direktori di filesystem, kamu memakai module untuk mengorganisasi kode. Dan sama seperti file di dalam sebuah direktori, kita memerlukan cara untuk menemukan module kita.