Sintaks Utama #

// Ini adalah program Rust paling sederhana yang bisa dijalankan

fn main() {
    // println! adalah macro, bukan fungsi biasa
    // Tanda seru (!) membedakan macro dari function call
    println!("Halo, Rust!");

    // Deklarasi variabel menggunakan let
    let angka = 42;
    let pesan = "Nilai angka adalah";

    // Format string menggunakan {} sebagai placeholder
    println!("{}: {}", pesan, angka);
}

// Komentar satu baris — diabaikan oleh compiler

/*
   Komentar blok — bisa mencakup
   beberapa baris sekaligus
*/

/// Komentar dokumentasi untuk item di bawahnya (fungsi, struct, dll.)
/// Mendukung sintaks Markdown dan diproses oleh rustdoc.
///
/// # Contoh
///
/// ```
/// let hasil = tambah(2, 3);
/// assert_eq!(hasil, 5);
/// ```
fn tambah(a: i32, b: i32) -> i32 {
    a + b
}

//! Komentar dokumentasi untuk modul atau crate itu sendiri
//! Biasanya ada di baris pertama file lib.rs atau main.rs

fn main() {
    // ANTI-PATTERN: mencoba mengubah variabel immutable
    let x = 5;
    x = 6; // error[E0384]: cannot assign twice to immutable variable `x`

    // BENAR: deklarasikan mut jika memang perlu diubah
    let mut y = 5;
    y = 6; // ✓ valid
    println!("y = {}", y);
}

fn main() {
    let angka = 5;

    // Shadowing: buat variabel baru dengan nama sama
    let angka = angka + 1;       // angka = 6

    // Shadowing bahkan bisa mengubah tipe
    let angka = angka.to_string(); // sekarang angka bertipe String, bukan i32

    println!("angka = {}", angka); // angka = "6"

    // ANTI-PATTERN: menggunakan mut untuk "mengubah tipe"
    // let mut nilai = 5;
    // nilai = "lima"; // error — tidak bisa mengubah tipe variabel mut
}

// Konstanta menggunakan SCREAMING_SNAKE_CASE
const KECEPATAN_CAHAYA: u64 = 299_792_458; // m/s

// Underscore bisa digunakan sebagai pemisah digit untuk keterbacaan
const POPULASI_BUMI: u64 = 8_000_000_000;

fn main() {
    println!("Kecepatan cahaya: {} m/s", KECEPATAN_CAHAYA);
}

fn main() {
    // Integer — gunakan suffix untuk tipe eksplisit
    let a: i32 = -42;
    let b = 1_000_000u64;    // suffix u64, underscore untuk keterbacaan
    let c = 0xFF;            // hexadecimal
    let d = 0b1111_0000;     // binary
    let e = 0o77;            // octal

    // Float
    let f: f64 = 3.14159;
    let g = 2.0f32;          // suffix f32

    // Boolean
    let benar: bool = true;
    let salah = false;

    // Char — gunakan single quote, bukan double quote
    let huruf = 'A';
    let emoji = '🦀'; // Rust char mendukung semua Unicode
    let karakter_cina = '中';

    println!("{} {} {} {} {}", a, f, benar, huruf, emoji);
}

fn main() {
    // Tuple: kumpulan nilai dengan tipe yang bisa berbeda-beda
    let koordinat: (f64, f64, f64) = (1.0, 2.5, -0.3);

    // Akses via indeks
    let x = koordinat.0;
    let y = koordinat.1;

    // Destructuring — cara yang lebih idiomatis
    let (px, py, pz) = koordinat;
    println!("Posisi: {}, {}, {}", px, py, pz);

    // Array: kumpulan nilai dengan tipe SAMA dan ukuran TETAP
    let angka: [i32; 5] = [1, 2, 3, 4, 5];
    let semua_nol = [0; 10]; // 10 elemen, semuanya 0

    // Akses via indeks
    println!("Elemen pertama: {}", angka[0]);
    println!("Panjang array: {}", angka.len());

    // ANTI-PATTERN: akses indeks di luar batas
    // let x = angka[10]; // runtime panic: index out of bounds
}

