Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Fungsi dan Closure Lanjutan

Bagian ini membahas beberapa fitur lanjutan yang berkaitan dengan fungsi dan closure, termasuk pointer fungsi dan cara mengembalikan closure.

Pointer Fungsi

Kita sudah bicara soal cara mengoper closure ke fungsi; ternyata kamu juga bisa mengoper fungsi biasa ke fungsi! Teknik ini berguna saat kamu ingin mengoper sebuah fungsi yang sudah kamu definisikan, alih-alih mendefinisikan closure baru. Fungsi berubah menjadi tipe fn (dengan huruf f kecil), jangan tertukar dengan trait closure Fn. Tipe fn disebut sebagai function pointer. Dengan mengoper fungsi memakai function pointer, kamu bisa memakai fungsi sebagai argumen untuk fungsi lain.

Sintaks untuk menyatakan bahwa sebuah parameter adalah function pointer mirip dengan sintaks closure, seperti yang kamu lihat di Listing 20-28. Di sana kita mendefinisikan fungsi add_one yang menambah 1 pada parameternya. Fungsi do_twice menerima dua parameter: sebuah function pointer ke fungsi apa pun yang menerima parameter i32 dan mengembalikan i32, serta sebuah nilai i32. Fungsi do_twice memanggil fungsi f dua kali dengan mengoper nilai arg, lalu menjumlahkan kedua hasil pemanggilan tersebut. Fungsi main memanggil do_twice dengan argumen add_one dan 5.

Filename: src/main.rs
fn add_one(x: i32) -> i32 {
    x + 1
}

fn do_twice(f: fn(i32) -> i32, arg: i32) -> i32 {
    f(arg) + f(arg)
}

fn main() {
    let answer = do_twice(add_one, 5);

    println!("The answer is: {answer}");
}
Listing 20-28: Memakai tipe fn untuk menerima function pointer sebagai argumen

Kode ini mencetak The answer is: 12. Kita menyatakan bahwa parameter f di do_twice adalah sebuah fn yang menerima satu parameter bertipe i32 dan mengembalikan i32. Setelah itu kita bisa memanggil f di dalam tubuh do_twice. Di main, kita bisa mengoper nama fungsi add_one sebagai argumen pertama ke do_twice.

Berbeda dengan closure, fn adalah sebuah tipe, bukan trait. Jadi kita menuliskan fn langsung sebagai tipe parameter, alih-alih mendeklarasikan parameter tipe generic dengan salah satu trait Fn sebagai trait bound.

Function pointer mengimplementasikan ketiga trait closure (Fn, FnMut, dan FnOnce), artinya kamu selalu bisa mengoper function pointer sebagai argumen ke fungsi yang mengharapkan closure. Sebaiknya tulis fungsi memakai tipe generic dan salah satu trait closure agar fungsimu bisa menerima baik fungsi maupun closure.

Meski begitu, ada kalanya kamu hanya ingin menerima fn, bukan closure— misalnya saat berhubungan dengan kode eksternal yang tidak punya closure: fungsi C bisa menerima fungsi sebagai argumen, tetapi C tidak mengenal closure.

Sebagai contoh kasus di mana kamu bisa memakai closure yang ditulis langsung maupun fungsi bernama, mari kita lihat penggunaan method map yang disediakan oleh trait Iterator di pustaka standar. Untuk memakai method map mengubah vector angka menjadi vector string, kita bisa memakai closure seperti di Listing 20-29.

fn main() {
    let list_of_numbers = vec![1, 2, 3];
    let list_of_strings: Vec<String> =
        list_of_numbers.iter().map(|i| i.to_string()).collect();
}
Listing 20-29: Memakai closure dengan method map untuk mengubah angka menjadi string

Atau kita bisa menyebut sebuah fungsi sebagai argumen map, menggantikan closure. Listing 20-30 menunjukkan tampilannya.

fn main() {
    let list_of_numbers = vec![1, 2, 3];
    let list_of_strings: Vec<String> =
        list_of_numbers.iter().map(ToString::to_string).collect();
}
Listing 20-30: Memakai fungsi String::to_string dengan method map untuk mengubah angka menjadi string

Perhatikan bahwa kita harus memakai sintaks nama lengkap yang sudah kita bahas di bagian “Advanced Traits”, karena ada beberapa fungsi bernama to_string yang tersedia.

Di sini kita memakai fungsi to_string yang didefinisikan dalam trait ToString, yang sudah diimplementasikan pustaka standar untuk tipe apa pun yang mengimplementasikan Display.

Ingat dari bagian “Enum Values” di Bab 6 bahwa nama setiap varian enum yang kita definisikan juga menjadi fungsi inisialisasi. Kita bisa memakai fungsi-fungsi inisialisasi ini sebagai function pointer yang mengimplementasikan trait closure. Artinya, kita bisa menyebut fungsi inisialisasi sebagai argumen untuk method yang menerima closure, seperti yang kamu lihat di Listing 20-31.

fn main() {
    enum Status {
        Value(u32),
        Stop,
    }

    let list_of_statuses: Vec<Status> = (0u32..20).map(Status::Value).collect();
}
Listing 20-31: Memakai inisialisasi enum dengan method map untuk membuat instance Status dari angka

Di sini kita membuat instance Status::Value dari setiap nilai u32 dalam rentang yang dipakai map, dengan memanggil fungsi inisialisasi Status::Value. Ada yang lebih suka gaya ini, ada pula yang lebih suka memakai closure. Keduanya dikompilasi menjadi kode yang sama, jadi pilih gaya yang paling jelas menurutmu.

