Core Syntax #

// This is the simplest runnable Rust program

fn main() {
    // println! is a macro, not an ordinary function
    // The exclamation mark (!) distinguishes a macro from a function call
    println!("Hello, Rust!");

    // Variables are declared with let
    let angka = 42;
    let pesan = "The value is";

    // Format strings use {} as placeholders
    println!("{}: {}", pesan, angka);
}

// Single-line comment — ignored by the compiler

/*
   Block comment — can span
   multiple lines at once
*/

/// Documentation comment for the item below it (function, struct, etc.)
/// Supports Markdown syntax and is processed by rustdoc.
///
/// # Examples
///
/// ```
/// let hasil = tambah(2, 3);
/// assert_eq!(hasil, 5);
/// ```
fn tambah(a: i32, b: i32) -> i32 {
    a + b
}

//! Documentation comment for the module or crate itself
//! Usually lives on the first line of a lib.rs or main.rs file

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

    // CORRECT: declare mut if you really need to change it
    let mut y = 5;
    y = 6; // ✓ valid
    println!("y = {}", y);
}

fn main() {
    let angka = 5;

    // Shadowing: create a new variable with the same name
    let angka = angka + 1;       // angka = 6

    // Shadowing can even change the type
    let angka = angka.to_string(); // now angka is a String, not an i32

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

    // ANTI-PATTERN: using mut to "change the type"
    // let mut nilai = 5;
    // nilai = "lima"; // error — you can't change the type of a mut variable
}

// Constants use SCREAMING_SNAKE_CASE
const KECEPATAN_CAHAYA: u64 = 299_792_458; // m/s

// Underscores can be used as digit separators for readability
const POPULASI_BUMI: u64 = 8_000_000_000;

fn main() {
    println!("Speed of light: {} m/s", KECEPATAN_CAHAYA);
}

fn main() {
    // Integers — use a suffix for an explicit type
    let a: i32 = -42;
    let b = 1_000_000u64;    // u64 suffix, underscore for readability
    let c = 0xFF;            // hexadecimal
    let d = 0b1111_0000;     // binary
    let e = 0o77;            // octal

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

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

    // Char — use single quotes, not double quotes
    let huruf = 'A';
    let emoji = '🦀'; // Rust char supports all of Unicode
    let karakter_cina = '中';

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

fn main() {
    // Tuple: a collection of values that can have different types
    let koordinat: (f64, f64, f64) = (1.0, 2.5, -0.3);

    // Access via index
    let x = koordinat.0;
    let y = koordinat.1;

    // Destructuring — the more idiomatic way
    let (px, py, pz) = koordinat;
    println!("Position: {}, {}, {}", px, py, pz);

    // Array: a collection of values with the SAME type and FIXED length
    let angka: [i32; 5] = [1, 2, 3, 4, 5];
    let semua_nol = [0; 10]; // 10 elements, all zero

    // Access via index
    println!("First element: {}", angka[0]);
    println!("Array length: {}", angka.len());

    // ANTI-PATTERN: accessing an index out of bounds
    // let x = angka[10]; // runtime panic: index out of bounds
}

fn main() {
    let suhu = 28;

    // if as an ordinary statement
    if suhu > 30 {
        println!("Hot");
    } else if suhu > 20 {
        println!("Comfortable");
    } else {
        println!("Cold");
    }

    // CORRECT: if as an expression — returns a value
    let kondisi = if suhu > 30 { "panas" } else { "sejuk" };
    println!("Weather: {}", kondisi);

    // ANTI-PATTERN: every branch must have the same type
    // let kondisi = if suhu > 30 { "panas" } else { 0 };
    // error: `if` and `else` have incompatible types
}

fn main() {
    let angka = 7;

    // ANTI-PATTERN: chained if-else for pattern matching
    // if angka == 1 { ... } else if angka == 2 { ... } — verbose and not exhaustive

    // CORRECT: use match
    match angka {
        1 => println!("One"),
        2 | 3 => println!("Two or Three"),      // multiple patterns
        4..=6 => println!("Four to Six"),   // range pattern
        n if n > 6 => println!("Greater than 6: {}", n), // guard condition
        _ => println!("Something else"),                  // wildcard — required if not exhaustive
    }

    // match can also return a value
    let deskripsi = match angka {
        1..=3 => "kecil",
        4..=6 => "sedang",
        _ => "besar",
    };
    println!("Number {}: {}", angka, deskripsi);
}

fn main() {
    // loop — an unbounded loop, stopped with break
    // Can return a value via break
    let mut counter = 0;
    let hasil = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2; // return a value from the loop
        }
    };
    println!("Loop result: {}", hasil); // 20

    // while — loops while the condition is true
    let mut n = 0;
    while n < 5 {
        print!("{} ", n);
        n += 1;
    }
    println!();

    // for — the most idiomatic way to iterate over collections
    let koleksi = [10, 20, 30, 40, 50];
    for elemen in koleksi {
        print!("{} ", elemen);
    }
    println!();

    // Ranges: 0..5 (exclusive), 0..=5 (inclusive)
    for i in 0..5 {
        print!("{} ", i); // 0 1 2 3 4
    }
    println!();

    // Enumerate to get the index and value at the same time
    for (indeks, nilai) in koleksi.iter().enumerate() {
        println!("[{}] = {}", indeks, nilai);
    }
}

// Function without a return value (return type () — the unit type)
fn sapa(nama: &str) {
    println!("Hello, {}!", nama);
}

// Function with a return value — the type after ->
fn tambah(a: i32, b: i32) -> i32 {
    // CORRECT: an expression without a semicolon is the implicit return value
    a + b
}

// ANTI-PATTERN: using explicit return for a case that isn't an early return
fn kurang(a: i32, b: i32) -> i32 {
    return a - b; // redundant for a simple case
}