fn main() {
    let suhu = 28;

    // if sebagai statement biasa
    if suhu > 30 {
        println!("Panas");
    } else if suhu > 20 {
        println!("Nyaman");
    } else {
        println!("Dingin");
    }

    // BENAR: if sebagai expression — mengembalikan nilai
    let kondisi = if suhu > 30 { "panas" } else { "sejuk" };
    println!("Cuaca {}", kondisi);

    // ANTI-PATTERN: tipe pada setiap branch harus sama
    // let kondisi = if suhu > 30 { "panas" } else { 0 };
    // error: `if` and `else` have incompatible types
}

fn main() {
    let angka = 7;

    // ANTI-PATTERN: menggunakan if-else berantai untuk pattern matching
    // if angka == 1 { ... } else if angka == 2 { ... } — verbose dan tidak exhaustive

    // BENAR: gunakan match
    match angka {
        1 => println!("Satu"),
        2 | 3 => println!("Dua atau Tiga"),      // multiple pattern
        4..=6 => println!("Empat sampai Enam"),   // range pattern
        n if n > 6 => println!("Lebih dari 6: {}", n), // guard condition
        _ => println!("Lainnya"),                  // wildcard — wajib jika tidak exhaustive
    }

    // match juga bisa mengembalikan nilai
    let deskripsi = match angka {
        1..=3 => "kecil",
        4..=6 => "sedang",
        _ => "besar",
    };
    println!("Angka {}: {}", angka, deskripsi);
}

fn main() {
    // loop — perulangan tanpa batas, dihentikan dengan break
    // Bisa mengembalikan nilai via break
    let mut counter = 0;
    let hasil = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2; // kembalikan nilai dari loop
        }
    };
    println!("Hasil loop: {}", hasil); // 20

    // while — perulangan selama kondisi true
    let mut n = 0;
    while n < 5 {
        print!("{} ", n);
        n += 1;
    }
    println!();

    // for — cara paling idiomatis untuk iterasi koleksi
    let koleksi = [10, 20, 30, 40, 50];
    for elemen in koleksi {
        print!("{} ", elemen);
    }
    println!();

    // Range: 0..5 (eksklusif), 0..=5 (inklusif)
    for i in 0..5 {
        print!("{} ", i); // 0 1 2 3 4
    }
    println!();

    // Enumerate untuk mendapat indeks sekaligus nilai
    for (indeks, nilai) in koleksi.iter().enumerate() {
        println!("[{}] = {}", indeks, nilai);
    }
}

// Fungsi tanpa return value (return type () — unit type)
fn sapa(nama: &str) {
    println!("Halo, {}!", nama);
}

// Fungsi dengan return value — tipe setelah ->
fn tambah(a: i32, b: i32) -> i32 {
    // BENAR: expression tanpa titik koma = return value implisit
    a + b
}

// ANTI-PATTERN: menggunakan return eksplisit untuk early return yang bukan early return
fn kurang(a: i32, b: i32) -> i32 {
    return a - b; // berlebihan untuk kasus sederhana
}

// BENAR: return eksplisit hanya untuk early return
fn pembagian_aman(a: i32, b: i32) -> Option<i32> {
    if b == 0 {
        return None; // early return — di sini return eksplisit masuk akal
    }
    Some(a / b) // return implisit di akhir fungsi
}

fn main() {
    sapa("Rustacean");
    println!("3 + 4 = {}", tambah(3, 4));

    match pembagian_aman(10, 0) {
        Some(hasil) => println!("Hasil: {}", hasil),
        None => println!("Tidak bisa dibagi nol"),
    }
}

fn main() {
    let pengali = 3;

    // Closure menangkap `pengali` dari scope luar
    let kalikan = |x: i32| x * pengali;

    println!("5 x {} = {}", pengali, kalikan(5)); // 15

    // Closure sering digunakan dengan iterator methods
    let angka = vec![1, 2, 3, 4, 5];

    let genap: Vec<i32> = angka.iter()
        .filter(|&&x| x % 2 == 0)
        .copied()
        .collect();

    let dikuadratkan: Vec<i32> = angka.iter()
        .map(|&x| x * x)
        .collect();

    println!("Genap: {:?}", genap);           // [2, 4]
    println!("Kuadrat: {:?}", dikuadratkan);  // [1, 4, 9, 16, 25]
}

// Definisi struct
struct Persegi {
    lebar: u32,
    tinggi: u32,
}

