Anatomi Program Pertama

Kita sudah berhasil menjalankan program pertama melalui cargo, dan outputnya memang membahagiakan. Namun keberhasilan tanpa pemahaman membuat kita rentan: begitu pesan error muncul, kita tidak tahu bagian mana yang harus diperbaiki. Pada Chapter ini kita akan memperlambat langkah dan membedah program Rust terkecil secara menyeluruh — mulai dari fn main hingga makro println! — sehingga setiap karakter pada program kita berikutnya punya alasan keberadaannya.

Program Rust Terkecil #

Simpan kode berikut sebagai halo_rust.rs, lalu kompilasi dan jalankan:

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

rustc --edition 2021 halo_rust.rs
./halo_rust

Output yang Dihasilkan:

Halo, Rust!

Program tersebut hanya tiga baris, tetapi memuat hampir seluruh anatomi dasar Rust. Mari kita bedah fungsi setiap barisnya:

1. Baris 1 (fn main() {): kata kunci fn mendeklarasikan sebuah function bernama main. Tanda kurung kosong () menandakan function tersebut tidak menerima parameter, sedangkan kurung kurawal pembuka { memulai blok isi function.
2. Baris 2 (println!("Halo, Rust!");): memanggil makro println! dengan satu argument berupa string literal "Halo, Rust!". Makro tersebut mencetak teks ke layar lalu menambahkan pergantian baris (newline) di akhirnya. Tanda titik koma menandai berakhirnya pernyataan.
3. Baris 3 (}): kurung kurawal penutup yang mengakhiri blok milik main. Seluruh isi function harus berada di antara pasangan kurung kurawal ini.

Function main sebagai Titik Masuk #

Kompilator Rust mengenali nama main secara istimewa: function inilah titik masuk (entry point) tempat eksekusi program dimulai. Setiap program binary Rust wajib memiliki tepat satu function main; tanpa function tersebut, kompilasi gagal karena kompilator tidak tahu harus memulai dari mana.

Tiga aturan penting menyertai function ini:

• Nama main ditulis dengan huruf kecil semua. Rust membedakan huruf besar dan kecil (case-sensitive), jadi Main atau MAIN bukanlah titik masuk.
• Kurung kurawal {} membungkus seluruh isi function; kedalaman indentasi tidak memengaruhi logika program.
• Eksekusi program berjalan dari baris pertama main hingga baris terakhir, lalu program berakhir.

Kata kunci fn sendiri akan terus kita pakai untuk membuat function lain di kemudian hari. Perbedaannya, nama function selain main harus dipanggil secara eksplisit agar isinya dieksekusi.

Makro println! dan Tanda Seru #

Perhatikan tanda seru (!) setelah kata println. Tanda tersebut membedakan makro dari function biasa: println! adalah macro, yaitu kode yang di-expand oleh kompilator menjadi rangkaian instruksi pencetakan yang lengkap saat kompilasi berlangsung. Dalam praktik sehari-hari, kita cukup memperlakukan println! seperti perintah cetak biasa; detail cara membuat makro sendiri akan kita bahas pada section Macros jauh di depan.

String literal "Halo, Rust!" ditulis di antara tanda kutip ganda. Rust tidak mengenal tanda kutip tunggal untuk teks seperti PHP; tanda kutip tunggal dipakai untuk tipe karakter tunggal. Teks apa pun yang berada di dalam tanda kutip ganda akan dicetak apa adanya, kecuali pola placeholder yang akan kita pelajari berikutnya.

Placeholder untuk Menyisipkan Nilai #

Program yang berguna jarang hanya mencetak teks mati; kita perlu menyisipkan nilai variable ke dalam kalimat. Rust memakai placeholder {} di dalam string, dan setiap placeholder diisi oleh argument yang ditulis setelah string. Perhatikan contoh berikut:

fn main() {
    let language = "Rust";
    let year = 2026;

    println!("Saya belajar {} sejak tahun {}", language, year);
}

Output yang Dihasilkan:

Saya belajar Rust sejak tahun 2026

Mari kita telaah pemetaannya:

1. Baris 2 (let language = "Rust";): membuat variable language berisi teks "Rust".
2. Baris 3 (let year = 2026;): membuat variable year berisi bilangan bulat 2026.
3. Baris 5 (println!("Saya belajar {} sejak tahun {}", language, year);): placeholder {} pertama digantikan argument pertama (language), dan placeholder kedua digantikan argument kedua (year). Jumlah placeholder harus sama dengan jumlah argument; jika tidak, kompilator menolak program dengan pesan yang jelas.

Argument tidak harus berupa variable — ekspresi aritmatika juga boleh langsung ditulis, seperti pada contoh berikut:

fn main() {
    let price = 50000;
    let quantity = 3;

    println!("Harga satuan: Rp{}", price);
    println!("Jumlah: {}", quantity);
    println!("Total: Rp{}", price * quantity);
}

Output yang Dihasilkan:

Harga satuan: Rp50000
Jumlah: 3
Total: Rp150000

Pada baris terakhir, price * quantity dihitung lebih dahulu menjadi 150000, kemudian hasil tersebut mengisi placeholder dan tercetak sebagai Rp150000. Kita tidak perlu variable sementara khusus untuk hasil perkalian tersebut.

Menyebut Nama Variable Langsung di Placeholder #

Sejak edition 2021, Rust menyediakan cara penulisan yang lebih ringkas: menuliskan nama variable langsung di dalam placeholder. Bandingkan kedua gaya berikut:

fn main() {
    let city = "Bandung";
    let temperature = 29;

    println!("Cuaca di {city} hari ini: {temperature} derajat");
}

Output yang Dihasilkan:

Cuaca di Bandung hari ini: 29 derajat

Penulisan {city} memiliki makna yang sama dengan {} yang diikuti argument city: isi variable city menggantikan placeholder tersebut. Gaya ini mengurangi pengulangan nama variable di ujung pernyataan sehingga baris panjang tetap mudah dibaca. Kedua gaya boleh dicampur dalam satu pemanggilan println! sesuai selera kita.

Titik Koma, Blok, dan Indentasi #

Tiga konvensi kecil ini menentukan apakah kode kita lolos kompilasi:

• Titik koma (;) mengakhiri pernyataan. Kebanyakan baris di dalam main ditutup titik koma, termasuk pemanggilan println!. Lupa menaruhnya akan memicu pesan error — kabar baiknya, kompilator menunjukkan lokasi dan bahkan menawarkan letak titik koma yang hilang.
• Kurung kurawal ({}) membentuk blok. Blok milik main dibuka di baris pertama dan ditutup di baris terakhir; blok if yang kita jumpai pada Chapter sebelumnya bekerja dengan cara yang sama.
• Indentasi empat spasi adalah konvensi komunitas Rust, bukan aturan sintaks. Kompilator tetap menerima indentasi lain, tetapi seluruh ekosistem Rust memakai empat spasi sehingga kode kita sebaiknya mengikuti agar seragam.

Ringkasan #

Anatomi program Rust terkecil kini tidak lagi menyimpan rahasia: fn main() { membuka titik masuk program, println! mencetak teks melalui makro, placeholder {} menyisipkan nilai variable maupun hasil ekspresi, dan titik koma menutup setiap pernyataan. Dengan peta anatomi ini di tangan, kita siap memahami bagaimana kode sumber berubah menjadi binary yang berjalan — topik Chapter berikutnya tentang model kompilasi Rust.