Cargo

Mengenal Packages, Crates, & Module

Dalam development software tentunya bertambahnya fitur akan seiring dengan bertambahnya jumlah kode, untuk itu Rust punya beberapa konsep yang mungkin untuk membuat sebuah komponen yang modular.

Packages adalah paket skeleton project yang siap pakai.
Crates adalah root dari beberapa module, dan function yang berelasi.
Modules & use untuk mengontrol ruang lingkup dan privasi dari paths atau bagian dari sistem module.
Paths adalah sebuah file yang terisolasi untuk mengelompokkan function dan module.

Packages & Crates

Crates adalah kumpulan modules, dan function yang saling berelasi di dalam sebuah package.

cargo new my-project
Created binary (application) `my-project` package
ls my-project
Cargo.toml
src
ls my-project/src
main.rs

Pada contoh diatas perintah cargo new my-project akan menghasilkan package my-project didalamnya terdapat direktori src yang berisi file src/main.rs dan file Cargo.toml yang berisi informasi paket pustaka yang kita gunakan, mirip seperti package.json jika menggunakan NodeJS.

Modules

Setelah membahas tentang package dan crate hal selanjutnya adalah modules, kita akan bahas sedikit tentang bagian-bagian dari sebuah module. Hal yang pertama adalah paths yang digunakan untuk mengelompokkan sebuah fungsi-fungsi dan module dalam sebuah file. Selanjutnya ada use yang merupakan keyword untuk memanggil atau membawa sebuah path kedalam scope yang berbeda, dan pub keyword yang akan membuat sebuah item menjadi publik agar dapat diakses di scope yang berbeda.

Modules membuat kita mudah untuk mengorganisasikan sebuah function berdasarkan fungsinya dan dapat digunakan berkali-kali untuk meminimalisir pekerjaan kita.

Oke, untuk selanjutnya kita akan membuat sebuah paket library di Rust, silakan ketik perintah cargo new --lib my-lib yang secara otomatis akan membuat skeleton project yang support untuk menerapkan konsep library, dengan option --lib file yang di generate dalam direktori src adalah src/lib.rs berbeda dengan tanpa menggunakan --lib.

// src/lib.rs
pub mod restaurant {
   pub fn hello(name: String) -> String {
       name
   }
}

Pada contoh kode diatas terdapat sebuah module restaurant dengan function hello() di dalamnya. Keyword pub digunakan untuk membuat module tersebut bisa diakses dari scope atau path yang berbeda.

Untuk menguji module restaurant tersebut silakan buat file main.rs, di dalam direktori src/main.rs isi dengan kode dibawah ini.

// src/main.rs
extern crate my_lib;
use my_lib::restaurant;
fn main() {
   let adi = restaurant::hello(String::from("adi"));
   println!("{}", adi);
}

Pada kode diatas, kode extern crate my_lib bertujuan untuk mengambil module yang berada di paths lib.rs yang merupakan root component, kemudian ada keyword use tujuannya untuk membawa module restaurant yang ada pada package my_lib.

Paths untuk mereferensi ke sebuah item di dalam module

Ada dua path yang terkenal di Rust, yaitu, absolute path & relative path, berikut penjelasannya.

Absolute path diawali dengan keyword crate untuk mengambil modul dari root component.
Relative path menggunakan self dan super untuk mengambil dari current module.

Dari kedua absolute dan relative paths diatas selanjutnya untuk mengakses module secara spesifik bisa menggunakan semicolons (::) biar lebih clear berikut ada contohnya.

// src/lib.rs
pub mod restaurant {
   pub fn hello(name: String) -> String {
       name
   }
}
pub fn call_directly() {
   // Absolute Path
   crate::restaurant::hello();
   // Relative Path
   self::restaurant::hello();
}

Keyword pub yang terdapat diawal module dan function bertujuan untuk mengekspos module dan function agar bisa diakses di luar scope, karena secara default module dan function di Rust bersifat private.

Memahami Penggunaan Use

pub mod restaurant {
   pub fn hello(name: String) -> String {
       name
   }
}
use crate::restaurant;
pub fn call_hello_from_restaurant() {
   restaurant::hello()
}

Pada kode diatas, syntax kode use crate::restaurant; digunakan untuk mengambil module restaurant dari root module dengan menggunakan cara absolute paths.

Chapter 3

Crates