// Implementasi method untuk struct menggunakan impl block
impl Persegi {
    // Associated function (bukan method) — tidak ada parameter self
    // Biasanya digunakan sebagai constructor
    fn baru(lebar: u32, tinggi: u32) -> Persegi {
        Persegi { lebar, tinggi } // field shorthand jika nama sama dengan variabel
    }

    // Method — parameter pertama selalu &self, &mut self, atau self
    fn luas(&self) -> u32 {
        self.lebar * self.tinggi
    }

    fn keliling(&self) -> u32 {
        2 * (self.lebar + self.tinggi)
    }

    fn perbesar(&mut self, faktor: u32) {
        self.lebar *= faktor;
        self.tinggi *= faktor;
    }
}

fn main() {
    let mut p = Persegi::baru(10, 5);
    println!("Luas: {}", p.luas());       // 50
    println!("Keliling: {}", p.keliling()); // 30

    p.perbesar(2);
    println!("Setelah diperbesar — Luas: {}", p.luas()); // 200

    // Struct update syntax — salin field dari struct lain
    let p2 = Persegi { lebar: 20, ..p };
    println!("p2 — Lebar: {}, Tinggi: {}", p2.lebar, p2.tinggi); // 20, 10
}

// Enum dengan berbagai jenis variant
enum Pesan {
    Keluar,                          // variant tanpa data
    Pindah { x: i32, y: i32 },      // variant dengan named fields
    Tulis(String),                   // variant dengan satu nilai
    GantiWarna(u8, u8, u8),         // variant dengan beberapa nilai
}

impl Pesan {
    fn proses(&self) {
        match self {
            Pesan::Keluar => println!("Program keluar"),
            Pesan::Pindah { x, y } => println!("Pindah ke ({}, {})", x, y),
            Pesan::Tulis(teks) => println!("Menulis: {}", teks),
            Pesan::GantiWarna(r, g, b) => println!("Warna: #{:02X}{:02X}{:02X}", r, g, b),
        }
    }
}

fn main() {
    let pesan_list = vec![
        Pesan::Pindah { x: 10, y: 20 },
        Pesan::Tulis(String::from("Halo")),
        Pesan::GantiWarna(255, 128, 0),
        Pesan::Keluar,
    ];

    for pesan in &pesan_list {
        pesan.proses();
    }
}

// Option<T> — nilai yang mungkin ada atau tidak ada
// enum Option<T> {
//     Some(T),
//     None,
// }

fn cari_elemen(koleksi: &[i32], target: i32) -> Option<usize> {
    for (i, &val) in koleksi.iter().enumerate() {
        if val == target {
            return Some(i);
        }
    }
    None
}

// Result<T, E> — operasi yang bisa berhasil atau gagal
// enum Result<T, E> {
//     Ok(T),
//     Err(E),
// }

fn bagi(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err(String::from("Tidak bisa membagi dengan nol"))
    } else {
        Ok(a / b)
    }
}

fn main() {
    let data = [3, 7, 1, 9, 4];

    // Menangani Option
    match cari_elemen(&data, 9) {
        Some(indeks) => println!("Ditemukan di indeks {}", indeks),
        None => println!("Tidak ditemukan"),
    }

    // Cara ringkas dengan if let
    if let Some(idx) = cari_elemen(&data, 7) {
        println!("7 ada di indeks {}", idx);
    }

    // Menangani Result
    match bagi(10.0, 3.0) {
        Ok(hasil) => println!("Hasil: {:.4}", hasil),
        Err(e) => println!("Error: {}", e),
    }

    // Operator ? — propagasi error secara otomatis (dalam fungsi yang return Result)
    // Dibahas lebih detail di artikel Error Handling
}

// Definisi trait
trait Deskripsi {
    // Method yang harus diimplementasikan
    fn deskripsikan(&self) -> String;

    // Method dengan implementasi default — bisa di-override
    fn cetak(&self) {
        println!("{}", self.deskripsikan());
    }
}

struct Pengguna {
    nama: String,
    email: String,
}

struct Produk {
    nama: String,
    harga: f64,
}

// Implementasi trait untuk Pengguna
impl Deskripsi for Pengguna {
    fn deskripsikan(&self) -> String {
        format!("Pengguna: {} ({})", self.nama, self.email)
    }
}

// Implementasi trait untuk Produk
impl Deskripsi for Produk {
    fn deskripsikan(&self) -> String {
        format!("Produk: {} — Rp{:.0}", self.nama, self.harga)
    }

