Kode yang kita tulis hari ini akan dibaca kembali oleh manusia — diri kita sendiri tiga bulan ke depan, atau rekan tim yang baru bergabung di proyek. Compiler tidak membutuhkan bantuan apa pun untuk membaca kode, tetapi manusia sering membutuhkan konteks yang tidak muat dalam nama variabel: alasan sebuah angka dipilih, kenapa satu cabang if sengaja kosong, atau unit apa yang dipakai sebuah nilai. Komentar biasa dengan tanda // adalah kanal resmi untuk catatan semacam itu. Catatan tersebut hidup di dalam source code, terlihat oleh siapa pun yang membaca filenya, dan sama sekali tidak ikut serta dalam program jadi. Pada section ini kita akan membangun dokumentasi Rust layer demi layer, dan layer pertamanya justru bentuk paling sederhana: komentar yang tidak dimaksudkan untuk dibaca compiler maupun pengguna crate eksternal.

Komentar untuk Manusia, Bukan untuk Mesin #

Rust mengenal komentar baris dengan tanda //. Semua karakter setelah tanda tersebut sampai akhir baris dianggap komentar dan diabaikan sepenuhnya oleh compiler. Komentar boleh menempati satu baris penuh, berada di akhir baris berisi kode (sering disebut inline comment), atau muncul berulang di banyak baris berurutan. Kita juga bebas menulis komentar di mana pun — sebelum fungsi, di dalam blok {}, di antara dua statement — tanpa memengaruhi makna program.

Rust juga menyediakan komentar blok dengan pasangan /* dan */ yang membungkus banyak baris sekaligus. Perbedaan pentingnya dibanding bahasa C: komentar blok Rust boleh bersarang, sebuah /* di dalam /* harus ditutup */ tambahan sebelum blok luar berakhir. Perilaku ini akan kita buktikan dengan contoh nyata di bawah.

Mekanisme: Lexer Membuang Komentar Sebelum Analisis #

Ketika rustc membaca berkas sumber, tahap pertama yang berjalan adalah lexer — komponen yang memecah teks menjadi token. Begitu lexer bertemu //, lexer melompat langsung ke karakter baris baru; begitu bertemu /*, lexer melompat sampai pasangan */ yang sepadan (perhitungan bersarang inilah yang membuat /* /* */ */ valid). Token hasil lexing sama sekali tidak memuat isi komentar, sehingga tahap parsing, pemeriksaan tipe, dan code generation tidak pernah melihat teks komentar. Akibatnya komentar tidak menghasilkan instruksi mesin apa pun: program dengan lima komentar dan program tanpa komentar sama sekali menghasilkan perilaku biner yang identik. Komentar adalah artefak yang hidup hanya di source code.

Contoh: Catatan di Program Warung Kopi #

Mari kita buktikan dua klaim sekaligus: komentar tidak mengganggu kompilasi, dan komentar dapat membantu pembaca memahami maksud kode. Buat proyek baru, lalu isi src/main.rs dengan program berikut:

rust 
// Program penghitung total belanja warung kopi.

fn main() {
    // harga dalam rupiah, per gelas / per porsi
    let harga_kopi_susu = 18_000;
    let harga_roti_bakar = 12_000; // roti dengan topping keju

    // pelanggan memesan dua kopi susu dan satu roti bakar
    let jumlah_kopi = 2;
    let jumlah_roti = 1;

    // hitung total sebelum diskon anggota
    let total = harga_kopi_susu * jumlah_kopi + harga_roti_bakar * jumlah_roti;

    /* cetak struk sederhana ke layar */
    println!("Total belanja: Rp{}", total);
}

Jalankan program:

bash 
cargo run

Output yang Dihasilkan:

text 
Total belanja: Rp48000

