Foundation

BAB 1: Program Pertama: Hello Rust

Program Rust pertama: fungsi main sebagai titik masuk, macro println!, menulis ke stderr, dan pesan kompilator saat format atau fungsi utama salah.

Program Rust pertama hanya 3 baris, tetapi di dalamnya ada 4 hal yang berbeda dari bahasa yang memakai interpreter: fungsi main sebagai titik masuk, makro println! dengan tanda seru, argumen format di dalam string, dan langkah kompilasi yang menghasilkan berkas biner sebelum program bisa dijalankan.

Bab ini menulis program itu, menjalankannya, lalu membongkar tiap bagian dengan bukti dari kompilator. Semua contoh dikompilasi dengan rustc 1.100.0, dan pesan kesalahan yang dikutip adalah keluaran asli kompilator, bukan ringkasan.

Program pertama

RSRUST
fn main() {
    println!("Hello, Rust!");
}

Simpan sebagai hello.rs, lalu kompilasi:

CodeTEXT
rustc hello.rs
./hello

Baris pertama menghasilkan berkas hello yang bisa dijalankan langsung. Baris kedua menjalankannya dan mencetak:

CodeTEXT
Hello, Rust!

Berkas hello itu bukan skrip yang dibaca ulang setiap kali dijalankan. Ukurannya 4.493.168 byte, dan isinya sudah berupa kode mesin untuk sistem tempat kompilasi dilakukan.

fn main adalah titik masuk

Program Rust selalu dimulai dari fungsi bernama main. Tanpa fungsi itu, kompilasi gagal sebelum program sempat dijalankan:

RSRUST
fn utama() {
    println!("tanpa main");
}
CodeTEXT
error[E0601]: `main` function not found in crate `tanpa_main`
 --> tanpa_main.rs:3:2
  |
3 | }
  |  ^ consider adding a `main` function to `tanpa_main.rs`

Nama main tidak bisa diganti, dan posisinya boleh di mana saja di dalam berkas. Yang penting, hanya ada 1 fungsi main pada setiap program yang bisa dijalankan.

Tanda kurung kurawal {} setelah main() menandai blok kode milik fungsi itu. Semua perintah yang ingin dijalankan ditulis di dalamnya.

println! adalah makro, bukan fungsi

Tanda seru setelah println bukan hiasan. Tanda itu menandakan bahwa println! adalah makro, yaitu kode yang diperluas menjadi kode lain saat kompilasi. Salah satu akibatnya, println! bisa memeriksa jumlah dan tipe argumen pada saat kompilasi, sebelum program berjalan.

RSRUST
fn main() {
    println!("Hello, Rust!");
}

Kalau tanda seru dihilangkan, kompilator akan mengeluh karena tidak ada fungsi bernama println. Untuk sementara, aturan yang perlu diingat: semua pencetakan di bab ini memakai tanda seru, karena println! dan eprintln! keduanya makro.

Argumen format di dalam string

println! menerima string format dan daftar nilai. Tanda {} di dalam string digantikan nilai sesuai urutan, sedangkan {nama} mengambil variabel dengan nama tersebut.

RSRUST
fn main() {
    println!("Nama saya {}, umur saya {} tahun", "Aziz", 30);

    let angka = 7;
    println!("angka = {angka}, kuadrat = {}", angka * angka);
}
CodeTEXT
Nama saya Aziz, umur saya 30 tahun
angka = 7, kuadrat = 49

Bentuk {angka} lebih ringkas dan lebih aman daripada {}, karena nama variabelnya terlihat di dalam string. Kalau variabel itu nanti diubah namanya, kompilator akan menolak kode yang masih memakai nama lama.

Kalau jumlah argumen tidak cocok dengan tanda {}, kompilasi berhenti:

RSRUST
fn main() {
    println!("{} dan {}", 1);
}
CodeTEXT
error: 2 positional arguments in format string, but there is 1 argument
 --> format_salah.rs:2:15
  |
2 |     println!("{} dan {}", 1);
  |               ^^     ^^   -

Kesalahan seperti ini tidak mungkin lolos ke pengguna, karena kompilator menghitungnya sebelum program dibuat.

Kurung kurawal yang ingin dicetak

Kurung kurawal dipakai penanda format, sehingga kurung kurawal yang ingin tampil apa adanya harus ditulis 2 kali:

RSRUST
fn main() {
    println!("kurung kurawal ditulis {{seperti ini}}");
}
CodeTEXT
kurung kurawal ditulis {seperti ini}

Mencetak ke stderr

println! menulis ke stdout, sedangkan eprintln! menulis ke stderr. Pada program yang dijalankan di terminal, keduanya terlihat sama. Perbedaannya terlihat saat keluarannya dipisah, misalnya dengan pengalihan:

RSRUST
fn main() {
    println!("baris ini keluar lewat stdout");
    eprintln!("baris ini keluar lewat stderr");
}
CodeTEXT
./program 2>/dev/null
baris ini keluar lewat stdout