    // Override implementasi default
    fn cetak(&self) {
        println!("=== {} ===", self.deskripsikan());
    }
}

// Trait sebagai parameter fungsi — generic dengan trait bound
fn tampilkan<T: Deskripsi>(item: &T) {
    item.cetak();
}

fn main() {
    let user = Pengguna {
        nama: String::from("Budi"),
        email: String::from("[email protected]"),
    };

    let produk = Produk {
        nama: String::from("Laptop"),
        harga: 15_000_000.0,
    };

    tampilkan(&user);
    tampilkan(&produk);
}

fn main() {
    // String dialokasikan di heap — ownership bisa dipindah
    let s1 = String::from("halo");
    let s2 = s1; // MOVE: s1 tidak bisa digunakan lagi

    // ANTI-PATTERN: menggunakan variabel setelah di-move
    // println!("{}", s1); // error[E0382]: borrow of moved value: `s1`

    // BENAR: gunakan s2 atau clone s1 sebelum di-move
    println!("{}", s2);

    let s3 = String::from("dunia");
    let s4 = s3.clone(); // clone: buat salinan, keduanya valid
    println!("{} dan {}", s3, s4);

    // Tipe Copy (integer, float, bool, char) tidak di-move — selalu di-copy
    let x = 5;
    let y = x;           // copy, bukan move
    println!("{} {}", x, y); // keduanya valid
}

fn hitung_panjang(s: &String) -> usize { // &String = borrow, bukan take ownership
    s.len()
} // s keluar scope, tapi tidak di-drop karena hanya borrowed

fn tambahkan_kata(s: &mut String) { // &mut = mutable borrow
    s.push_str(", dunia");
}

fn main() {
    let s = String::from("halo");

    // Borrow immutable — s masih valid setelah pemanggilan
    let panjang = hitung_panjang(&s);
    println!("Panjang '{}' adalah {}", s, panjang);

    let mut s2 = String::from("halo");
    tambahkan_kata(&mut s2);
    println!("{}", s2); // "halo, dunia"

    // ANTI-PATTERN: lebih dari satu mutable borrow bersamaan
    let mut s3 = String::from("test");
    let r1 = &mut s3;
    // let r2 = &mut s3; // error: tidak bisa borrow s3 sebagai mutable lebih dari sekali
    println!("{}", r1);
}

// Tanpa anotasi lifetime, compiler tidak bisa tahu
// apakah return value mengacu ke x atau y
// Anotasi 'a berarti: return value punya lifetime minimal sepanjang x dan y
fn terpanjang<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

fn main() {
    let string1 = String::from("string panjang");
    let hasil;
    {
        let string2 = String::from("xyz");
        hasil = terpanjang(string1.as_str(), string2.as_str());
        println!("String terpanjang: {}", hasil); // ✓ valid di sini
    }
    // println!("{}", hasil); // error — string2 sudah tidak valid
}

// Modul bisa didefinisikan inline atau di file terpisah
mod geometri {
    // Private secara default — hanya bisa diakses di dalam modul ini
    fn luas_internal(lebar: f64, tinggi: f64) -> f64 {
        lebar * tinggi
    }

    // pub — bisa diakses dari luar modul
    pub struct Persegi {
        pub lebar: f64,   // field pub — bisa diakses dari luar
        tinggi: f64,      // field private — tidak bisa diakses dari luar
    }

    impl Persegi {
        pub fn baru(lebar: f64, tinggi: f64) -> Self {
            Persegi { lebar, tinggi }
        }

        pub fn luas(&self) -> f64 {
            luas_internal(self.lebar, self.tinggi) // boleh akses fungsi private di modul yang sama
        }
    }

    pub mod lingkaran {
        pub fn luas(radius: f64) -> f64 {
            std::f64::consts::PI * radius * radius
        }
    }
}

fn main() {
    // use untuk mempersingkat path
    use geometri::Persegi;
    use geometri::lingkaran;

    let p = Persegi::baru(10.0, 5.0);
    println!("Luas persegi: {}", p.luas());
    println!("Lebar: {}", p.lebar); // ✓ field pub
    // println!("{}", p.tinggi);    // ✗ error: field private

    println!("Luas lingkaran r=7: {:.2}", lingkaran::luas(7.0));
}