Trait Lanjutan
Kita pertama kali membahas trait di bagian “Mendefinisikan Perilaku Bersama dengan Trait” pada Bab 10, tetapi belum membahas detail yang lebih lanjut. Sekarang kamu sudah tahu lebih banyak tentang Rust, kita bisa masuk ke seluk-beluknya.
Mendefinisikan Trait dengan Tipe Asosiasi
Tipe asosiasi menghubungkan placeholder tipe dengan sebuah trait sehingga definisi metode trait bisa memakai placeholder tersebut dalam signature-nya. Implementor trait akan menentukan tipe konkret yang dipakai menggantikan placeholder untuk implementasi tertentu. Dengan begitu, kita bisa mendefinisikan trait yang memakai beberapa tipe tanpa perlu tahu persis tipe apa itu sampai trait diimplementasikan.
Kita sudah menyebut sebagian besar fitur lanjutan di bab ini sebagai hal yang jarang dibutuhkan. Tipe asosiasi ada di tengah-tengah: pemakaiannya lebih jarang daripada fitur yang dijelaskan di bagian lain buku ini, tetapi lebih umum daripada banyak fitur lain yang dibahas di bab ini.
Salah satu contoh trait dengan tipe asosiasi adalah trait Iterator yang disediakan pustaka standar. Tipe asosiasinya bernama Item dan mewakili tipe nilai yang diiterasi oleh tipe yang mengimplementasikan trait Iterator. Definisi trait Iterator ditunjukkan pada Listing 20-13.
pub trait Iterator {
type Item;
fn next(&mut self) -> Option<Self::Item>;
}
Iterator yang memiliki tipe asosiasi ItemTipe Item adalah placeholder, dan definisi metode next menunjukkan bahwa metode itu akan mengembalikan nilai bertipe Option<Self::Item>. Implementor trait Iterator akan menentukan tipe konkret untuk Item, lalu metode next akan mengembalikan Option yang berisi nilai bertipe konkret tersebut.
Tipe asosiasi mungkin tampak mirip dengan generic, karena generic juga memungkinkan kita mendefinisikan fungsi tanpa menentukan tipe apa yang bisa ditanganinya. Untuk melihat perbedaan kedua konsep ini, kita akan melihat implementasi trait Iterator pada tipe bernama Counter yang menentukan tipe Item sebagai u32:
struct Counter {
count: u32,
}
impl Counter {
fn new() -> Counter {
Counter { count: 0 }
}
}
impl Iterator for Counter {
type Item = u32;
fn next(&mut self) -> Option<Self::Item> {
// --snip--
if self.count < 5 {
self.count += 1;
Some(self.count)
} else {
None
}
}
}
Sintaks ini tampak mirip dengan sintaks generic. Jadi, kenapa tidak mendefinisikan saja trait Iterator dengan generic, seperti pada Listing 20-14?
pub trait Iterator<T> {
fn next(&mut self) -> Option<T>;
}
Iterator menggunakan genericPerbedaannya adalah saat memakai generic, seperti pada Listing 20-14, kita harus menuliskan anotasi tipe di setiap implementasi; karena kita juga bisa mengimplementasikan Iterator<String> for Counter atau tipe lain, kita bisa punya beberapa implementasi Iterator untuk Counter. Dengan kata lain, ketika sebuah trait memiliki parameter generic, trait itu bisa diimplementasikan berkali-kali untuk satu tipe, dengan mengubah tipe konkret parameter generic tersebut setiap kali. Saat memakai metode next pada Counter, kita harus memberikan anotasi tipe untuk menunjukkan implementasi Iterator mana yang ingin kita pakai.
Dengan tipe asosiasi, kita tidak perlu menganotasi tipe, karena kita tidak bisa mengimplementasikan sebuah trait berkali-kali pada satu tipe. Pada Listing 20-13 dengan definisi yang memakai tipe asosiasi, kita bisa memilih tipe Item hanya sekali karena hanya boleh ada satu impl Iterator for Counter. Kita tidak perlu menyebut bahwa kita menginginkan iterator bernilai u32 di setiap tempat kita memanggil next pada Counter.
Tipe asosiasi juga menjadi bagian dari kontrak trait: implementor trait harus menyediakan sebuah tipe untuk menggantikan placeholder tipe asosiasi. Tipe asosiasi biasanya punya nama yang menggambarkan bagaimana tipe itu akan dipakai, dan mendokumentasikannya dalam dokumentasi API adalah kebiasaan yang baik.
Memakai Parameter Generic Default dan Overloading Operator
Saat memakai parameter tipe generic, kita bisa menentukan tipe konkret default untuk tipe generic tersebut. Ini menghilangkan keharusan bagi implementor trait untuk menyebut tipe konkret jika tipe default sudah cocok. Kamu menentukan tipe default dengan mendeklarasikan tipe generic memakai sintaks <PlaceholderType=ConcreteType>.
Contoh bagus dari situasi teknik ini berguna adalah overloading operator, di mana kamu menyesuaikan perilaku sebuah operator (seperti +) dalam situasi tertentu.
Rust tidak membolehkan kamu membuat operator sendiri atau meng-overload operator sembarangan. Namun, kamu bisa meng-overload operasi dan trait terkait yang tercantum di std::ops dengan mengimplementasikan trait yang bersesuaian dengan operator itu. Misalnya, pada Listing 20-15, kita meng-overload operator + untuk menjumlahkan dua instance Point. Kita melakukan ini dengan mengimplementasikan trait Add pada struct Point.
use std::ops::Add;
#[derive(Debug, Copy, Clone, PartialEq)]
struct Point {
x: i32,
y: i32,
}
impl Add for Point {
type Output = Point;
fn add(self, other: Point) -> Point {
Point {
x: self.x + other.x,
y: self.y + other.y,
}
}
}
fn main() {
assert_eq!(
Point { x: 1, y: 0 } + Point { x: 2, y: 3 },
Point { x: 3, y: 3 }
);
}
Add untuk meng-overload operator + bagi instance PointMetode add menjumlahkan nilai x dari dua instance Point dan nilai y dari dua instance Point untuk membuat Point baru. Trait Add punya tipe asosiasi bernama Output yang menentukan tipe yang dikembalikan dari metode add.
Tipe generic default dalam kode ini ada di dalam trait Add. Berikut definisinya:
#![allow(unused)]
fn main() {
trait Add<Rhs=Self> {
type Output;
fn add(self, rhs: Rhs) -> Self::Output;
}
}
Kode ini seharusnya tampak cukup akrab: sebuah trait dengan satu metode dan satu tipe asosiasi. Bagian yang baru adalah Rhs=Self: sintaks ini disebut parameter tipe default. Parameter tipe generic Rhs (singkatan dari “right-hand side”, sisi kanan) menentukan tipe parameter rhs dalam metode add. Jika kita tidak menentukan tipe konkret untuk Rhs saat mengimplementasikan trait Add, tipe Rhs akan default ke Self, yaitu tipe tempat kita mengimplementasikan Add.
Saat mengimplementasikan Add untuk Point, kita memakai nilai default Rhs karena kita ingin menjumlahkan dua instance Point. Mari kita lihat contoh implementasi trait Add di mana kita ingin menyesuaikan tipe Rhs, bukan memakai nilainya yang default.
Kita punya dua struct, Millimeters dan Meters, yang menyimpan nilai dalam satuan berbeda. Pembungkusan tipis sebuah tipe yang sudah ada ke dalam struct lain ini dikenal sebagai pola newtype, yang kita jelaskan lebih rinci di bagian “Mengimplementasikan Trait Eksternal dengan Pola Newtype”. Kita ingin menjumlahkan nilai dalam millimeter dengan nilai dalam meter dan membiarkan implementasi Add melakukan konversi dengan benar. Kita bisa mengimplementasikan Add untuk Millimeters dengan Meters sebagai Rhs, seperti pada Listing 20-16.
use std::ops::Add;
struct Millimeters(u32);
struct Meters(u32);
impl Add<Meters> for Millimeters {
type Output = Millimeters;
fn add(self, other: Meters) -> Millimeters {
Millimeters(self.0 + (other.0 * 1000))
}
}
Add pada Millimeters untuk menjumlahkan Millimeters dan MetersUntuk menjumlahkan Millimeters dan Meters, kita menulis impl Add<Meters> guna menetapkan nilai parameter tipe Rhs, alih-alih memakai default-nya, Self.
Kamu akan memakai parameter tipe default dengan dua cara utama:
- Untuk mengembangkan sebuah tipe tanpa merusak kode yang sudah ada
- Untuk membolehkan penyesuaian dalam kasus tertentu yang kebanyakan pengguna tidak butuh
Trait Add dari pustaka standar adalah contoh tujuan kedua: biasanya kamu menjumlahkan dua tipe yang sama, tetapi trait Add menyediakan kemampuan untuk menyesuaikan lebih jauh. Memakai parameter tipe default dalam definisi trait Add berarti kamu tidak perlu menyebut parameter tambahan itu hampir sepanjang waktu. Dengan kata lain, sedikit boilerplate implementasi tidak diperlukan, sehingga trait lebih mudah dipakai.
Tujuan pertama mirip dengan yang kedua, tetapi terbalik: jika kamu ingin menambahkan parameter tipe ke trait yang sudah ada, kamu bisa memberinya nilai default agar fungsionalitas trait bisa dikembangkan tanpa merusak kode implementasi yang sudah ada.
Membedakan Metode yang Bernama Sama
Tidak ada dalam Rust yang melarang sebuah trait punya metode dengan nama yang sama dengan metode trait lain, dan Rust juga tidak melarang kamu mengimplementasikan kedua trait pada satu tipe. Kamu juga bisa mengimplementasikan metode langsung pada tipe dengan nama yang sama dengan metode dari trait.
Saat memanggil metode yang bernama sama, kamu perlu memberi tahu Rust mana yang ingin kamu pakai. Perhatikan kode pada Listing 20-17, di mana kita mendefinisikan dua trait, Pilot dan Wizard, yang keduanya punya metode bernama fly. Lalu kita mengimplementasikan kedua trait itu pada tipe Human yang sudah punya metode bernama fly yang diimplementasikan langsung di dalamnya. Setiap metode fly melakukan hal yang berbeda.
trait Pilot {
fn fly(&self);
}
trait Wizard {
fn fly(&self);
}
struct Human;
impl Pilot for Human {
fn fly(&self) {
println!("This is your captain speaking.");
}
}
impl Wizard for Human {
fn fly(&self) {
println!("Up!");
}
}
impl Human {
fn fly(&self) {
println!("*waving arms furiously*");
}
}
fn main() {}
fly dan diimplementasikan pada tipe Human, serta metode fly diimplementasikan langsung pada Human.Saat kita memanggil fly pada instance Human, compiler secara default memanggil metode yang diimplementasikan langsung pada tipe itu, seperti pada Listing 20-18.
trait Pilot {
fn fly(&self);
}
trait Wizard {
fn fly(&self);
}
struct Human;
impl Pilot for Human {
fn fly(&self) {
println!("This is your captain speaking.");
}
}
impl Wizard for Human {
fn fly(&self) {
println!("Up!");
}
}
impl Human {
fn fly(&self) {
println!("*waving arms furiously*");
}
}
fn main() {
let person = Human;
person.fly();
}
fly pada instance HumanMenjalankan kode ini akan mencetak *waving arms furiously*, yang menunjukkan bahwa Rust memanggil metode fly yang diimplementasikan langsung pada Human.
Untuk memanggil metode fly dari trait Pilot maupun trait Wizard, kita perlu memakai sintaks yang lebih eksplisit untuk menentukan metode fly yang kita maksud. Listing 20-19 mendemonstrasikan sintaks ini.
trait Pilot {
fn fly(&self);
}
trait Wizard {
fn fly(&self);
}
struct Human;
impl Pilot for Human {
fn fly(&self) {
println!("This is your captain speaking.");
}
}
impl Wizard for Human {
fn fly(&self) {
println!("Up!");
}
}
impl Human {
fn fly(&self) {
println!("*waving arms furiously*");
}
}
fn main() {
let person = Human;
Pilot::fly(&person);
Wizard::fly(&person);
person.fly();
}
fly dari trait mana yang ingin kita panggilDengan menyebut nama trait sebelum nama metode, kita memperjelas pada Rust implementasi fly mana yang ingin kita panggil. Kita juga bisa menulis Human::fly(&person), yang setara dengan person.fly() yang kita pakai pada Listing 20-19, tetapi penulisannya sedikit lebih panjang jika kita tidak perlu membedakannya.
Menjalankan kode ini mencetak hal berikut:
$ cargo run
Compiling traits-example v0.1.0 (file:///projects/traits-example)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.46s
Running `target/debug/traits-example`
This is your captain speaking.
Up!
*waving arms furiously*
Karena metode fly menerima parameter self, jika kita punya dua tipe yang sama-sama mengimplementasikan satu trait, Rust bisa mengetahui implementasi trait mana yang dipakai berdasarkan tipe self.
Namun, fungsi asosiasi yang bukan metode tidak punya parameter self. Ketika ada beberapa tipe atau trait yang mendefinisikan fungsi bukan-metode dengan nama yang sama, Rust tidak selalu tahu tipe apa yang kamu maksud kecuali kamu memakai sintaks fully qualified. Misalnya, pada Listing 20-20, kita membuat trait untuk tempat penampungan hewan yang ingin memberi semua anak anjing nama Spot. Kita membuat trait Animal dengan fungsi asosiasi bukan-metode baby_name. Trait Animal diimplementasikan untuk struct Dog, di mana kita juga menyediakan fungsi asosiasi bukan-metode baby_name secara langsung.
trait Animal {
fn baby_name() -> String;
}
struct Dog;
impl Dog {
fn baby_name() -> String {
String::from("Spot")
}
}
impl Animal for Dog {
fn baby_name() -> String {
String::from("puppy")
}
}
fn main() {
println!("A baby dog is called a {}", Dog::baby_name());
}
Kita mengimplementasikan kode untuk menamai semua anak anjing Spot dalam fungsi asosiasi baby_name yang didefinisikan pada Dog. Tipe Dog juga mengimplementasikan trait Animal, yang menggambarkan ciri-ciri yang dimiliki semua hewan. Anak anjing disebut puppy, dan hal itu diungkapkan dalam implementasi trait Animal pada Dog, melalui fungsi asosiasi baby_name milik trait Animal.
Di main, kita memanggil fungsi Dog::baby_name, yang memanggil fungsi asosiasi yang didefinisikan langsung pada Dog. Kode ini mencetak hal berikut:
$ cargo run
Compiling traits-example v0.1.0 (file:///projects/traits-example)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.54s
Running `target/debug/traits-example`
A baby dog is called a Spot
Hasil ini bukan yang kita inginkan. Kita ingin memanggil fungsi baby_name yang merupakan bagian dari trait Animal yang kita implementasikan pada Dog, agar kode mencetak A baby dog is called a puppy. Teknik menyebut nama trait yang kita pakai pada Listing 20-19 tidak membantu di sini; jika kita mengubah main menjadi kode pada Listing 20-21, kita akan mendapat error kompilasi.
trait Animal {
fn baby_name() -> String;
}
struct Dog;
impl Dog {
fn baby_name() -> String {
String::from("Spot")
}
}
impl Animal for Dog {
fn baby_name() -> String {
String::from("puppy")
}
}
fn main() {
println!("A baby dog is called a {}", Animal::baby_name());
}
baby_name dari trait Animal, tetapi Rust tidak tahu implementasi mana yang dipakaiKarena Animal::baby_name tidak punya parameter self, dan bisa ada tipe lain yang mengimplementasikan trait Animal, Rust tidak bisa mengetahui implementasi Animal::baby_name mana yang kita inginkan. Kita akan mendapat error compiler ini:
$ cargo run
Compiling traits-example v0.1.0 (file:///projects/traits-example)
error[E0790]: cannot call associated function on trait without specifying the corresponding `impl` type
--> src/main.rs:20:43
|
2 | fn baby_name() -> String;
| ------------------------- `Animal::baby_name` defined here
...
20 | println!("A baby dog is called a {}", Animal::baby_name());
| ^^^^^^^^^^^^^^^^^^^ cannot call associated function of trait
|
help: use the fully-qualified path to the only available implementation
|
20 | println!("A baby dog is called a {}", <Dog as Animal>::baby_name());
| +++++++ +
For more information about this error, try `rustc --explain E0790`.
error: could not compile `traits-example` (bin "traits-example") due to 1 previous error
Untuk membedakan dan memberi tahu Rust bahwa kita ingin memakai implementasi Animal untuk Dog, bukan implementasi Animal untuk tipe lain, kita perlu memakai sintaks fully qualified. Listing 20-22 menunjukkan cara memakai sintaks fully qualified.
trait Animal {
fn baby_name() -> String;
}
struct Dog;
impl Dog {
fn baby_name() -> String {
String::from("Spot")
}
}
impl Animal for Dog {
fn baby_name() -> String {
String::from("puppy")
}
}
fn main() {
println!("A baby dog is called a {}", <Dog as Animal>::baby_name());
}
baby_name dari trait Animal sebagaimana diimplementasikan pada DogKita memberikan anotasi tipe di dalam tanda kurung sudut, yang menandakan kita ingin memanggil metode baby_name dari trait Animal sebagaimana diimplementasikan pada Dog, dengan menyatakan bahwa kita ingin memperlakukan tipe Dog sebagai Animal untuk pemanggilan fungsi ini. Sekarang kode ini akan mencetak apa yang kita inginkan:
$ cargo run
Compiling traits-example v0.1.0 (file:///projects/traits-example)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.48s
Running `target/debug/traits-example`
A baby dog is called a puppy
Secara umum, sintaks fully qualified didefinisikan sebagai berikut:
<Type as Trait>::function(receiver_if_method, next_arg, ...);
Untuk fungsi asosiasi yang bukan metode, tidak akan ada receiver: hanya ada daftar argumen lainnya. Kamu bisa memakai sintaks fully qualified di mana pun kamu memanggil fungsi atau metode. Namun, kamu boleh menghilangkan bagian mana pun dari sintaks ini yang bisa diketahui Rust dari informasi lain dalam program. Kamu hanya perlu memakai sintaks yang lebih panjang ini ketika ada beberapa implementasi dengan nama yang sama dan Rust butuh bantuan untuk mengetahui implementasi mana yang ingin kamu panggil.
Memakai Supertrait
Kadang kamu bisa menulis definisi trait yang bergantung pada trait lain: agar sebuah tipe bisa mengimplementasikan trait pertama, kamu ingin mewajibkan tipe itu juga mengimplementasikan trait kedua. Kamu melakukan ini supaya definisi trait-mu bisa memakai item asosiasi dari trait kedua. Trait yang menjadi sandaran definisi trait-mu disebut supertrait dari trait tersebut.
Misalnya, kita ingin membuat trait OutlinePrint dengan metode outline_print yang mencetak nilai tertentu yang sudah diformat agar berbingkai tanda bintang. Artinya, dengan sebuah struct Point yang mengimplementasikan trait Display dari pustaka standar sehingga menghasilkan (x, y), ketika kita memanggil outline_print pada instance Point yang bernilai 1 untuk x dan 3 untuk y, hasilnya harus seperti ini:
**********
* *
* (1, 3) *
* *
**********
Dalam implementasi metode outline_print, kita ingin memakai fungsionalitas trait Display. Oleh karena itu, kita perlu menentukan bahwa trait OutlinePrint hanya bekerja untuk tipe yang juga mengimplementasikan Display dan menyediakan fungsionalitas yang dibutuhkan OutlinePrint. Kita bisa melakukan itu dalam definisi trait dengan menulis OutlinePrint: Display. Teknik ini mirip dengan menambahkan trait bound pada trait. Listing 20-23 menunjukkan implementasi trait OutlinePrint.
use std::fmt;
trait OutlinePrint: fmt::Display {
fn outline_print(&self) {
let output = self.to_string();
let len = output.len();
println!("{}", "*".repeat(len + 4));
println!("*{}*", " ".repeat(len + 2));
println!("* {output} *");
println!("*{}*", " ".repeat(len + 2));
println!("{}", "*".repeat(len + 4));
}
}
fn main() {}
OutlinePrint yang membutuhkan fungsionalitas dari DisplayKarena kita sudah menentukan bahwa OutlinePrint membutuhkan trait Display, kita bisa memakai fungsi to_string yang otomatis diimplementasikan untuk tipe apa pun yang mengimplementasikan Display. Jika kita mencoba memakai to_string tanpa menambahkan titik dua dan menyebut trait Display setelah nama trait, kita akan mendapat error yang mengatakan bahwa tidak ada metode bernama to_string untuk tipe &Self dalam scope saat ini.
Mari kita lihat apa yang terjadi saat kita mencoba mengimplementasikan OutlinePrint pada tipe yang tidak mengimplementasikan Display, seperti struct Point:
use std::fmt;
trait OutlinePrint: fmt::Display {
fn outline_print(&self) {
let output = self.to_string();
let len = output.len();
println!("{}", "*".repeat(len + 4));
println!("*{}*", " ".repeat(len + 2));
println!("* {output} *");
println!("*{}*", " ".repeat(len + 2));
println!("{}", "*".repeat(len + 4));
}
}
struct Point {
x: i32,
y: i32,
}
impl OutlinePrint for Point {}
fn main() {
let p = Point { x: 1, y: 3 };
p.outline_print();
}
Kita mendapat error yang mengatakan bahwa Display dibutuhkan tetapi tidak diimplementasikan:
$ cargo run
Compiling traits-example v0.1.0 (file:///projects/traits-example)
error[E0277]: `Point` doesn't implement `std::fmt::Display`
--> src/main.rs:20:23
|
20 | impl OutlinePrint for Point {}
| ^^^^^ unsatisfied trait bound
|
help: the trait `std::fmt::Display` is not implemented for `Point`
--> src/main.rs:15:1
|
15 | struct Point {
| ^^^^^^^^^^^^
note: required by a bound in `OutlinePrint`
--> src/main.rs:3:21
|
3 | trait OutlinePrint: fmt::Display {
| ^^^^^^^^^^^^ required by this bound in `OutlinePrint`
error[E0277]: `Point` doesn't implement `std::fmt::Display`
--> src/main.rs:24:7
|
24 | p.outline_print();
| ^^^^^^^^^^^^^ unsatisfied trait bound
|
help: the trait `std::fmt::Display` is not implemented for `Point`
--> src/main.rs:15:1
|
15 | struct Point {
| ^^^^^^^^^^^^
note: required by a bound in `OutlinePrint::outline_print`
--> src/main.rs:3:21
|
3 | trait OutlinePrint: fmt::Display {
| ^^^^^^^^^^^^ required by this bound in `OutlinePrint::outline_print`
4 | fn outline_print(&self) {
| ------------- required by a bound in this associated function
For more information about this error, try `rustc --explain E0277`.
error: could not compile `traits-example` (bin "traits-example") due to 2 previous errors
Untuk memperbaikinya, kita mengimplementasikan Display pada Point dan memenuhi batasan yang dibutuhkan OutlinePrint, seperti ini:
trait OutlinePrint: fmt::Display {
fn outline_print(&self) {
let output = self.to_string();
let len = output.len();
println!("{}", "*".repeat(len + 4));
println!("*{}*", " ".repeat(len + 2));
println!("* {output} *");
println!("*{}*", " ".repeat(len + 2));
println!("{}", "*".repeat(len + 4));
}
}
struct Point {
x: i32,
y: i32,
}
impl OutlinePrint for Point {}
use std::fmt;
impl fmt::Display for Point {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "({}, {})", self.x, self.y)
}
}
fn main() {
let p = Point { x: 1, y: 3 };
p.outline_print();
}
Setelah itu, mengimplementasikan trait OutlinePrint pada Point akan berhasil dikompilasi, dan kita bisa memanggil outline_print pada instance Point untuk menampilkannya di dalam bingkai tanda bintang.
Mengimplementasikan Trait Eksternal dengan Pola Newtype
Di bagian “Mengimplementasikan Trait pada Sebuah Tipe” pada Bab 10, kita menyebut aturan orphan yang menyatakan bahwa kita hanya boleh mengimplementasikan sebuah trait pada sebuah tipe jika trait-nya, tipe-nya, atau keduanya, lokal terhadap crate kita. Kita bisa mengakali pembatasan ini memakai pola newtype, yang melibatkan pembuatan tipe baru dalam tuple struct. (Kita membahas tuple struct di bagian “Membuat Tipe Berbeda dengan Tuple Struct” pada Bab 5.) Tuple struct itu akan punya satu field dan menjadi pembungkusan tipis di sekitar tipe yang ingin kita beri implementasi trait. Dengan begitu, tipe pembungkusnya lokal terhadap crate kita, dan kita bisa mengimplementasikan trait pada pembungkus tersebut. Newtype adalah istilah yang berasal dari bahasa pemrograman Haskell. Pola ini tidak menimbulkan penalti performa saat runtime, dan tipe pembungkusnya dihilangkan pada saat kompilasi.
Sebagai contoh, misalkan kita ingin mengimplementasikan Display pada Vec<T>, yang dicegah langsung oleh aturan orphan karena trait Display dan tipe Vec<T> didefinisikan di luar crate kita. Kita bisa membuat struct Wrapper yang menyimpan instance Vec<T>; lalu, kita bisa mengimplementasikan Display pada Wrapper dan memakai nilai Vec<T> tersebut, seperti pada Listing 20-24.
use std::fmt;
struct Wrapper(Vec<String>);
impl fmt::Display for Wrapper {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[{}]", self.0.join(", "))
}
}
fn main() {
let w = Wrapper(vec![String::from("hello"), String::from("world")]);
println!("w = {w}");
}
Wrapper di sekitar Vec<String> untuk mengimplementasikan DisplayImplementasi Display memakai self.0 untuk mengakses Vec<T> di dalamnya karena Wrapper adalah tuple struct dan Vec<T> adalah item pada indeks 0 dalam tuple itu. Lalu, kita bisa memakai fungsionalitas trait Display pada Wrapper.
Kelemahan teknik ini adalah Wrapper merupakan tipe baru, jadi ia tidak punya metode-metode dari nilai yang disimpannya. Kita harus mengimplementasikan semua metode Vec<T> langsung pada Wrapper sehingga metode-metode itu mendelegasikan ke self.0, yang akan memungkinkan kita memperlakukan Wrapper persis seperti Vec<T>. Jika kita ingin tipe baru itu punya setiap metode yang dimiliki tipe di dalamnya, salah satu solusinya adalah mengimplementasikan trait Deref pada Wrapper untuk mengembalikan tipe dalam tersebut (kita membahas implementasi trait Deref di bagian “Memperlakukan Smart Pointer seperti Reference Biasa” pada Bab 15). Jika kita tidak ingin tipe Wrapper punya semua metode tipe di dalamnya—misalnya, untuk membatasi perilaku tipe Wrapper—kita harus mengimplementasikan secara manual hanya metode yang memang kita inginkan.
Pola newtype ini juga berguna meskipun tidak melibatkan trait. Mari kita mengalihkan fokus dan melihat beberapa cara lanjutan untuk berinteraksi dengan sistem tipe Rust.