Tipe Data Generic
Kita memakai generic untuk membuat definisi bagi item seperti tanda tangan fungsi atau struct, yang kemudian bisa kita pakai dengan banyak tipe data konkret yang berbeda. Mari kita lihat dulu cara mendefinisikan fungsi, struct, enum, dan method menggunakan generic. Setelah itu, kita akan membahas bagaimana generic memengaruhi performa kode.
Di Dalam Definisi Fungsi
Saat mendefinisikan fungsi yang memakai generic, kita menaruh generic di tanda tangan fungsi, tepat di tempat yang biasa kita pakai untuk menentukan tipe data parameter dan nilai kembalian. Dengan begitu, kode kita jadi lebih fleksibel dan memberi lebih banyak kemampuan kepada siapa pun yang memanggil fungsi tersebut, sekaligus mencegah duplikasi kode.
Melanjutkan fungsi largest kita, Listing 10-4 menampilkan dua fungsi yang sama-sama
mencari nilai terbesar dalam sebuah slice. Setelah itu, kita akan menggabungkan
keduanya menjadi satu fungsi yang memakai generic.
fn largest_i32(list: &[i32]) -> &i32 {
let mut largest = &list[0];
for item in list {
if item > largest {
largest = item;
}
}
largest
}
fn largest_char(list: &[char]) -> &char {
let mut largest = &list[0];
for item in list {
if item > largest {
largest = item;
}
}
largest
}
fn main() {
let number_list = vec![34, 50, 25, 100, 65];
let result = largest_i32(&number_list);
println!("The largest number is {result}");
assert_eq!(*result, 100);
let char_list = vec!['y', 'm', 'a', 'q'];
let result = largest_char(&char_list);
println!("The largest char is {result}");
assert_eq!(*result, 'y');
}
Fungsi largest_i32 adalah fungsi yang kita ekstrak di Listing 10-3 untuk mencari
i32 terbesar dalam sebuah slice. Fungsi largest_char mencari char terbesar
dalam sebuah slice. Isi kedua fungsi itu sama, jadi mari kita hilangkan duplikasi
dengan memperkenalkan parameter tipe generic dalam satu fungsi.
Untuk memparameterisasi tipe dalam satu fungsi baru, kita perlu memberi nama pada
parameter tipe itu, sama seperti yang kita lakukan pada parameter nilai fungsi.
Kamu bisa memakai identifier apa pun sebagai nama parameter tipe. Namun kita akan
memakai T karena, sesuai konvensi, nama parameter tipe di Rust itu pendek, sering
kali hanya satu huruf, dan konvensi penamaan tipe Rust memakai UpperCamelCase.
Karena T adalah kependekan dari type, itulah pilihan default kebanyakan
programmer Rust.
Saat kita memakai sebuah parameter di dalam isi fungsi, kita harus mendeklarasikan
nama parameter itu di tanda tangan agar compiler tahu apa arti nama tersebut.
Begitu pula saat kita memakai nama parameter tipe di tanda tangan fungsi, kita harus
mendeklarasikan nama parameter tipe itu sebelum memakainya. Untuk mendefinisikan
fungsi largest yang generic, kita menaruh deklarasi nama tipe di dalam tanda
kurung sudut, <>, antara nama fungsi dan daftar parameter, seperti ini:
fn largest<T>(list: &[T]) -> &T {
Kita membaca definisi ini sebagai “Fungsi largest bersifat generic untuk suatu
tipe T.” Fungsi ini punya satu parameter bernama list, yaitu slice dari nilai-
nilai bertipe T. Fungsi largest akan mengembalikan reference ke sebuah nilai
dengan tipe T yang sama.
Listing 10-5 menampilkan definisi fungsi largest gabungan yang memakai tipe data
generic di tanda tangannya. Listing itu juga menunjukkan cara kita bisa memanggil
fungsi tersebut dengan slice berisi nilai i32 maupun nilai char. Perhatikan
bahwa kode ini belum bisa dikompilasi.
fn largest<T>(list: &[T]) -> &T {
let mut largest = &list[0];
for item in list {
if item > largest {
largest = item;
}
}
largest
}
fn main() {
let number_list = vec![34, 50, 25, 100, 65];
let result = largest(&number_list);
println!("The largest number is {result}");
let char_list = vec!['y', 'm', 'a', 'q'];
let result = largest(&char_list);
println!("The largest char is {result}");
}
largest yang memakai parameter tipe generic; ini belum bisa dikompilasiJika kita mengompilasi kode ini sekarang, kita akan mendapat error ini:
$ cargo run
Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0369]: binary operation `>` cannot be applied to type `&T`
--> src/main.rs:5:17
|
5 | if item > largest {
| ---- ^ ------- &T
| |
| &T
|
help: consider restricting type parameter `T` with trait `PartialOrd`
|
1 | fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> &T {
| ++++++++++++++++++++++
For more information about this error, try `rustc --explain E0369`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error
Teks bantuan menyebut std::cmp::PartialOrd, yang merupakan sebuah trait, dan kita
akan membahas trait di bagian berikutnya. Untuk sementara, ketahuilah bahwa error
ini menyatakan isi fungsi largest tidak akan bekerja untuk semua tipe yang mungkin
dipakai T. Karena kita ingin membandingkan nilai bertipe T di dalam isi fungsi,
kita hanya bisa memakai tipe-tipe yang nilainya bisa diurutkan. Untuk mengaktifkan
perbandingan, pustaka standar menyediakan trait std::cmp::PartialOrd yang bisa
kamu implementasikan pada tipe-tipe (lihat Lampiran C untuk penjelasan lebih lanjut
tentang trait ini). Untuk memperbaiki Listing 10-5, kita bisa mengikuti saran dari
teks bantuan dan membatasi tipe yang sah untuk T hanya pada tipe-tipe yang
mengimplementasikan PartialOrd. Listing itu lalu akan bisa dikompilasi, karena
pustaka standar mengimplementasikan PartialOrd pada i32 maupun char.
Di Dalam Definisi Struct
Kita juga bisa mendefinisikan struct agar memakai parameter tipe generic pada satu
atau lebih field dengan sintaks <>. Listing 10-6 mendefinisikan struct Point<T>
untuk menyimpan nilai koordinat x dan y dari tipe apa pun.
struct Point<T> {
x: T,
y: T,
}
fn main() {
let integer = Point { x: 5, y: 10 };
let float = Point { x: 1.0, y: 4.0 };
}
Point<T> yang menyimpan nilai x dan y bertipe TSintaks untuk memakai generic dalam definisi struct mirip dengan yang dipakai dalam definisi fungsi. Pertama, kita mendeklarasikan nama parameter tipe di dalam tanda kurung sudut tepat setelah nama struct. Lalu, kita memakai tipe generic itu di dalam definisi struct pada tempat-tempat yang seharusnya kita sebutkan tipe data konkret.
Perhatikan bahwa karena kita hanya memakai satu tipe generic untuk mendefinisikan
Point<T>, definisi ini menyatakan bahwa struct Point<T> bersifat generic untuk
suatu tipe T, dan field x serta y keduanya bertipe sama, apa pun tipe itu.
Jika kita membuat instance Point<T> yang nilainya bertipe berbeda, seperti di
Listing 10-7, kode kita tidak akan bisa dikompilasi.
struct Point<T> {
x: T,
y: T,
}
fn main() {
let wont_work = Point { x: 5, y: 4.0 };
}
x dan y harus bertipe sama karena keduanya memakai tipe data generic T yang sama.Pada contoh ini, saat kita menetapkan nilai integer 5 ke x, kita memberi tahu
compiler bahwa tipe generic T akan menjadi integer untuk instance Point<T> ini.
Lalu, saat kita menetapkan 4.0 untuk y, yang telah kita definisikan bertipe sama
dengan x, kita akan mendapat error ketidaksesuaian tipe seperti ini:
$ cargo run
Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0308]: mismatched types
--> src/main.rs:7:38
|
7 | let wont_work = Point { x: 5, y: 4.0 };
| ^^^ expected integer, found floating-point number
For more information about this error, try `rustc --explain E0308`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error
Untuk mendefinisikan struct Point di mana x dan y sama-sama generic tetapi
boleh bertipe berbeda, kita bisa memakai beberapa parameter tipe generic. Misalnya,
di Listing 10-8 kita mengubah definisi Point agar bersifat generic untuk tipe T
dan U, dengan x bertipe T dan y bertipe U.
struct Point<T, U> {
x: T,
y: U,
}
fn main() {
let both_integer = Point { x: 5, y: 10 };
let both_float = Point { x: 1.0, y: 4.0 };
let integer_and_float = Point { x: 5, y: 4.0 };
}
Point<T, U> yang generic untuk dua tipe sehingga x dan y bisa berisi nilai bertipe berbedaSekarang semua instance Point yang ditampilkan diperbolehkan! Kamu bisa memakai
parameter tipe generic sebanyak yang kamu mau dalam sebuah definisi, tetapi memakai
lebih dari beberapa saja bisa membuat kode sulit dibaca. Jika kamu merasa perlu
banyak tipe generic dalam kode, itu bisa jadi tanda bahwa kode perlu dipecah menjadi
bagian-bagian yang lebih kecil.
Di Dalam Definisi Enum
Sama seperti yang kita lakukan pada struct, kita bisa mendefinisikan enum agar
menyimpan tipe data generic di variant-nya. Mari kita lihat sekali lagi enum
Option<T> yang disediakan pustaka standar dan kita pakai di Bab 6:
#![allow(unused)]
fn main() {
enum Option<T> {
Some(T),
None,
}
}
Definisi ini sekarang seharusnya lebih masuk akal bagimu. Seperti yang kamu lihat,
enum Option<T> bersifat generic untuk tipe T dan punya dua variant: Some, yang
menyimpan satu nilai bertipe T, dan variant None yang tidak menyimpan nilai apa
pun. Dengan memakai enum Option<T>, kita bisa menyampaikan konsep abstrak dari
sebuah nilai opsional, dan karena Option<T> itu generic, kita bisa memakai
abstraksi ini tidak peduli apa pun tipe nilai opsionalnya.
Enum juga bisa memakai beberapa tipe generic. Definisi enum Result yang kita pakai
di Bab 9 adalah salah satu contohnya:
#![allow(unused)]
fn main() {
enum Result<T, E> {
Ok(T),
Err(E),
}
}
Enum Result bersifat generic untuk dua tipe, T dan E, dan punya dua variant:
Ok, yang menyimpan nilai bertipe T, dan Err, yang menyimpan nilai bertipe E.
Definisi ini membuat enum Result nyaman dipakai di mana pun kita punya operasi
yang bisa berhasil (mengembalikan nilai dari suatu tipe T) atau gagal
(mengembalikan error dari suatu tipe E). Faktanya, inilah yang kita pakai untuk
membuka file di Listing 9-3, di mana T diisi dengan tipe std::fs::File saat file
berhasil dibuka dan E diisi dengan tipe std::io::Error saat ada masalah saat
membuka file.
Saat kamu mengenali situasi dalam kode di mana ada beberapa definisi struct atau enum yang hanya berbeda pada tipe nilai yang mereka simpan, kamu bisa menghindari duplikasi dengan memakai tipe generic sebagai gantinya.
Di Dalam Definisi Method
Kita bisa mengimplementasikan method pada struct dan enum (seperti yang kita lakukan
di Bab 5) dan memakai tipe generic pula dalam definisinya. Listing 10-9 menampilkan
struct Point<T> yang kita definisikan di Listing 10-6 dengan sebuah method bernama
x yang diimplementasikan padanya.
struct Point<T> {
x: T,
y: T,
}
impl<T> Point<T> {
fn x(&self) -> &T {
&self.x
}
}
fn main() {
let p = Point { x: 5, y: 10 };
println!("p.x = {}", p.x());
}
x pada struct Point<T> yang akan mengembalikan reference ke field x bertipe TDi sini, kita telah mendefinisikan method bernama x pada Point<T> yang
mengembalikan reference ke data di field x.
Perhatikan bahwa kita harus mendeklarasikan T tepat setelah impl agar bisa
memakai T untuk menyatakan bahwa kita mengimplementasikan method pada tipe
Point<T>. Dengan mendeklarasikan T sebagai tipe generic setelah impl, Rust bisa
mengenali bahwa tipe di dalam tanda kurung sudut pada Point adalah tipe generic,
bukan tipe konkret. Kita sebenarnya bisa memilih nama yang berbeda untuk parameter
generic ini dibanding parameter generic yang dideklarasikan dalam definisi struct,
tetapi memakai nama yang sama adalah hal yang lazim. Jika kamu menulis sebuah method
dalam impl yang mendeklarasikan tipe generic, method itu akan didefinisikan pada
semua instance tipe tersebut, tidak peduli tipe konkret apa yang akhirnya
menggantikan tipe generic itu.
Kita juga bisa menentukan batasan pada tipe generic saat mendefinisikan method pada
tipe itu. Misalnya, kita bisa mengimplementasikan method hanya pada instance
Point<f32>, alih-alih pada instance Point<T> dengan tipe generic apa pun. Di
Listing 10-10, kita memakai tipe konkret f32, yang berarti kita tidak
mendeklarasikan tipe apa pun setelah impl.
struct Point<T> {
x: T,
y: T,
}
impl<T> Point<T> {
fn x(&self) -> &T {
&self.x
}
}
impl Point<f32> {
fn distance_from_origin(&self) -> f32 {
(self.x.powi(2) + self.y.powi(2)).sqrt()
}
}
fn main() {
let p = Point { x: 5, y: 10 };
println!("p.x = {}", p.x());
}
impl yang hanya berlaku untuk struct dengan tipe konkret tertentu bagi parameter tipe generic TKode ini berarti tipe Point<f32> akan punya method distance_from_origin;
instance lain dari Point<T> di mana T bukan bertipe f32 tidak akan punya
method ini. Method tersebut mengukur seberapa jauh titik kita dari titik di
koordinat (0.0, 0.0) dan memakai operasi matematika yang hanya tersedia untuk tipe
angka-desimal.
Parameter tipe generic dalam definisi struct tidak selalu sama dengan yang kita
pakai dalam tanda tangan method struct yang sama. Listing 10-11 memakai tipe generic
X1 dan Y1 untuk struct Point serta X2 dan Y2 untuk tanda tangan method
mixup agar contohnya lebih jelas. Method itu membuat instance Point baru dengan
nilai x dari Point self (bertipe X1) dan nilai y dari Point yang
diteruskan (bertipe Y2).
struct Point<X1, Y1> {
x: X1,
y: Y1,
}
impl<X1, Y1> Point<X1, Y1> {
fn mixup<X2, Y2>(self, other: Point<X2, Y2>) -> Point<X1, Y2> {
Point {
x: self.x,
y: other.y,
}
}
}
fn main() {
let p1 = Point { x: 5, y: 10.4 };
let p2 = Point { x: "Hello", y: 'c' };
let p3 = p1.mixup(p2);
println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
}
Di main, kita telah mendefinisikan Point yang x-nya bertipe i32 (dengan nilai
5) dan y-nya bertipe f64 (dengan nilai 10.4). Variabel p2 adalah struct
Point yang x-nya berupa string slice (dengan nilai "Hello") dan y-nya berupa
char (dengan nilai c). Memanggil mixup pada p1 dengan argumen p2 memberi
kita p3, yang akan punya i32 untuk x karena x berasal dari p1. Variabel
p3 akan punya char untuk y karena y berasal dari p2. Pemanggilan macro
println! akan mencetak p3.x = 5, p3.y = c.
Tujuan contoh ini adalah menunjukkan situasi di mana sebagian parameter generic
dideklarasikan dengan impl dan sebagian lagi dideklarasikan bersama definisi
method. Di sini, parameter generic X1 dan Y1 dideklarasikan setelah impl
karena keduanya mengikuti definisi struct. Parameter generic X2 dan Y2
dideklarasikan setelah fn mixup karena keduanya hanya relevan bagi method itu.
Performa Kode yang Memakai Generic
Kamu mungkin bertanya-tanya apakah ada biaya saat runtime saat memakai parameter tipe generic. Kabar baiknya, memakai tipe generic tidak membuat programmu berjalan lebih lambat dibandingkan saat memakai tipe konkret.
Rust mewujudkan hal ini dengan melakukan monomorfisasi pada kode yang memakai generic saat waktu kompilasi. Monomorfisasi adalah proses mengubah kode generic menjadi kode spesifik dengan mengisi tipe-tipe konkret yang dipakai saat dikompilasi. Dalam proses ini, compiler melakukan kebalikan dari langkah-langkah yang kita pakai untuk membuat fungsi generic di Listing 10-5: compiler melihat semua tempat di mana kode generic dipanggil dan menghasilkan kode untuk tipe-tipe konkret yang dipakai saat memanggil kode generic tersebut.
Mari kita lihat cara kerjanya dengan memakai enum generic Option<T> dari pustaka
standar:
#![allow(unused)]
fn main() {
let integer = Some(5);
let float = Some(5.0);
}
Saat Rust mengompilasi kode ini, Rust melakukan monomorfisasi. Selama proses itu,
compiler membaca nilai-nilai yang dipakai dalam instance Option<T> dan mengenali
dua macam Option<T>: salah satunya bertipe i32 dan yang lain bertipe f64.
Dengan demikian, compiler mengembangkan definisi generic Option<T> menjadi dua
definisi yang dikhususkan untuk i32 dan f64, sehingga definisi generic itu
digantikan oleh definisi-definisi spesifik tersebut.
Versi hasil monomorfisasi dari kode itu tampak seperti berikut (compiler memakai nama yang berbeda dari yang kita pakai di sini untuk keperluan ilustrasi):
enum Option_i32 {
Some(i32),
None,
}
enum Option_f64 {
Some(f64),
None,
}
fn main() {
let integer = Option_i32::Some(5);
let float = Option_f64::Some(5.0);
}
Option<T> yang generic digantikan dengan definisi-definisi spesifik yang dibuat
oleh compiler. Karena Rust mengompilasi kode generic menjadi kode yang menyebutkan
tipe di setiap instance, kita tidak membayar biaya runtime apa pun untuk memakai
generic. Saat kode dijalankan, kode itu bekerja persis seperti seandainya kita
menduplikasi setiap definisi secara manual. Proses monomorfisasi inilah yang membuat
generic Rust sangat efisien di runtime.