BAB 24: Associated Function
Associated function adalah fungsi di dalam blok impl yang dipanggil lewat nama tipe tanpa self, dan bab ini mengukur cara memakainya sebagai konstruktor.
String::from("kopi") sudah dipakai sejak bab tentang string, dan bentuk pemanggilan itu tidak memerlukan nilai String yang sudah ada lebih dulu. Nama tipe ditulis di depan, tanda :: di tengah, lalu nama fungsi di belakangnya. Fungsi yang dipanggil dengan cara seperti itu bekerja tanpa instance, karena tidak ada self yang harus diisi.
Struct Barang dengan 3 field memaksa setiap pembuatan instance menulis nama, harga, dan jumlah. Kalau aturan pengisiannya selalu sama, misalnya jumlah awal selalu 1, penulisan berulang itu memindahkan aturan ke setiap tempat pemakaian dan mudah lupa diperbarui. Associated function memindahkan aturan tersebut ke 1 tempat di dalam tipe itu sendiri.
Bab ini membahas cara mendefinisikan dan memanggil associated function, peran kata kunci Self, 4 pesan kesalahan yang muncul saat pemanggilannya salah, dan cara memakai Default serta konstruktor di standard library. Setelah bab ini selesai, kamu dapat menulis konstruktor sendiri untuk tipe buatanmu dan membaca E0599, E0424, serta E0411 sebagai kesalahan seputar pemanggilan fungsi pada tipe. Semua contoh dijalankan dengan rustc 1.100.0 pada folder /tmp/latihan-rust/bab24.
Memanggil fungsi lewat nama tipe
Associated function didefinisikan di dalam blok impl, dan dipanggil dengan menulis nama tipe lalu ::. Program berikut membuat konstruktor Barang::baru yang mengisi jumlah awal dengan 1.
struct Barang {
nama: String,
harga: u32,
jumlah: u32,
}
impl Barang {
fn baru(nama: &str, harga: u32) -> Barang {
Barang {
nama: String::from(nama),
harga,
jumlah: 1,
}
}
}
fn main() {
let kopi = Barang::baru("kopi", 2500);
println!("{} x {} = {}", kopi.nama, kopi.jumlah, kopi.harga * kopi.jumlah);
}
kopi x 1 = 2500
Fungsi baru menerima 2 parameter dan mengembalikan Barang, sehingga hasilnya bisa langsung disimpan ke variabel. Isi harga, adalah field init shorthand yang sudah dibahas pada bab struct, yaitu singkatan dari harga: harga. Perhatikan bahwa jumlah diisi tetap 1, dan itulah aturan yang tadi tersebar di banyak tempat sekarang hanya ada di dalam impl.
Parameter pertama nama bertipe &str, bukan String, supaya fungsi bisa menerima string literal maupun potongan String yang sudah ada. Di dalamnya nilai itu disalin menjadi String milik struct, sehingga hasilnya tidak bergantung pada umur variabel pemanggil.
Blok impl dan kata kunci Self
Di dalam blok impl Barang, tipe Barang bisa ditulis sebagai Self. Keduanya menunjuk tipe yang sama, dan Self berguna saat nama tipe panjang atau saat tipe itu nanti memakai parameter generik.
struct Barang {
nama: String,
harga: u32,
jumlah: u32,
}
impl Barang {
fn baru(nama: &str, harga: u32) -> Self {
Self {
nama: String::from(nama),
harga,
jumlah: 1,
}
}
fn grosir(nama: &str, harga: u32, jumlah: u32) -> Self {
Self {
nama: String::from(nama),
harga,
jumlah,
}
}
fn contoh(nama: &str) -> Self {
Self::baru(nama, 0)
}
}
fn main() {
let kopi = Barang::baru("kopi", 2500);
let tebu = Barang::grosir("tebu", 2000, 12);
let sampel = Barang::contoh("sampel");
println!("{} {} {}", kopi.nama, kopi.jumlah, kopi.harga);
println!("{} {} {}", tebu.nama, tebu.jumlah, tebu.harga);
println!("{} {} {}", sampel.nama, sampel.jumlah, sampel.harga);
}
kopi 1 2500
tebu 12 2000
sampel 1 0
Satu tipe boleh punya beberapa associated function sekaligus, dan salah satunya boleh memanggil yang lain lewat Self::baru. Pemanggilan Self::baru(nama, 0) di dalam contoh tetap harus menyebut nama fungsi, karena Self hanya menunjuk tipe, bukan instance. Baris itu tidak bisa disingkat menjadi baru(nama, 0), sebab nama associated function tidak masuk ke ruang nama fungsi biasa.
Self juga dipakai pada implementasi trait, karena di sana nama tipe tidak selalu boleh diulang. Contohnya fn default() -> Self pada trait Default yang dibahas di bagian akhir bab ini. Aturan penggantiannya sederhana: selama kode berada di dalam impl untuk tipe itu, Self dan nama tipe menunjuk hal yang sama, sehingga pilih salah satu dan pakai secara konsisten dalam satu blok.
new bukan nama istimewa
Buku resmi Rust menyatakan bahwa associated function yang bukan method sering dipakai sebagai konstruktor, dan namanya biasanya new. Kalimat berikutnya penting: "new isn't a special name and isn't built into the language". Tidak ada perlakuan khusus dari kompilator untuk fungsi bernama new, sama seperti tidak ada perlakuan khusus untuk nama baru atau dari_csv.
Akibat praktisnya, pemilihan nama mengikuti kebiasaan, bukan aturan bahasa. String::from memakai from, Vec::with_capacity memakai with_capacity, dan tipe yang bisa dibuat tanpa argumen memakai default lewat trait Default. Semua bentuk itu adalah associated function biasa yang dipanggil dengan ::.
Nama juga berguna sebagai keterangan biaya. Vec::new() membuat vector tanpa memesan memori, sedangkan Vec::with_capacity(100) memesan ruang untuk 100 elemen lebih dulu. Keduanya konstruktor yang sah, dan pembaca kode bisa menebak mana yang memesan memori hanya dari namanya. Kebiasaan seperti ini tidak diperiksa kompilator, tetapi membuat kode lebih mudah dibaca tanpa membuka dokumentasi.
Memanggil associated function dengan titik: E0599
Karena tidak punya self, associated function tidak bisa dipanggil dengan titik pada instance. Percobaan berikut menulis kopi.baru("tebu") seolah baru adalah method.
struct Barang {
nama: String,
}
impl Barang {
fn baru(nama: &str) -> Self {
Self {
nama: String::from(nama),
}
}
}
fn main() {
let kopi = Barang::baru("kopi");
println!("{}", kopi.baru("tebu").nama);
}
error[E0599]: no method named `baru` found for struct `Barang` in the current scope
--> uji/salah_titik.rs:15:25
|
1 | struct Barang {
| ------------- method `baru` not found for this struct
...
15 | println!("{}", kopi.baru("tebu").nama);
| ^^^^ this is an associated function, not a method
|
= note: found the following associated functions; to be used as methods, functions must have a `self` parameter
note: the candidate is defined in an impl for the type `Barang`
--> uji/salah_titik.rs:6:5
|
6 | fn baru(nama: &str) -> Self {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: use associated function syntax instead
|
15 - println!("{}", kopi.baru("tebu").nama);
15 + println!("{}", Barang::baru("tebu").nama);
|
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0599`.
Pesan itu menyebut penyebabnya dengan tepat: baru adalah associated function, bukan method, dan syarat menjadi method adalah parameter self. Kompilator juga menawarkan perbaikan yang benar, yaitu mengganti kopi.baru("tebu") menjadi Barang::baru("tebu"). Perhatikan bahwa pemanggilan dengan titik akan mengabaikan kopi sepenuhnya, sehingga nilainya tidak terpakai meskipun barisnya lolos.
Fungsi di luar impl: E0599
Kesalahan berikutnya terlihat mirip, tetapi penyebabnya berbeda. Fungsi baru ditulis di tingkat module, lalu dipanggil dengan Barang::baru.
struct Barang {
nama: String,
}
fn baru(nama: &str) -> Barang {
Barang {
nama: String::from(nama),
}
}
fn main() {
let kopi = Barang::baru("kopi");
println!("{}", kopi.nama);
}
error[E0599]: no associated function or constant named `baru` found for struct `Barang` in the current scope
--> uji/salah_luar_impl.rs:12:24
|
1 | struct Barang {
| ------------- associated function or constant `baru` not found for this struct
...
12 | let kopi = Barang::baru("kopi");
| ^^^^ associated function or constant not found in `Barang`
error: aborting due to 1 previous error
Tanda :: hanya mencari nama yang terdaftar pada tipe, dan yang mendaftarkan nama adalah blok impl. Fungsi yang berdiri sendiri di tingkat module tidak terdaftar di sana, walaupun menerima parameter dan mengembalikan Barang. Perbaikannya ada 2: pindahkan baru ke dalam impl Barang, atau panggil sebagai fungsi biasa dengan baru("kopi") tanpa nama tipe di depan.
Perbedaan kalimat kedua pesan itu menandakan hal yang berbeda. Pesan pertama berbunyi "no method named", sedangkan pesan kedua berbunyi "no associated function or constant named". Keduanya memakai kode E0599 karena sama sama gagal menemukan nama yang cocok, tetapi arah pencariannya berbeda: satu mencari method pada instance, satu mencari nama yang terdaftar di tipe.
Memakai self tanpa receiver: E0424 dan E0411
self hanya tersedia pada fungsi yang menerimanya sebagai parameter. Program berikut menulis associated function tanpa parameter, lalu memakai self di dalamnya.
struct Barang {
nama: String,
jumlah: u32,
}
impl Barang {
fn baru(nama: &str) -> Self {
Self {
nama: String::from(nama),
jumlah: 1,
}
}
fn jumlah_awal() -> u32 {
self.jumlah
}
}
fn main() {
println!("{}", Barang::jumlah_awal());
}
error[E0424]: cannot find value `self` in this scope
--> uji/salah_self.rs:15:9
|
14 | fn jumlah_awal() -> u32 {
| ----------- this function doesn't have a `self` parameter
15 | self.jumlah
| ^^^^ `self` value is a keyword only available in methods with a `self` parameter
|
= note: a module named `self` exists in another namespace
help: add a `self` receiver parameter to make the associated `fn` a method
|
14 | fn jumlah_awal(&self) -> u32 {
| +++++
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0424`.
Pesan itu menawarkan 1 perbaikan yang mengubah sifat fungsinya: menambahkan &self membuat jumlah_awal menjadi method, sehingga pemanggilannya berubah dari Barang::jumlah_awal() menjadi barang.jumlah_awal(). Kalau fungsinya memang harus tetap associated function, nilainya harus dikirim sebagai parameter biasa, misalnya fn jumlah_awal(jumlah: u32) -> u32.
Kesalahan sejenis muncul saat Self dipakai di luar blok impl. Fungsi baru berikut ditulis di tingkat module dengan tipe kembalian Self.
struct Barang {
nama: String,
}
fn baru(nama: &str) -> Self {
Self {
nama: String::from(nama),
}
}
fn main() {
let kopi = baru("kopi");
println!("{}", kopi.nama);
}
error[E0411]: cannot find type `Self` in this scope
--> uji/salah_self_luar.rs:5:24
|
5 | fn baru(nama: &str) -> Self {
| ---- ^^^^ `Self` is only available in impls, traits, and type definitions
| |
| `Self` not allowed in a function
error[E0411]: cannot find struct, variant or union type `Self` in this scope
--> uji/salah_self_luar.rs:6:5
|
5 | fn baru(nama: &str) -> Self {
| ---- `Self` not allowed in a function
6 | Self {
| ^^^^ `Self` is only available in impls, traits, and type definitions
error: aborting due to 2 previous errors
Self bukan nama tipe yang berdiri sendiri, melainkan sebutan untuk tipe yang sedang di-impl. Di luar blok itu tidak ada tipe yang dimaksud, sehingga kompilator melaporkan 2 kesalahan sekaligus, 1 pada tipe kembalian dan 1 pada pembuatan nilai. Perbaikannya menulis Barang secara eksplisit, atau memindahkan fungsi ke dalam impl Barang.
Default sebagai associated function
Trait Default mewajibkan 1 associated function bernama default, dan fungsi itu dipanggil dengan nama tipe. Program berikut mengisi nilai awal untuk struct Barang tanpa menulis konstruktor baru.
#[derive(Debug)]
struct Barang {
nama: String,
harga: u32,
jumlah: u32,
}
impl Default for Barang {
fn default() -> Self {
Self {
nama: String::from("tanpa nama"),
harga: 0,
jumlah: 0,
}
}
}
fn main() {
let kosong = Barang::default();
let daftar = vec![Barang::default(), Barang::default()];
println!("{:?}", kosong);
println!("jumlah barang: {}", daftar.len());
}
Barang { nama: "tanpa nama", harga: 0, jumlah: 0 }
jumlah barang: 2
Pemanggilan Barang::default() memakai bentuk yang sama dengan Barang::baru, karena keduanya associated function. Bedanya, default terikat pada trait sehingga bisa dipakai kode umum yang hanya tahu tipenya implements Default. Struktur dengan semua field yang sudah implements Default bisa memakai #[derive(Default)], sedangkan contoh di atas menulis implementasinya sendiri karena ingin nama awal berisi teks.
Associated function di dalam module
Struct publik yang dipakai dari module lain membutuhkan associated function publik pula, dan pemanggilannya menyebut seluruh jalur. Program berikut memakai module katalog dengan struct Barang di dalamnya.
mod katalog {
pub struct Barang {
pub nama: String,
pub harga: u32,
}
impl Barang {
pub fn baru(nama: &str, harga: u32) -> Self {
Self {
nama: String::from(nama),
harga,
}
}
}
}
fn main() {
let kopi = katalog::Barang::baru("kopi", 2500);
println!("{} {}", kopi.nama, kopi.harga);
}
kopi 2500
Jalur katalog::Barang::baru dibaca dari kiri ke kanan: module, tipe, lalu associated function. Tanpa pub pada fn baru, pemanggilan dari main ditolak dengan E0624 yang menyebut fungsi itu privat. Pola ini yang membuat field bisa ditutup sementara pembuatan instance tetap mungkin, karena fungsi di dalam module yang sama boleh mengisi field privat.
Konstruktor di standard library
String menyediakan beberapa associated function dengan biaya berbeda. Program berikut membandingkan kapasitas awal dari 3 konstruktor.
fn main() {
let a = String::new();
let b = String::from("");
let c = String::with_capacity(8);
println!("new: len {} kapasitas {}", a.len(), a.capacity());
println!("from: len {} kapasitas {}", b.len(), b.capacity());
println!("with_capacity: len {} kapasitas {}", c.len(), c.capacity());
}
new: len 0 kapasitas 0
from: len 0 kapasitas 0
with_capacity: len 0 kapasitas 8
Ketiga nilai punya panjang 0, tetapi with_capacity sudah memesan buffer 8 byte. Dokumentasi std menuliskan fungsi itu "Creates a new empty String with at least the specified capacity", dan hasil ukur di atas menunjukkan permintaan 8 byte dipenuhi tepat 8 byte pada versi ini. Artinya pemilihan associated function bukan soal selera: new dan from("") tidak memesan memori, sedangkan with_capacity memesan sejak awal untuk menghindari realokasi saat isi ditambahkan.
Hal yang sama berlaku untuk tipe buatan sendiri. Konstruktor yang menerima &str dan menyalinnya membuat String baru, sedangkan konstruktor yang menerima String bisa memindahkan nilainya tanpa salinan. Nama fungsinya bebas, tetapi biaya yang ditanggung pemanggil ditentukan oleh tipe parameter yang dipilih.
Latihan
- Buat
struct Bukudengan fieldjudul: String,halaman: u32, danselesai: bool. Tulis associated functionBuku::baru(judul, halaman)yang mengisiselesaidenganfalse. - Tambahkan associated function
Buku::tebal(judul)yang memakaiSelf::barulalu mengisihalamandengan 500, tanpa menulis ulang seluruh field. - Panggil
buku.baru("Rust")dengan titik, jalankanrustc, dan kutip barishelpyang ditawarkan kompilator. - Hapus
pubpadafn barudi dalam module, lalu jelaskan kode kesalahan yang muncul dan baris mana yang ditunjuk.
Ringkasan
Associated function adalah fungsi di dalam blok impl yang tidak menerima self, sehingga dipanggil lewat nama tipe dengan :: dan tidak membutuhkan instance. Di dalam blok itu tipe bisa disebut Self, tetapi Self tidak berlaku di luar blok impl dan self hanya tersedia pada method. Pemanggilan yang salah menghasilkan E0599 saat nama tidak ditemukan atau dipanggil dengan titik, E0424 saat self dipakai tanpa receiver, dan E0411 saat Self dipakai di luar impl. Nama new hanya kebiasaan, dan pilihan konstruktor di standard library seperti String::with_capacity menentukan kapasitas awal 8 byte pada contoh yang diukur di bab ini.
Referensi
- The Rust Programming Language. Method Syntax, bagian Associated Functions.
- The Rust Reference. Associated items.
- Rust Standard Library. String in std::string.