🦀 Rust untuk Pemula: Panduan Lengkap

# Instal Rust menggunakan rustup
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Ikuti instruksi di layar, pilih opsi 1 (default installation)

# Muat ulang environment
source $HOME/.cargo/env

# Verifikasi instalasi
rustc --version
# Output: rustc 1.78.0 (9b00956e5 2024-04-29)

cargo --version
# Output: cargo 1.78.0 (54d8815d0 2024-03-26)

# 1. Download rustup-init.exe dari https://rustup.rs
# 2. Jalankan rustup-init.exe
# 3. Ikuti instruksi instalasi (pilih opsi 1)
# 4. Pastikan Visual Studio C++ Build Tools terinstal

# Verifikasi di Command Prompt atau PowerShell:
rustc --version
# Output: rustc 1.78.0 (9b00956e5 2024-04-29)

cargo --version
# Output: cargo 1.78.0 (54d8815d0 2024-03-26)

# Update Rust ke versi terbaru:
rustup update

// File: hello.rs
fn main() {
    println!("Halo, dunia!");
    println!("Selamat datang di Rust!");
    println!("Nama saya: BeebaneLabs");
}

// Kompilasi dan jalankan dari terminal:
// rustc hello.rs
// ./hello
//
// Output:
// Halo, dunia!
// Selamat datang di Rust!
// Nama saya: BeebaneLabs

# Buat proyek baru dengan Cargo
cargo new hello_rust
cd hello_rust

# Struktur proyek yang dihasilkan:
# hello_rust/
# ├── Cargo.toml    (konfigurasi proyek)
# └── src/
#     └── main.rs   (kode utama)

# Kompilasi dan jalankan
cargo run

# Hanya kompile tanpa menjalankan
cargo build

# Kompilasi dengan optimasi (release mode)
cargo build --release

# Cek apakah kode bisa dikompile tanpa error
cargo check

# Jalankan unit test
cargo test

# Generate dan buka dokumentasi
cargo doc --open

[package]
name = "hello_rust"
version = "0.1.0"
edition = "2021"

[dependencies]
# Tambahkan library dari crates.io di sini
# contoh: serde = "1.0"
# contoh: tokio = { version = "1", features = ["full"] }

fn main() {
    // Variabel immutable (default, tidak bisa diubah)
    let nama = "Budi Santoso";
    let umur = 25;
    println!("Nama: {}, Umur: {}", nama, umur);

    // Variabel mutable (bisa diubah nilainya)
    let mut skor = 100;
    println!("Skor awal: {}", skor);   // 100
    skor = 150;
    println!("Skor baru: {}", skor);   // 150

    // Shadowing — mendeklarasi ulang variabel dengan nama sama
    let x = 5;
    let x = x + 1;        // x sekarang = 6
    let x = x * 2;        // x sekarang = 12
    println!("x = {}", x); // 12

    // Shadowing bisa mengubah tipe data
    let angka = "42";              // string
    let angka: i32 = angka.parse().unwrap();  // integer
    println!("angka = {}", angka); // 42

    // Deklarasi dengan tipe eksplisit
    let tinggi: f64 = 175.5;
    let aktif: bool = true;
    let huruf: char = 'R';

    println!("Tinggi: {}, Aktif: {}, Huruf: {}", tinggi, aktif, huruf);

    // Konstanta — selalu immutable, harus tipe eksplisit
    const PI: f64 = 3.14159265358979;
    const MAKS_PESERTA: u32 = 100;
    println!("PI = {}, Maks peserta = {}", PI, MAKS_PESERTA);
}