// CORRECT: explicit return is only for early returns
fn pembagian_aman(a: i32, b: i32) -> Option<i32> {
    if b == 0 {
        return None; // early return — explicit return makes sense here
    }
    Some(a / b) // implicit return at the end of the function
}

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

    match pembagian_aman(10, 0) {
        Some(hasil) => println!("Result: {}", hasil),
        None => println!("Cannot divide by zero"),
    }
}

fn main() {
    let pengali = 3;

    // The closure captures `pengali` from the outer scope
    let kalikan = |x: i32| x * pengali;

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

    // Closures are often used with 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!("Even: {:?}", genap);           // [2, 4]
    println!("Squares: {:?}", dikuadratkan);  // [1, 4, 9, 16, 25]
}

// Struct definition
struct Persegi {
    lebar: u32,
    tinggi: u32,
}

// Implementing methods for the struct with an impl block
impl Persegi {
    // Associated function (not a method) — no self parameter
    // Usually used as a constructor
    fn baru(lebar: u32, tinggi: u32) -> Persegi {
        Persegi { lebar, tinggi } // field shorthand when names match the variables
    }

    // Method — the first parameter is always &self, &mut self, or 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!("Area: {}", p.luas());       // 50
    println!("Perimeter: {}", p.keliling()); // 30

    p.perbesar(2);
    println!("After scaling — Area: {}", p.luas()); // 200

    // Struct update syntax — copy fields from another struct
    let p2 = Persegi { lebar: 20, ..p };
    println!("p2 — Width: {}, Height: {}", p2.lebar, p2.tinggi); // 20, 10
}

// Enum with various kinds of variants
enum Pesan {
    Keluar,                          // variant without data
    Pindah { x: i32, y: i32 },      // variant with named fields
    Tulis(String),                   // variant with a single value
    GantiWarna(u8, u8, u8),         // variant with multiple values
}

impl Pesan {
    fn proses(&self) {
        match self {
            Pesan::Keluar => println!("Program exiting"),
            Pesan::Pindah { x, y } => println!("Move to ({}, {})", x, y),
            Pesan::Tulis(teks) => println!("Writing: {}", teks),
            Pesan::GantiWarna(r, g, b) => println!("Color: #{:02X}{:02X}{:02X}", r, g, b),
        }
    }
}

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

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

// Option<T> — a value that may or may not exist
// 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> — an operation that can succeed or fail
// enum Result<T, E> {
//     Ok(T),
//     Err(E),
// }

fn bagi(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err(String::from("Cannot divide by zero"))
    } else {
        Ok(a / b)
    }
}

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

    // Handling Option
    match cari_elemen(&data, 9) {
        Some(indeks) => println!("Found at index {}", indeks),
        None => println!("Not found"),
    }

    // The concise way with if let
    if let Some(idx) = cari_elemen(&data, 7) {
        println!("7 is at index {}", idx);
    }

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

    // The ? operator — automatic error propagation (inside functions that return Result)
    // Covered in more detail in the Error Handling article
}

// Trait definition
trait Deskripsi {
    // Method that must be implemented
    fn deskripsikan(&self) -> String;

    // Method with a default implementation — can be overridden
    fn cetak(&self) {
        println!("{}", self.deskripsikan());
    }
}

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

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

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

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

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

// Trait as a function parameter — generic with a 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() {
    // A String is allocated on the heap — ownership can be transferred
    let s1 = String::from("halo");
    let s2 = s1; // MOVE: s1 can no longer be used

    // ANTI-PATTERN: using a variable after it's been moved
    // println!("{}", s1); // error[E0382]: borrow of moved value: `s1`

    // CORRECT: use s2, or clone s1 before the move
    println!("{}", s2);

    let s3 = String::from("dunia");
    let s4 = s3.clone(); // clone: make a copy, both are valid
    println!("{} and {}", s3, s4);

    // Copy types (integers, floats, bool, char) are not moved — always copied
    let x = 5;
    let y = x;           // copy, not move
    println!("{} {}", x, y); // both are valid
}

fn hitung_panjang(s: &String) -> usize { // &String = borrow, not take ownership
    s.len()
} // s leaves scope, but isn't dropped because it was only borrowed

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

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

    // Immutable borrow — s is still valid after the call
    let panjang = hitung_panjang(&s);
    println!("Length of '{}' is {}", s, panjang);

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

    // ANTI-PATTERN: more than one mutable borrow at the same time
    let mut s3 = String::from("test");
    let r1 = &mut s3;
    // let r2 = &mut s3; // error: cannot borrow s3 as mutable more than once
    println!("{}", r1);
}

// Without a lifetime annotation, the compiler can't know
// whether the return value refers to x or y
// The 'a annotation means: the return value has a lifetime at least as long as x and 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("a long string");
    let hasil;
    {
        let string2 = String::from("xyz");
        hasil = terpanjang(string1.as_str(), string2.as_str());
        println!("Longest string: {}", hasil); // ✓ valid here
    }
    // println!("{}", hasil); // error — string2 is no longer valid
}

// Modules can be defined inline or in separate files
mod geometri {
    // Private by default — only accessible inside this module
    fn luas_internal(lebar: f64, tinggi: f64) -> f64 {
        lebar * tinggi
    }

    // pub — accessible from outside the module
    pub struct Persegi {
        pub lebar: f64,   // pub field — accessible from outside
        tinggi: f64,      // private field — not accessible from outside
    }

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

        pub fn luas(&self) -> f64 {
            luas_internal(self.lebar, self.tinggi) // allowed to access private functions in the same module
        }
    }

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

fn main() {
    // use to shorten paths
    use geometri::Persegi;
    use geometri::lingkaran;

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

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