cargo

rustc adalah singkatan dari Rust Compiler, dan perintah itulah yang sebenarnya digunakan saat melakukan compiling. Rust file diakhiri dengan ekstensi .rs. Namun pada umumnya banyak orang yang tidak menuliskan rustc main.rs untuk melakukan compile. Mereka biasanya menggunakan sesuatu yang biasanya disebut sebagai cargo, yang mana ini adalah package manager untuk Rust.

Satu catatan tentang nama cargo: ia disebut cargo karena di saat Andan meletakkan crates (peti) bersama-sama, Anda akan mendapatkan cargo. Sebuah peti adalah kotak kayu yang biasanya Anda lihat di kapal ataupun di truk, namun Anda mengingat bahwa setiap project di Rust juga disebut sebagai crate. Kemudian, di saat Anda menggabungkan semua crate-crate tersebut, Anda akan mendapatkan cargo.

Anda bisa melihat ini di saat Anda menggunakan cargo untuk menjalankan sebuah project. Mari kita mencoba melakukan sesuatu yang sederhana menggunakan rand: kita akan secara random memilih antara 8 huruf.

use rand::seq::SliceRandom; // gunakan ini untuk mengaplikasikan .choose terhadap slices

fn main() {

    let my_letters = vec!['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'];

    let mut rng = rand::thread_rng();
    for _ in 0..6 {
        print!("{} ", my_letters.choose(&mut rng).unwrap());
    }
}

Kita akan mendapatkan output seperti b c g h e a. Namun pertama-taman kita ingin melihat apa yang cargo lakukan. Untuk menggunakan cargo dan menjalankan program kita, biasanya kita menggunakan cargo run. Ia akan mem-build program kita dan menjalankannya. Namun di saat ia mulai melakukan compiling, ia melakukan hal seperti ini:

   Compiling getrandom v0.1.14
   Compiling cfg-if v0.1.10
   Compiling ppv-lite86 v0.2.8
   Compiling rand_core v0.5.1
   Compiling rand_chacha v0.2.2
   Compiling rand v0.7.3
   Compiling rust_book v0.1.0 (C:\Users\mithr\OneDrive\Documents\Rust\rust_book)
    Finished dev [unoptimized + debuginfo] target(s) in 13.13s
     Running `C:\Users\mithr\OneDrive\Documents\Rust\rust_book\target\debug\rust_book.exe`
g f c f h b

Jadi terlihat bahwa ia sepertinya tidak hanya menggunakan crate rand, namun ada beberapa crate lainnya juga. Ini dikarenakan kita memerlukan rand, namun rand juga memiliki beberapa bagian code yang memerlukan crate-crate lainnya. Sehingga cargo akan mencari semua crate yang kita perlukan dan memasukkan semuanya bersamaan. Di kasus kita ini, kita hanya memerlukan tujuh buah crate. Namun pada project yang besar Anda mungkin bisa memerlukan 200 atau lebih banyak crate yang harus dimasukkan ke project tersebut.

Ini adalah dimana Anda bisa melihat tradeoff pada Rust. Rust benar-benar sangat cepat, karena ia sebelumnya telah melakukan compile sebelum programnya digunakan. Hal ini dilakukan dengan cara (compilernya) melihat semua codenya dan memeriksa apa yang sebenarnya dilakukan oleh code yang kita tuliskan. Sebagai contoh, Anda menuliskan sebuah generic function:

use std::fmt::Display;

fn print_and_return_thing<T: Display>(input: T) -> T {
    println!("You gave me {} and now I will give it back.", input);
    input
}

fn main() {
    let my_name = print_and_return_thing("Windy");
    let small_number = print_and_return_thing(9.0);
}

Function ini bisa mengambil apapun yang memiliki trait Display, sehingga kita membarikannya &str dan selanjutnya f64, dan kita pun tidak mendapatkan masalah. Namun compiler tidak melihat ke generic, karena ia tidak ingin melakukan apapun di saat runtime (perlu diingat kembali, compiler harus mengetahui typenya di saat compile time). Compiler ingin membuat program yang bisa berjalan dengan sendirinya secepat mungkin. Sehingga di saat compiler melihat "Windy", ia tidak melihat functionnya sebagai fn print_and_return_thing<T: Display>(input: T) -> T. Ia akan meliha function tersebut seperti fn print_and_return_thing(input: &str) -> &str. Dan selanjutnya compiler akan melihat functionnya seperti fn print_and_return_thing(input: f64) -> f64. Semua pemeriksaan mengenai trait dan lainnya diselesaikan saat compile time. Ini sebabnya mengapa generic memakan waktu yang lebih lama untuk di-compile, karena ia perlu mengetahui semua posibilitas type yang digunakan, dan membuatnya menjadi concrete.

Satu hal lagi: Rust di tahun 2020 berupaya keras untuk mengupgrade compile time, karena bagian inilah yang memakan waktu paling lama. Setiap version di Rust menjadi sedikit lebih cepat saat melakukan compiling, dan ada beberapa rencana lain untuk mempercepatnya. Terlepas dari hal itu, untuk saat ini, inilah yang harus Anda ketahui:

  • cargo build akan mem-build program Anda, sehingga Anda bisa menjalankannya
  • cargo run akan mem-build program Anda dan menjalankannya sekaligus
  • cargo build --release dan cargo run --release akan melakukan hal yang sama namun di dalam mode release. Apa itu? Mode release berguna saat code Anda telah selesai dibuat. Kemudian Rust akan memerlukan waktu yang lebih lama untuk meng-compile, tapi compiler melakukan ini karena compiler akan melakukan apapun yang ia ketahui dan yang ia bisa untuk membuat programnya menjadi lebih cepat. Program dari mode release sebenarnya jauh lebih cepat daripada menggunakan mode regular, yang mana biasa disebut dengan mode debug. Ini dikarenakan ia meng-compile lebih cepat dan memiliki lebih banyak informasi debug. cargo build yang biasa (regular) biasa disebut dengan "debug build" dan cargo build --release biasa disebut dengan "release build".
  • cargo check adalah cara untuk memeriksa code Anda. Ia mirip seperti melakukan compiling, namun ia tidak benar-benar membuatkan programnya. Ini adalah cara yang baik yang sering digunakan untuk memeriksa code karena ia tidak memakan waktu lama seperti build ataupun run.

Ah ya, --release adalah bagian dari perintah yang biasa disebut dengan flag. Yang mana itu adalah informasi extra di dalam sebuah perintah.

Hal-hal lain yang perlu Anda ketahui adalah:

  • cargo new. Anda menggunakan ini untuk membuat project Rust yang baru. Setelah new, tuliskan nama projectnya dan cargo akan membuat folder dan semua file yang Anda perlukan.
  • cargo clean. Di saat Anda menambahkan crate pada Cargo.toml, computer akan men-download semua file yang diperlukan dan crate-crate ini akan memakan banyak space di harddisk Anda. Jika Anda tidak menginginkan crate-crate itu lagi pada komputer Anda, tuliskan perintah cargo clean.

Satu hal lagi tentang compiler: ia hanya membutuhkan waktu paling lama di saat Anda menggunakan cargo build atau cargo run untuk pertama kalinya. Setelah itu compilernya akan mengingatnya, dan selanjutnya ia akan melakukan compile dengan cepat lagi. Namun jika Anda menggunakan cargo clean dan kemudian menggunakan perintah cargo build, ia akan sekali lagi melakukan compile dengan lambat.