fn main() {
    // &str — string slice (immutable reference, fixed size)
    let s1: &str = "Hello, Rust!";

    // String — owned, bisa dimodifikasi
    let mut s2: String = String::from("Hello");
    s2.push_str(", World!");
    println!("{}", s2); // Hello, World!

    // Konversi &str → String
    let s3: String = "hello".to_string();
    let s4: String = String::from("hello");

    // Konversi String → &str (dereference)
    let s5: &str = &s3;
    let s6: &str = s3.as_str();

    // Format string
    let nama = "Budi";
    let umur = 25;
    let pesan = format!("Nama: {}, Umur: {}", nama, umur);
    println!("{}", pesan);

    // Multi-line string
    let teks = "\
Baris pertama
Baris kedua
Baris ketiga";
    println!("{}", teks);
}

fn main() {
    // Tuple — kumpulan nilai dengan tipe berbeda
    let data: (i32, f64, &str) = (42, 3.14, "Rust");
    println!("Integer: {}, Float: {}, String: {}", data.0, data.1, data.2);

    // Destructuring tuple
    let (angka, desimal, teks) = data;
    println!("angka={}, desimal={}, teks={}", angka, desimal, teks);

    // Array — kumpulan nilai dengan tipe sama, ukuran tetap
    let angka = [1, 2, 3, 4, 5];
    println!("Elemen pertama: {}", angka[0]); // 1
    println!("Elemen terakhir: {}", angka[4]); // 5

    // Array dengan inisialisasi
    let nol = [0; 5]; // [0, 0, 0, 0, 0]
    println!("Array nol: {:?}", nol);

    // Panjang array
    println!("Panjang: {}", angka.len()); // 5

    // Iterasi array
    for item in angka.iter() {
        print!("{} ", item);
    }
    println!();
}

// Fungsi tanpa return value
fn sapa(nama: &str) {
    println!("Halo, {}! Selamat datang di Rust!", nama);
}

// Fungsi dengan return value (ekspresi terakhir tanpa semikolon)
fn tambah(a: i32, b: i32) -> i32 {
    a + b  // tanpa semikolon = return value
}

// Fungsi dengan return eksplisit
fn kali(a: i32, b: i32) -> i32 {
    return a * b;  // return eksplisit (kurang idiomatic)
}

// Fungsi dengan multiple return (menggunakan tuple)
fn bagi(a: f64, b: f64) -> (f64, f64) {
    let hasil = a / b;
    let sisa = a % b;
    (hasil, sisa)
}

fn main() {
    sapa("Budi");

    let hasil = tambah(10, 20);
    println!("10 + 20 = {}", hasil);

    let hasil_kali = kali(5, 6);
    println!("5 × 6 = {}", hasil_kali);

    let (hasil_bagi, sisa) = bagi(17.0, 5.0);
    println!("17 / 5 = {} sisa {}", hasil_bagi, sisa);
}

fn main() {
    // if-else
    let umur = 20;
    if umur >= 17 {
        println!("Dewasa");
    } else if umur >= 13 {
        println!("Remaja");
    } else {
        println!("Anak-anak");
    }

    // if sebagai ekspresi (bisa menghasilkan nilai)
    let status = if umur >= 18 { "Dewasa" } else { "Belum dewasa" };
    println!("Status: {}", status);

    // match — pattern matching (switch yang powerful)
    let hari = 3;
    let nama_hari = match hari {
        1 => "Senin",
        2 => "Selasa",
        3 => "Rabu",
        4 => "Kamis",
        5 => "Jumat",
        6 => "Sabtu",
        7 => "Minggu",
        _ => "Tidak valid",  // _ menangkap semua kemungkinan lain
    };
    println!("Hari ke-{} adalah {}", hari, nama_hari);

    // match dengan range
    let nilai = 85;
    let grade = match nilai {
        90..=100 => "A",
        80..=89 => "B",
        70..=79 => "C",
        60..=69 => "D",
        _ => "E",
    };
    println!("Nilai {} → Grade {}", nilai, grade);
}

