Tipe Data & Koleksi

BAB 17: Function

Fungsi di Rust menerima parameter bertipe, mengembalikan nilai lewat panah dan expression terakhir, serta membedakan statement dari expression.

Rumus luas persegi panjang yang dipakai di 5 tempat berbeda cukup ditulis 1 kali sebagai fungsi, dan setiap perbaikan rumus hanya menyentuh 1 bagian kode. Rust menyusun program dari fungsi, dan main adalah fungsi yang pertama dijalankan saat biner dimulai. Fungsi lain baru bekerja ketika dipanggil.

Bab ini membahas cara mendefinisikan fungsi, menerima parameter bertipe, mengembalikan nilai, dan membedakan statement dari expression. Setelah bab ini selesai, kamu dapat menulis fungsi dengan parameter dan nilai kembalian, memakai blok sebagai expression, dan menjelaskan mengapa 1 titik koma bisa mengubah tipe kembalian. Semua contoh dikompilasi dengan rustc 1.100.0 dan dijalankan dari folder /tmp/latihan-rust/bab17.

Mendefinisikan dan memanggil fungsi

Fungsi ditulis dengan kata kunci fn, diikuti nama, daftar parameter di dalam tanda kurung, tipe kembalian setelah panah, lalu badan fungsi di dalam kurung kurawal. Berkas f1_gabung.rs mendefinisikan main lebih dulu, lalu 2 fungsi lain di bawahnya.

RSRUST
fn main() {
    println!("main dimulai");
    sapa();
    sapa();
    println!("dua kali 21 = {}", dua_kali(21));
}

fn sapa() {
    println!("Halo dari fungsi sapa");
}

fn dua_kali(n: i32) -> i32 {
    n * 2
}
CodeTEXT
main dimulai
Halo dari fungsi sapa
Halo dari fungsi sapa
dua kali 21 = 42

Urutan definisi tidak mempengaruhi pemanggilan. sapa dan dua_kali ditulis setelah main, tetapi tetap bisa dipanggil dari main karena kompilator membaca seluruh berkas sebelum menentukan isi tiap fungsi. Yang menentukan urutan eksekusi adalah urutan pemanggilan, bukan urutan penulisan.

Pemanggilan sapa() 2 kali menjalankan badan yang sama, dan tiap pemanggilan berdiri sendiri. dua_kali(21) mengembalikan 42 karena n berisi 21 saat badan fungsi dijalankan, lalu hasilnya dipakai println! sebagai argumen.

Nama fungsi memakai huruf kecil dengan garis bawah, dan kompilator memperingatkan nama yang memakai huruf besar di tengah. Berkas f9_nama.rs sengaja memakai nama duaKali untuk memicu peringatan itu.

RSRUST
fn duaKali(n: i32) -> i32 {
    n * 2
}

fn main() {
    println!("{}", duaKali(21));
}
CodeTEXT
warning: function `duaKali` should have a snake case name
 --> f9_nama.rs:1:4
  |
