Memahami Fungsi dalam Konteks Rust

Dalam Rust, fungsi adalah unit paling dasar untuk mengelompokkan logika yang bisa dipanggil berulang kali. Fungsi membantu menjaga kode tetap terstruktur dan reusable. Ketika menulis fungsi, Anda harus menentukan nama, daftar parameter, tipe data parameter (jika ada), serta apa yang dikembalikan. Karena Rust adalah bahasa yang statis dan terkompilasi, setiap elemen itu harus jelas agar compiler bisa memastikan keamanan memori dan tipe.

Mari mulai dengan struktur dasar:

fn nama_fungsi(parameter1: Tipe1, parameter2: Tipe2) -> TipeBalik {
    // badan fungsi
}

Pada contoh ini, parameter1 dan parameter2 menerima nilai dengan tipe masing-masing, lalu fungsi mengembalikan TipeBalik. Bila tidak mengembalikan nilai, cukup lewati bagian -> TipeBalik dan Rust akan menganggap fungsi mengembalikan unit (()).

Menentukan Parameter dan Tipe

Parameter adalah input yang membuat fungsi fleksibel. Rust mengharuskan Anda mendefinisikan tipe parameter agar lebih aman. Misalnya:

fn sapa(nama: &str) {
    println!("Halo, {}!", nama);
}

Parameter nama bertipe &str, menunjukkan bahwa fungsi menerima referensi string slice yang dipinjam. Menggunakan referensi membantu menghindari copy data besar pada heap.

Selain tipe primitif, parameter bisa berupa struktur data sendiri atau bahkan generic jika Anda ingin fungsi berlaku untuk berbagai tipe:

fn cetak(nilai: T) {
    println!("Nilai: {}", nilai);
}

Di atas, trait bound std::fmt::Display menjamin bahwa tipe yang diteruskan bisa dicetak. Pendekatan ini menggabungkan fleksibilitas tanpa mengorbankan kejelasan tipe.

Nilai Balik dan Perbedaan Ekspresi vs Statement

Rust memperlakukan hampir semua hal sebagai ekspresi kecuali beberapa construct spesifik. Ekspresi menghasilkan nilai, sementara statement melakukan sesuatu tanpa menghasilkan nilai (seperti deklarasi variabel). Perhatikan contoh:

let x = 5; // statement
let y = {
    let z = 2; // statement
    z + 3      // ekspresi, menghasilkan nilai 5
};

fn tambah(a: i32, b: i32) -> i32 {
    a + b // ekspresi terakhir tanpa titik koma menjadi nilai balik
}

Perhatikan kalau ekspresi terakhir dalam blok tidak diakhiri titik koma, maka nilai ekspresi tersebut akan menjadi nilai blok. Hal ini memudahkan menulis fungsi yang bersih tanpa return eksplisit.

Contoh fungsi berikut menjelaskan penulisan nilai balik:

fn jumlah(a: i32, b: i32) -> i32 {
    println!("Menjumlahkan {} dan {}", a, b);
    a + b // nilai balik ekspresif
}

Jika Anda menambahkan titik koma di akhir a + b;, fungsi akan mengembalikan unit dan itu bukan yang Anda inginkan.

Contoh Fungsi Penjumlahan dan Salam

Berikut dua fungsi sederhana tapi representatif: satu menangani penjumlahan, satunya menyapa pengguna.

fn tambah(a: i32, b: i32) -> i32 {
    a + b
}

fn sapa(nama: &str) -> String {
    format!("Halo, {}!", nama)
}

fn main() {
    let total = tambah(8, 12);
    println!("Total: {}", total);

    let pesan = sapa("Aprilia");
    println!("{}", pesan);
}

Fungsi tambah menerima dua argumen bertipe i32 dan mengembalikan jumlahnya. Tanpa titik koma, ekspresi akhir langsung mewakili nilai balik. Fungsi sapa memperlihatkan bagaimana mengembalikan String dengan format! untuk menyusun pesan.

Tips Praktis Menulis Fungsi di Rust

Berikut kebiasaan penting agar fungsi Anda tetap rapi:

  • Gunakan nama deskriptif: fn hitung_total() lebih baik daripada fn pekerja(). Nama fungsi harus mencerminkan tindakan.
  • Batasi jumlah parameter: Fungsi dengan lebih dari tiga parameter cenderung sulit diuji. Pertimbangkan struct atau tuple untuk mengelompokkan data.
  • Berikan tipe eksplisit: Meski Rust memiliki inferensi, mendeklarasikan tipe parameter maupun nilai balik menjaga dokumentasi tetap jelas.
  • Pisahkan logika menggunakan fungsi bantu: Jika fungsi terlalu panjang, ekstrak bagian logika ke fungsi kecil untuk meningkatkan readability.
  • Unifikasikan penanganan error: Saat fungsi mungkin gagal, kembalikan Result daripada memanggil panic!. Ini memaksa pemanggil menangani error.

Contoh penggunaan Result sederhana:

fn bagi(a: i32, b: i32) -> Result {
    if b == 0 {
        Err("Pembagi tidak boleh nol")
    } else {
        Ok(a / b)
    }
}

Dengan menunjukkan Result, kode tetap eksplisit terhadap potensi kegagalan dan memudahkan debugging.

Membedakan Ekspresi dan Statement dalam Fungsi

Perbedaan ekspresi vs statement penting saat menentukan nilai balik. Ekspresi memberikan nilai dan bisa digunakan sebagai bagian dari fungsi atau parameter lain. Sebaliknya statement hanya menjalankan instruksi. Saat menulis fungsi, selalu perhatikan ekspresi akhir agar nilai balik sesuai ekspektasi.

Dalam praktik, jika Anda menulis:

fn contoh() -> i32 {
    let nilai = 7;
    nilai + 1;
}

// Ini akan gagal karena fungsi tidak mengembalikan nilai