fn main() {
    // loop — infinite loop
    let mut counter = 0;
    let hasil = loop {
        counter += 1;
        if counter == 5 {
            break counter * 2;  // break bisa mengembalikan nilai
        }
    };
    println!("Hasil loop: {}", hasil); // 10

    // while loop
    let mut angka = 5;
    while angka > 0 {
        print!("{}... ", angka);
        angka -= 1;
    }
    println!("Liftoff! 🚀");

    // for loop (paling sering digunakan)
    for i in 1..=5 {
        print!("{} ", i);
    }
    println!(); // 1 2 3 4 5

    // Iterasi dengan enumerate
    let buah = ["apel", "mangga", "jeruk"];
    for (index, item) in buah.iter().enumerate() {
        println!("{}. {}", index + 1, item);
    }

    // Iterasi collection
    let angka = vec![10, 20, 30, 40, 50];
    let total: i32 = angka.iter().sum();
    println!("Total: {}", total); // 150
}

fn main() {
    // String di-allocate di heap, s1 adalah owner
    let s1 = String::from("Hello");

    // MOVE: ownership dipindahkan dari s1 ke s2
    let s2 = s1;
    // println!("{}", s1);  // ERROR! s1 sudah tidak valid

    println!("s2 = {}", s2); // OK, s2 adalah owner baru

    // CLONE: membuat deep copy (keduanya valid)
    let s3 = s2.clone();
    println!("s2 = {}, s3 = {}", s2, s3); // Keduanya valid

    // Tipe data yang disimpan di stack (Copy trait) tidak berpindah
    let x = 5;
    let y = x;  // COPY, bukan move
    println!("x = {}, y = {}", x, y); // Keduanya valid!

    // Ownership dan fungsi
    let nama = String::from("Budi");
    cetak_nama(nama);          // ownership dipindahkan ke fungsi
    // println!("{}", nama);   // ERROR! nama sudah tidak valid

    // Fungsi yang mengembalikan ownership
    let nama2 = String::from("Ani");
    let nama2 = ambil_dan_kembalikan(nama2);
    println!("Nama2: {}", nama2); // OK, ownership dikembalikan
}

fn cetak_nama(nama: String) {
    println!("Nama: {}", nama);
} // nama di-drop di sini

fn ambil_dan_kembalikan(nama: String) -> String {
    println!("Memproses: {}", nama);
    nama  // kembalikan ownership
}

// Fungsi yang meminjam string (tidak mengambil ownership)
fn hitung_panjang(s: &str) -> usize {
    s.len()
} // s di-drop di sini, tapi ownership tetap di pemanggil

fn main() {
    let s = String::from("Hello, Rust!");

    // &s membuat reference ke s, ownership TIDAK berpindah
    let panjang = hitung_panjang(&s);

    println!("\"{}\" panjangnya {} karakter", s, panjang); // OK!

    // Multiple immutable references — diizinkan!
    let r1 = &s;
    let r2 = &s;
    println!("r1={}, r2={}", r1, r2); // OK
}

fn tambah_excl(s: &mut String) {
    s.push_str("!");
}

fn main() {
    let mut pesan = String::from("Halo");

    // Mutable reference — bisa mengubah data asli
    tambah_excl(&mut pesan);
    println!("{}", pesan); // Halo!

    // Aturan: hanya SATU mutable reference pada satu waktu
    let r1 = &mut pesan;
    // let r2 = &mut pesan;  // ERROR! Tidak bisa dua mutable ref

    r1.push_str(" Dunia");
    println!("{}", r1); // Halo! Dunia

    // Tidak bisa gabungkan mutable dan immutable reference
    // pada scope yang sama
    let mut data = String::from("test");
    let r_immut = &data;
    // let r_mut = &mut data;  // ERROR!
    println!("{}", r_immut);
    // Setelah r_immut selesai digunakan, baru bisa mutable:
    let r_mut = &mut data;
    r_mut.push_str(" ok");
    println!("{}", r_mut);
}

// Mendefinisikan struct
struct Mahasiswa {
    nama: String,
    umur: u32,
    ipk: f64,
    aktif: bool,
}