1 | fn duaKali(n: i32) -> i32 {
  |    ^^^^^^^ help: convert the identifier to snake case: `dua_kali`
  |
  = note: `#[warn(non_snake_case)]` (part of `#[warn(nonstandard_style)]`) on by default

Program tetap berjalan dan mencetak 42 karena peringatan bukan error. Lint non_snake_case bisa dinaikkan menjadi error lewat atribut #![deny(non_snake_case)] di awal berkas, dan itu berguna saat nama fungsi harus seragam di seluruh proyek.

Alur 1 pemanggilan fungsi

Pemanggilan fungsi memindahkan kendali dari pemanggil ke badan fungsi, lalu mengembalikan nilai ke titik pemanggilan. Diagram berikut menunjukkan urutan itu untuk luas(3, 4).

Alur pemanggilan luas(3, 4) dari main sampai nilai 12 dicetak

Urutan pemanggilan: argumen masuk ke parameter, badan fungsi dijalankan, nilai terakhir dikembalikan, lalu hasilnya dipakai pemanggil.

Nilai 3 dan 4 disalin ke parameter p dan l karena i32 menyalin dirinya sendiri. Badan fungsi berisi 1 expression p * l yang menghasilkan 12, dan angka itu menjadi nilai kembalian. Pemanggil menerima 12 dan menyerahkannya ke println!, sehingga yang tercetak adalah hasil akhir, bukan isi parameter.

Parameter wajib bertipe

Setiap parameter harus punya tipe yang ditulis di tanda tangan fungsi. Rust Book menyatakan bahwa di dalam signature fungsi, tipe setiap parameter wajib dideklarasikan, dan keputusan itu diambil supaya kompilator jarang menebak tipe di bagian lain kode.

RSRUST
fn luas(p: i32, l: i32) -> i32 {
    p * l
}

fn main() {
    println!("luas 3x4 {}", luas(3, 4));
    println!("luas 5x2 {}", luas(5, 2));

    let sisi = 7;
    println!("luas 7x7 {}", luas(sisi, sisi));
}
CodeTEXT
luas 3x4 12
luas 5x2 10
luas 7x7 49

Parameter juga boleh berupa pola, bukan nama tunggal. Rust Reference menyebut parameter fungsi adalah pola yang tidak bisa gagal dicocokkan, sehingga pola yang sah pada let tanpa else juga sah sebagai parameter.

RSRUST
fn jarak((x, y): (i32, i32)) -> i32 {
    x.abs() + y.abs()
}

fn main() {
    println!("jarak {}", jarak((-3, 4)));
}
CodeTEXT
jarak 7

Fungsi jarak menerima 1 parameter bertipe tuple, lalu membongkarnya menjadi x dan y di tanda tangan. Hasilnya 7, yaitu 3 ditambah 4 setelah tanda negatif dibuang abs. Bentuk ini berguna saat 2 nilai memang selalu berpasangan, tetapi parameter terpisah lebih mudah dibaca kalau jumlahnya lebih dari 2.

Menghilangkan tipe parameter menghentikan kompilasi sebelum program dijalankan.

RSRUST
fn luas(p, l) -> i32 {
    p * l
}

fn main() {
    println!("{}", luas(3, 4));
}
CodeTEXT
error: expected one of `:`, `@`, or `|`, found `,`
 --> e1_tipe.rs:1:10
  |
1 | fn luas(p, l) -> i32 {
  |          ^ expected one of `:`, `@`, or `|`
  |
help: if this is a parameter name, give it a type
  |
1 | fn luas(p: TypeName, l) -> i32 {
  |          ++++++++++

Pesan itu menyebut :, @, dan | karena ketiganya boleh muncul setelah nama parameter: titik dua untuk tipe, @ untuk pola dengan nama, dan | untuk parameter closure. Kompilator juga menawarkan perbaikan berupa penambahan tipe, dan itulah yang dibutuhkan pada kasus ini.

Mengembalikan nilai dengan panah

Tipe kembalian ditulis setelah ->, dan nilai yang dikembalikan adalah expression terakhir di badan fungsi tanpa titik koma. Rust Book menuliskan bahwa tipe nilai kembalian dideklarasikan setelah panah, dan expression tidak memakai titik koma di ujungnya.

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

fn main() {
    println!("{}", tambah(2, 3));
}
CodeTEXT
error[E0308]: mismatched types
 --> e2_titikkoma.rs:1:30
  |
1 | fn tambah(a: i32, b: i32) -> i32 {
  |    ------                    ^^^ expected `i32`, found `()`
  |    |
  |    implicitly returns `()` as its body has no tail or `return` expression
2 |     a + b;
  |          - help: remove this semicolon to return this value

error: aborting due to 1 previous error

Titik koma mengubah a + b dari expression menjadi statement, sehingga nilainya dibuang dan badan fungsi tidak punya nilai akhir. Kompilator menunjuk baris yang harus diubah, yaitu menghapus titik koma. Rust Book menyebut aturan yang sama dengan kalimat bahwa menambahkan titik koma pada ujung expression mengubahnya menjadi statement yang tidak mengembalikan nilai.

Kesalahan tipe kembalian juga muncul saat cabang if memberi tipe berbeda.

RSRUST
fn status(nilai: i32) -> i32 {
    if nilai >= 75 {
        1
    } else {
        "nol"
    }
}

fn main() {
    println!("{}", status(80));
}
CodeTEXT
error[E0308]: mismatched types
 --> e4_kembali.rs:5:9
  |
1 | fn status(nilai: i32) -> i32 {
  |                          --- expected `i32` because of return type
...
5 |         "nol"
  |         ^^^^^ expected `i32`, found `&str`

error: aborting due to 1 previous error

Pesan E0308 menyebut tipe kembalian sebagai patokan, lalu menunjuk cabang else sebagai sumber ketidakcocokan. if di Rust adalah expression, jadi kedua cabangnya harus menghasilkan tipe yang sama. Perbaikannya adalah mengubah "nol" menjadi angka, atau mengubah tipe kembalian fungsi menjadi &str dan menyesuaikan cabang lainnya.

Statement dan expression

Statement adalah perintah yang tidak menghasilkan nilai, sedangkan expression menghasilkan nilai. Blok di dalam kurung kurawal adalah expression kalau nilai terakhirnya tidak diikuti titik koma.

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

fn main() {
    let hasil = tambah(2, 3);
    println!("hasil {}", hasil);

    let blok = {
        let a = 4;
        let b = 5;
        a * b
    };
    println!("blok {}", blok);

    let x = 10;
    let x = {
        let y = x * 2;
        y + 1
    };
    println!("x {}", x);
}
CodeTEXT
hasil 5
blok 20
x 21

Blok pertama menghasilkan 20 karena a * b menjadi nilai blok, sementara let a dan let b di dalamnya hanya menyiapkan nilai. Blok kedua membaca x yang lama, menghitung 21, lalu hasilnya dipakai untuk x yang baru. Pola ini disebut shadowing, dan dipakai saat nilai baru merupakan hasil pengolahan nilai lama.

Pemisahan statement dan expression menjelaskan 2 aturan yang sudah dibahas: badan fungsi memberi nilai lewat expression terakhir, dan titik koma membuang nilai itu. Satu titik koma di ujung blok mengubah seluruh blok menjadi statement yang bertipe ().

Return lebih awal

Kata kunci return dipakai untuk keluar dari fungsi sebelum mencapai expression terakhir. Bagian yang sering dipakai adalah pemeriksaan di awal, supaya kasus tidak valid ditangani lebih dulu.

RSRUST
fn label_nilai(nilai: i32) -> &'static str {
    if nilai < 0 {
        return "tidak valid";
    }
    if nilai >= 75 {
        return "lulus";
    }
    "remedial"
}

fn main() {
    println!("{}", label_nilai(-5));
    println!("{}", label_nilai(80));
    println!("{}", label_nilai(60));
}
CodeTEXT
tidak valid
lulus
remedial

Fungsi itu punya 2 return dan 1 expression terakhir, dan ketiganya menghasilkan tipe &'static str, yaitu teks yang hidup selama program berjalan. Nilai -5 keluar di pemeriksaan pertama, 80 keluar di pemeriksaan kedua, dan 60 melewati keduanya sehingga memakai nilai terakhir. Aturan lifetime pada tipe itu dibahas di bab tentang lifetime, jadi untuk sekarang cukup diingat bahwa semua jalur harus memberi tipe yang sama.

Fungsi tanpa nilai kembalian

Fungsi tanpa -> tidak mengembalikan nilai yang bisa dipakai. Yang dikembalikan adalah unit (), dan nilainya bisa disimpan walaupun tidak berisi apa pun.

RSRUST
fn cetak_label(teks: &str) {
    println!("[{}]", teks);
}

fn main() {
    let hasil = cetak_label("mulai");
    println!("nilai kembalian {:?}", hasil);
    println!("ukurannya {} byte", std::mem::size_of_val(&hasil));
}
CodeTEXT
[mulai]
nilai kembalian ()
ukurannya 0 byte

Baris [mulai] tercetak sebelum variabel hasil diisi, karena cetak_label dijalankan lebih dulu dan mengembalikan (). Ukuran nilai itu 0 byte, sesuai tabel di dokumentasi size_of yang mencatat () berukuran 0. Menulis let hasil: () = cetak_label("mulai"); juga sah, dan itu membuktikan tipe kembaliannya tanpa perlu {:?}.

Fungsi di dalam fungsi

Fungsi boleh didefinisikan di dalam fungsi lain. Fungsi bersarang hanya terlihat oleh induknya, sehingga namanya tidak bisa dipanggil dari main.

RSRUST
fn keliling(sisi: i32) -> i32 {
    fn kali_empat(n: i32) -> i32 {
        n * 4
    }

    kali_empat(sisi)
}

fn main() {
    println!("keliling {}", keliling(5));
}
CodeTEXT
keliling 20

kali_empat hanya berguna di dalam keliling, dan menempatkannya di sana menunjukkan bahwa fungsi itu bukan bagian dari antarmuka luar. Pemanggilan dari main ditolak karena kali_empat tidak ada di cakupan itu.

RSRUST
fn keliling(sisi: i32) -> i32 {
    fn kali_empat(n: i32) -> i32 {
        n * 4
    }

    kali_empat(sisi)
}

fn main() {
    println!("langsung {}", kali_empat(5));
}
CodeTEXT
error[E0425]: cannot find function `kali_empat` in this scope
  --> f7_bersarang.rs:10:29
   |
10 |     println!("langsung {}", kali_empat(5));
   |                             ^^^^^^^^^^ not found in this scope

error: aborting due to 1 previous error

Pesan E0425 memakai frasa not found in this scope, bukan pesan tentang tipe atau argumen, karena kompilator memang tidak menemukan nama itu di cakupan main. Fungsi bersarang berbeda dari closure: closure bisa menangkap variabel sekitarnya, sedangkan fungsi bersarang tidak.

Jumlah argumen diperiksa saat kompilasi

Rust tidak punya nilai bawaan untuk parameter, jadi jumlah argumen harus sama dengan jumlah parameter. Kekurangan 1 argumen ditolak sebelum program berjalan.

RSRUST
fn luas(p: i32, l: i32) -> i32 {
    p * l
}

fn main() {
    println!("{}", luas(3));
}
CodeTEXT
error[E0061]: this function takes 2 arguments but 1 argument was supplied
 --> e3_argumen.rs:6:20
  |
6 |     println!("{}", luas(3));
  |                    ^^^^--- argument #2 of type `i32` is missing
  |
note: function defined here
 --> e3_argumen.rs:1:4
  |
1 | fn luas(p: i32, l: i32) -> i32 {
  |    ^^^^         ------
help: provide the argument
  |
6 |     println!("{}", luas(3, /* i32 */));
  |                          +++++++++++

error: aborting due to 1 previous error

Pesan E0061 menghitung jumlah argumen, menunjuk parameter yang kosong, lalu menunjukkan posisi penambahannya. Pemeriksaan ini terjadi saat kompilasi, sehingga kesalahan pemanggilan tidak pernah menjadi panic saat berjalan. Kalau nilai bawaan dibutuhkan, polanya adalah membuat fungsi pembungkus yang mengisi argumen tersebut.

Latihan

  1. Tulis fungsi suhu_fahrenheit(celsius: f64) -> f64 yang mengembalikan celsius * 9.0 / 5.0 + 32.0, lalu panggil dengan 3 nilai.
  2. Tulis fungsi label(nilai: i32) -> &'static str yang memakai return lebih awal untuk nilai negatif.
  3. Hapus titik koma pada expression terakhir di salah satu fungsimu, catat kode error yang muncul, lalu perbaiki.
  4. Pindahkan main ke baris paling bawah setelah semua fungsi, lalu pastikan program tetap berjalan.

Ringkasan

Fungsi didefinisikan dengan fn, menerima parameter yang wajib bertipe, dan mengembalikan nilai lewat expression terakhir setelah panah ->. Statement tidak menghasilkan nilai, sedangkan expression menghasilkan nilai, dan 1 titik koma di ujung expression mengubahnya menjadi statement bertipe (). Fungsi tanpa tipe kembalian menghasilkan unit yang berukuran 0 byte, dan jumlah argumen diperiksa kompilator sebelum program dijalankan.

Referensi

  1. The Rust Programming Language. Functions.
  2. The Rust Reference. Functions.
  3. The Rust Reference. Statements.