Program berjalan seolah-olah semua komentar tidak pernah ditulis — memang demikian adanya. Mari kita bedah peran komentar di tiap baris penting:

  1. Baris 1 (// Program penghitung total belanja warung kopi.): komentar tingkat file yang menjelaskan tujuan program secara keseluruhan. Lexer membuang baris ini sebelum parsing dimulai.
  2. Baris 4 (// harga dalam rupiah, per gelas / per porsi): komentar di atas sekelompok deklarasi yang menyatakan satuan nilai. Nama harga_kopi_susu menyimpan angka, tetapi hanya komentar yang menyatakan bahwa angka tersebut dalam rupiah — compiler tidak pernah memeriksa satuan.
  3. Baris 6 (let harga_roti_bakar = 12_000; // roti dengan topping keju): inline comment di akhir baris. Lexer memproses statement let sampai titik koma, lalu melompat ke baris baru saat bertemu //.
  4. Baris 12 (// hitung total sebelum diskon anggota): komentar yang menjelaskan mengapa perhitungan muncul di sana dan konteksnya — total ini masih sebelum diskon, informasi yang tidak bisa ditebak dari nama variabel total.
  5. Baris 13 (let total = ...): statement yang dihitung normal oleh compiler; kehadiran komentar di atasnya tidak mengubah apa pun pada hasil 48_000.
  6. Baris 15 (/* cetak struk sederhana ke layar */): komentar blok satu baris. Lexer melompat dari /* ke */ pada baris yang sama, lalu melanjutkan membaca println!.

Komentar Blok yang Bersarang #

Kemampuan bersarang /* */ membedakan Rust dari C dan C++. Kode berikut membuktikannya — komentar dalam ditutup lebih dulu, lalu blok luar ditutup:

rust 
fn main() {
    /* catatan sementara: fungsi import stok
       /* TODO: ganti dengan baca berkas CSV */
       selesai menyusun ulang tampilan */
    let stok_biji = 40;
    println!("Stok biji kopi tersisa: {} kg", stok_biji);
}

Output yang Dihasilkan:

text 
Stok biji kopi tersisa: 40 kg

Mari kita bedah blok komentar di atas:

  1. Baris 2 (/* catatan sementara: fungsi import stok): membuka komentar blok luar. Lexer kini berada di dalam komentar dan menghitung kedalaman bersarang.
  2. Baris 3 (/* TODO: ganti dengan baca berkas CSV */ — komentar dalam): membuka komentar kedua di dalam yang pertama, lalu menutupnya di baris yang sama. Di C, */ pertama akan menutup seluruh komentar dan sisa teks menjadi kode — di Rust, kedalaman bersarang membuat komentar luar tetap berlanjut.
  3. Baris 4 (selesai menyusun ulang tampilan */): menutup komentar luar. Setelah titik ini lexer kembali membaca kode sungguhan, sehingga let stok_biji = 40; diproses normal.
  4. Baris 5-6 (let stok_biji dan println!): kode berjalan normal — bukti bahwa seluruh blok tiga baris di atasnya benar-benar diabaikan hingga kedalaman bersarang habis.

Kapan Komentar Membantu, Kapan Mengganggu #

Komentar terbaik menjawab pertanyaan mengapa, bukan mengulang apa. Komentar // tambahkan 1 ke i di atas i += 1 hanya menduplikasi kode; komentar // lewati baris header CSV di baris pertama menyimpan informasi yang tidak terbaca dari kode. Sebelum menulis komentar, kita perlu yakin bahwa nama variabel, nama fungsi, dan struktur kode sudah kehabisan cara menyampaikan maksud tersebut — komentar adalah jalan terakhir, bukan yang pertama.

Ringkasan #

Komentar biasa // dan blok /* */ adalah catatan untuk manusia yang dibuang oleh lexer sebelum kompilasi — tidak ada jejaknya di program jadi, dan komentar blok Rust boleh bersarang dengan penghitungan kedalaman. Komentar paling berguna saat menjelaskan satuan, alasan keputusan, dan konteks yang tidak muat dalam nama. Lapisan ini murni internal: pembaca lain harus membuka source code untuk melihatnya. Bagaimana jika kita ingin catatan yang ikut terbit sebagai dokumentasi API yang bisa dibaca tanpa membuka source? Jawabannya adalah doc comment ///, materi Chapter berikutnya.