// Struct dengan method (implementasi)
impl Mahasiswa {
    // Constructor (associated function)
    fn baru(nama: &str, umur: u32) -> Self {
        Mahasiswa {
            nama: String::from(nama),
            umur,
            ipk: 0.0,
            aktif: true,
        }
    }

    // Method (mengambil &self)
    fn tampilkan(&self) {
        println!("{} ({} tahun, IPK: {:.2})", self.nama, self.umur, self.ipk);
    }

    // Method mutable (mengambil &mut self)
    fn tambah_ipk(&mut self, nilai: f64) {
        self.ipk = (self.ipk + nilai) / 2.0;
    }

    // Method yang mengambil ownership (jarang digunakan)
    fn lulus(self) -> String {
        format!("{} telah lulus!", self.nama)
    }
}

fn main() {
    // Membuat instance struct
    let mhs1 = Mahasiswa {
        nama: String::from("Budi"),
        umur: 21,
        ipk: 3.75,
        aktif: true,
    };

    println!("Nama: {}", mhs1.nama);
    println!("Umur: {}", mhs1.umur);

    // Mutable struct
    let mut mhs2 = Mahasiswa::baru("Ani", 20);
    mhs2.tambah_ipk(3.5);
    mhs2.tampilkan();

    // Struct update syntax
    let mhs3 = Mahasiswa {
        nama: String::from("Citra"),
        ipk: 3.90,
        ..mhs2  // sisanya dari mhs2
    };
    mhs3.tampilkan();

    // Tuple struct
    struct Warna(u8, u8, u8);
    let merah = Warna(255, 0, 0);
    println!("Warna: ({}, {}, {})", merah.0, merah.1, merah.2);

    // Unit struct
    struct Marker;
}

// Enum sederhana
enum Arah {
    Utara,
    Selatan,
    Timur,
    Barat,
}

// Enum dengan data
enum Pesan {
    Keluar,                                  // tanpa data
    Teks(String),                            // satu String
    Pindah { x: i32, y: i32 },              // named fields
    Warna(u8, u8, u8),                      // tuple fields
}

// Enum dengan method
impl Pesan {
    fn proses(&self) {
        match self {
            Pesan::Keluar => println!("Keluar dari aplikasi"),
            Pesan::Teks(teks) => println!("Pesan: {}", teks),
            Pesan::Pindah { x, y } => println!("Pindah ke ({}, {})", x, y),
            Pesan::Warna(r, g, b) => println!("Warna: #{:02X}{:02X}{:02X}", r, g, b),
        }
    }
}

fn main() {
    let arah = Arah::Utara;
    match arah {
        Arah::Utara => println!("Ke Utara ⬆"),
        Arah::Selatan => println!("Ke Selatan ⬇"),
        Arah::Timur => println!("Ke Timur ➡"),
        Arah::Barat => println!("Ke Barat ⬅"),
    }

    // Menggunakan enum dengan data
    let msg1 = Pesan::Teks(String::from("Halo Dunia"));
    let msg2 = Pesan::Pindah { x: 10, y: 20 };
    let msg3 = Pesan::Warna(255, 128, 0);

    msg1.proses(); // Pesan: Halo Dunia
    msg2.proses(); // Pindah ke (10, 20)
    msg3.proses(); // Warna: FF8000
}

// Option sudah built-in di Rust:
// enum Option<T> {
//     Some(T),
//     None,
// }

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

fn main() {
    let angka = vec![10, 20, 30, 40, 50];

    // Menggunakan match dengan Option
    match cari_index(&angka, 30) {
        Some(idx) => println!("Ditemukan di index {}", idx),
        None => println!("Tidak ditemukan"),
    }

    // if let — shorthand untuk match satu case
    if let Some(idx) = cari_index(&angka, 40) {
        println!("Index 40: {}", idx);
    }

    // unwrap_or — nilai default jika None
    let idx = cari_index(&angka, 99).unwrap_or(0);
    println!("Index: {}", idx); // 0

    // map — transformasi nilai di dalam Option
    let hasil = cari_index(&angka, 30).map(|i| i * 10);
    println!("Hasil: {:?}", hasil); // Some(200)
}

