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.
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}");
}
fn untuk menerima function pointer sebagai argumenKode 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();
}
map untuk mengubah angka menjadi stringAtau 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();
}
String::to_string dengan method map untuk mengubah angka menjadi stringPerhatikan 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();
}
map untuk membuat instance Status dari angkaDi 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
}
}
impl TraitMeski 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.
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
}
Vec<T> berisi closure yang didefinisikan oleh fungsi yang mengembalikan tipe impl FnDi 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)
}
Vec<T> berisi closure yang didefinisikan oleh fungsi yang mengembalikan Box<dyn Fn> agar tipenya samaKode 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!