./program 1>/dev/null
baris ini keluar lewat stderr

Pemisahan ini berguna untuk pesan kesalahan dan log, karena keduanya bisa disimpan di berkas berbeda dari hasil program. Untuk sementara, cukup ingat bahwa println! untuk hasil, eprintln! untuk pesan diagnostik.

Membaca susunan program

Kembali ke program pertama, tiap bagiannya punya tugas:

BagianTugas
fnmenandai deklarasi fungsi
main()nama fungsi yang dijadikan titik masuk
{ }blok kode yang dijalankan
println!makro pencetak ke stdout
"Hello, Rust!"string format tanpa penanda
;penutup pernyataan

Titik koma di akhir baris println! wajib ditulis, karena baris itu adalah pernyataan. Aturan ini akan terasa berbeda saat masuk ke bab tentang block expression, karena tidak semua baris di Rust diakhiri titik koma.

Titik koma yang hilang

Titik koma di akhir println! mudah terlupa, terutama bagi yang terbiasa dengan bahasa tanpa titik koma. Kalau baris itu bukan baris terakhir di dalam blok, kompilator menolaknya:

RSRUST
fn main() {
    println!("satu")
    println!("dua");
}
CodeTEXT
error: expected `;`, found `println`
 --> tanpa_titikkoma.rs:2:21
  |
2 |     println!("satu")
  |                     ^ help: add `;` here
3 |     println!("dua");
  |     ------- unexpected token

Perhatikan bahwa baris terakhir di dalam blok justru tidak wajib berakhir titik koma, karena baris itu dibaca sebagai nilai kembalian blok. Aturan ini yang membuat contoh 1 baris seperti fn main() { println!("hai") } tetap sah.

Kompilasi sekali, jalankan berkali-kali

Biner hasil kompilasi bisa dijalankan tanpa kompiler. Saya menjalankan hello dengan PATH yang tidak memuat folder cargo, dan programnya tetap mencetak Hello, Rust! dengan kode keluar 0.

CodeTEXT
env -i PATH=/usr/bin:/bin ./hello
Hello, Rust!

Sifat ini yang membedakan alur kerja Rust dari bahasa ber-interpreter. Kompilasi memakan waktu di awal, tetapi menjalankan program sesudahnya tidak memerlukan apa pun selain berkas biner itu, dan mesin tujuan tidak perlu memasang Rust.

Nama berkas menentukan nama biner

rustc memakai nama berkas sumber sebagai nama biner, tanpa ekstensi .rs. Berkas nama-berkas.rs menghasilkan biner nama-berkas sebesar 4.493.232 byte, lengkap dengan tanda hubung di namanya.

CodeTEXT
rustc nama-berkas.rs
./nama-berkas

Kalau nama biner ingin berbeda, tulis dengan -o:

CodeTEXT
rustc nama-berkas.rs -o program_saya

Nama berkas sumber tidak berpengaruh pada isi program. Yang berpengaruh hanya nama biner yang dihasilkan, dan itulah yang dipakai saat program dijalankan.

Eksperimen pertama

5 hal yang bisa dicoba setelah program pertama berjalan:

  1. Ganti teks di dalam string, kompilasi ulang, lalu jalankan. Berkas biner lama akan tertimpa, jadi tidak perlu menghapusnya lebih dulu.
  2. Hapus fungsi main dan lihat pesan E0601 muncul.
  3. Tambah 1 argumen pada string format yang hanya punya 1 penanda, lalu baca pesan kesalahannya.
  4. Hapus titik koma pada baris pertama di dalam blok dan lihat pesan expected ; muncul.
  5. Ganti println! menjadi eprintln!, lalu jalankan dengan 2>/dev/null untuk melihat keluarannya hilang dari layar.

Kelima percobaan itu memakai perintah yang sama, dan itu inti alur kerja Rust: ubah kode, kompilasi, jalankan. Tidak ada langkah tambahan seperti memasang runtime atau menjalankan server, dan tidak ada berkas perantara yang perlu diurus sendiri.

Ringkasan

Program Rust dijalankan dari fungsi main, dan kompilasi dengan rustc menghasilkan berkas biner yang bisa dijalankan langsung. println! adalah makro, bukan fungsi, sehingga pemanggilannya memakai tanda seru.

String format memakai {} untuk nilai berurutan dan {nama} untuk variabel tertentu, sedangkan kurung kurawal yang ingin dicetak ditulis 2 kali. Keluaran hasil memakai println! ke stdout, pesan diagnostik memakai eprintln! ke stderr, dan kesalahan format maupun fungsi main yang hilang ditolak saat kompilasi.

Referensi

  1. The Rust Programming Language. Hello, World!.
  2. The Rust Programming Language. Hello, Cargo!.
  3. Standard library. Macro println.
  4. Standard library. Macro eprintln.