fn main() {
    // Membuat vector
    let mut angka: Vec<i32> = Vec::new();
    angka.push(10);
    angka.push(20);
    angka.push(30);

    // Vec dengan macro
    let buah = vec!["apel", "mangga", "jeruk"];

    // Akses elemen
    println!("Buah pertama: {}", buah[0]); // apel

    // Akses aman dengan get (mengembalikan Option)
    match buah.get(5) {
        Some(item) => println!("Ada: {}", item),
        None => println!("Index tidak valid"),
    }

    // Iterasi
    for item in &buah {
        print!("{} ", item);
    }
    println!();

    // Iterasi mutable
    let mut skor = vec![80, 90, 70];
    for item in &mut skor {
        *item += 5; // tambah 5 ke setiap skor
    }
    println!("Skor: {:?}", skor); // [85, 95, 75]

    // Method berguna
    println!("Panjang: {}", angka.len());
    println!("Kosong? {}", angka.is_empty());
    println!("Contains 20? {}", angka.contains(&20));

    // Filter dan collect
    let besar: Vec<&i32> = angka.iter().filter(|&&x| x > 15).collect();
    println!("> 15: {:?}", besar); // [20, 30]
}

use std::collections::HashMap;

fn main() {
    // Membuat HashMap
    let mut nilai: HashMap<&str, i32> = HashMap::new();

    // Insert data
    nilai.insert("Matematika", 85);
    nilai.insert("Fisika", 90);
    nilai.insert("Kimia", 78);

    // Akses data
    if let Some(n) = nilai.get("Matematika") {
        println!("Nilai Matematika: {}", n);
    }

    // Iterasi
    for (mapel, n) in &nilai {
        println!("{}: {}", mapel, n);
    }

    // Update: overwrite jika sudah ada
    nilai.insert("Matematika", 95);

    // Entry API: insert jika belum ada
    nilai.entry("Biologi").or_insert(88);
    nilai.entry("Matematika").or_insert(50); // tidak berubah

    // Counter pattern
    let teks = "halo halo dunia halo";
    let mut hitungan: HashMap<&str, i32> = HashMap::new();
    for kata in teks.split_whitespace() {
        let count = hitungan.entry(kata).or_insert(0);
        *count += 1;
    }
    println!("Hitungan kata: {:?}", hitungan);
}

use std::fs;
use std::num::ParseIntError;

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

// Fungsi dengan ? operator (propagate error)
fn baca_angka_dari_file(path: &str) -> Result<i32, Box<dyn std::error::Error>> {
    let konten = fs::read_to_string(path)?;  // ? propagates error
    let angka: i32 = konten.trim().parse()?; // ? propagates error
    Ok(angka)
}

fn main() {
    // Menggunakan Result dengan match
    match bagi(10.0, 3.0) {
        Ok(hasil) => println!("10 / 3 = {:.2}", hasil),
        Err(e) => println!("Error: {}", e),
    }

    match bagi(10.0, 0.0) {
        Ok(hasil) => println!("Hasil: {}", hasil),
        Err(e) => println!("Error: {}", e),
    }

    // unwrap — langsung ambil nilai, panic jika Err
    let hasil = bagi(10.0, 2.0).unwrap(); // OK: 5.0
    // let gagal = bagi(10.0, 0.0).unwrap(); // PANIC!

    // unwrap_or — nilai default
    let hasil = bagi(10.0, 0.0).unwrap_or(0.0);
    println!("Hasil: {}", hasil); // 0.0

    // expect — panic dengan pesan custom
    let hasil = bagi(10.0, 2.0).expect("Pembagian gagal");

    // unwrap_or_else — fallback dengan closure
    let hasil = bagi(10.0, 0.0).unwrap_or_else(|e| {
        println!("Warning: {}", e);
        0.0
    });
    println!("Hasil: {}", hasil);
}