Mengembalikan Closure

Closure direpresentasikan oleh trait, yang berarti kamu tidak bisa mengembalikan closure secara langsung. Pada kebanyakan kasus di mana kamu ingin mengembalikan sebuah trait, kamu bisa memakai tipe konkret yang mengimplementasi trait itu sebagai nilai kembalian fungsi. Namun, untuk closure kamu biasanya tidak bisa melakukan itu karena closure tidak punya tipe konkret yang bisa dikembalikan. Kamu juga tidak boleh memakai function pointer fn sebagai tipe kembalian jika closure tersebut menangkap nilai apa pun dari scope-nya, misalnya.

Sebagai gantinya, kamu biasanya akan memakai sintaks impl Trait yang sudah kita pelajari di Bab 10. Kamu bisa mengembalikan tipe fungsi apa pun, memakai Fn, FnOnce, dan FnMut. Misalnya, kode di Listing 20-32 akan terkompilasi dengan baik.

#![allow(unused)]
fn main() {
fn returns_closure() -> impl Fn(i32) -> i32 {
    |x| x + 1
}
}
Listing 20-32: Mengembalikan closure dari fungsi memakai sintaks impl Trait

Meski begitu, seperti yang kita catat di bagian “Inferring and Annotating Closure Types” dalam Bab 13, setiap closure juga punya tipenya sendiri yang berbeda. Jika kamu perlu bekerja dengan beberapa fungsi yang punya tanda tangan sama tetapi implementasi berbeda, kamu perlu memakai trait object untuk mereka. Perhatikan apa yang terjadi jika kamu menulis kode seperti di Listing 20-33.

Filename: src/main.rs
fn main() {
    let handlers = vec![returns_closure(), returns_initialized_closure(123)];
    for handler in handlers {
        let output = handler(5);
        println!("{output}");
    }
}

fn returns_closure() -> impl Fn(i32) -> i32 {
    |x| x + 1
}

fn returns_initialized_closure(init: i32) -> impl Fn(i32) -> i32 {
    move |x| x + init
}
Listing 20-33: Membuat Vec<T> berisi closure yang didefinisikan oleh fungsi yang mengembalikan tipe impl Fn

Di sini kita punya dua fungsi, returns_closure dan returns_initialized_closure, yang keduanya mengembalikan impl Fn(i32) -> i32. Perhatikan bahwa closure yang mereka kembalikan berbeda, meskipun keduanya mengimplementasikan tipe yang sama. Jika kita mencoba mengompilasi kode ini, Rust memberi tahu kita bahwa kode itu tidak akan jalan:

$ cargo build
   Compiling functions-example v0.1.0 (file:///projects/functions-example)
error[E0308]: mismatched types
  --> src/main.rs:2:44
   |
 2 |     let handlers = vec![returns_closure(), returns_initialized_closure(123)];
   |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected opaque type, found a different opaque type
...
 9 | fn returns_closure() -> impl Fn(i32) -> i32 {
   |                         ------------------- the expected opaque type
...
13 | fn returns_initialized_closure(init: i32) -> impl Fn(i32) -> i32 {
   |                                              ------------------- the found opaque type
   |
   = note: expected opaque type `impl Fn(i32) -> i32`
              found opaque type `impl Fn(i32) -> i32`
   = note: distinct uses of `impl Trait` result in different opaque types

For more information about this error, try `rustc --explain E0308`.
error: could not compile `functions-example` (bin "functions-example") due to 1 previous error

Pesan error itu menjelaskan bahwa setiap kali kita mengembalikan impl Trait, Rust membuat opaque type yang unik—sebuah tipe yang detailnya tidak bisa kita lihat dari apa yang Rust bangun untuk kita, dan kita juga tidak bisa menebak tipe yang akan dihasilkan Rust untuk ditulis sendiri. Jadi, meskipun fungsi-fungsi ini mengembalikan closure yang mengimplementasikan trait yang sama, yaitu Fn(i32) -> i32, opaque type yang Rust hasilkan untuk masing-masing tetap berbeda. (Ini mirip dengan cara Rust menghasilkan tipe konkret yang berbeda untuk blok async yang berbeda, bahkan ketika tipe keluarannya sama, seperti yang kita lihat di “The Pin Type and the Unpin Trait” di Bab 17.) Kita sudah beberapa kali melihat solusi untuk masalah ini: kita bisa memakai trait object, seperti di Listing 20-34.

fn main() {
    let handlers = vec![returns_closure(), returns_initialized_closure(123)];
    for handler in handlers {
        let output = handler(5);
        println!("{output}");
    }
}

fn returns_closure() -> Box<dyn Fn(i32) -> i32> {
    Box::new(|x| x + 1)
}

fn returns_initialized_closure(init: i32) -> Box<dyn Fn(i32) -> i32> {
    Box::new(move |x| x + init)
}
Listing 20-34: Membuat Vec<T> berisi closure yang didefinisikan oleh fungsi yang mengembalikan Box<dyn Fn> agar tipenya sama

Kode ini akan terkompilasi dengan baik. Untuk penjelasan lebih lanjut soal trait object, lihat bagian “Using Trait Objects To Abstract over Shared Behavior” di Bab 18.

Selanjutnya, mari kita bahas macro!