Advanced Traits
Traits đã được nhắc đến trong chương 10 “Traits: Defining Shared Behavior”, tuy nhiên đó chỉ là những kiến thức cơ bản nhất của traits mà thôi. Trong chương này, ta sẽ đi sâu hơn vào những tính năng nâng cao của traits.
Sử dụng Associated Types khi định nghĩa Trait
Associated types có thể được sử dụng khi định nghĩa Trait mà khi implement nó ta hoàn toàn biết trước được kiểu dữ liệu mà trait đó muốn sử dụng.
Các tính năng nâng cao khác ở chương này đa số đều ít khi được sử dụng, tuy nhiên associated types lại ở khoảng giữa: nó không được sử dụng quá nhiều như những tính năng khác được mô tả ở trong cuốn sách này nhưng lại được sử dụng phổ biến hơn các tính năng nâng cao khác.
Một ví dụ điển hình của việc sử dụng associated type trong trait là Iterator
của thư viện chuẩn trong Rust. Associated type có tên là Item
ở trong trường hợp này. Trong phần “The Iterator
Trait and the next
Method”, ta đã đề cập đến định nghĩa của Iterator
trait
pub trait Iterator {
type Item;
fn next(&mut self) -> Option<Self::Item>;
}
Listing 19-12: Định nghĩa Iterator
trait sử dụng associated type Item
Kiểu Item
còn được gọi là placeholder type, next
method sẽ trả về một kiểu Option<Self::Item>
. Các struct implement Iterator
này đều sẽ có một kiểu dữ liệu duy nhất và cố định là Item
, next
method làm nhiệm vụ trả về Option
chứa Item đó.
Đến đây ta có thể thấy khá nhiều điểm tương đồng giữa associated type và generics type, vậy tại sao phải sử dụng associated types?
Ví dụ sau sẽ cho ta thấy sự khác biệt giữa 2 cách dùng. Ở chương 13, listing 13-21 sử dụng associated type Item
bằng u32
:
Filename: src/lib.rs
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
}
}
}
Và cú pháp dùng generics được mô tả trong listing 19-13?
pub trait Iterator<T> {
fn next(&mut self) -> Option<T>;
}
Listing 19-13: Đinh nghĩa Iterator
trait sử dụng generics
Sự khác biệt ở đây là khi dùng generics, ta phải chú thích kiểu dữ liệu cho mỗi lần implement; hoàn toàn có thể implement Iterator<String> for Counter
hoặc bất kì kiểu dữ liệu nào khác ngoài u32
, do đó ta có thể có rất nhiều các phiên bản khác nhau của Iterator
cho Counter
. Nói một cách khác, khi một trait sử dụng generics parameter, nó có thể implement rất nhiều lần, thay đổi kiểu dữ liệu cho mỗi lần đó. Khi sử dụng method next
, ta bắt buộc phải cung cấp kiểu dữ liệu để thể hiện Iterator
nào được sử dụng.
Với associated types, ta không cần phải chú thích kiểu dữ liệu như vậy bởi trait này không thể implement nhiều lần, Iterator
chỉ có Item
với kiểu dữ liệu duy nhất là u32
mà thôi.
Tham số Generic Type mặc định và nạp chồng toán tử (Operator Overloading)
Khi sử dụng generic type, ta có thể chỉ định tham số mặc định cho nó. Cú pháp ở đây là <PlaceholderType=ConcreteType>
.
Một ví dụ tuyệt vời nhất cho trường hợp này là khi dùng đến nạp chồng toán tử (operator overloading). Operator overloading dùng để biến tấu hành vi của một toán tử (như là +
) trong vài trường hợp cụ thể.
Rust không cho phép bạn tạo mới một toán tử hay nạp chồng một toán tử bất kì. Tuy nhiên, bạn có thể nạp chồng một toán tử nếu toán tử đó nằm trong thư viện std::ops
bằng cách implement toán tử nằm trong chính thư viện này. Ví dụ trong listing 19-4, ta sẽ nạp chồng toán tử +
để cộng 2 Point
với nhau. Để làm được điều này, ta phải implement Add
trait cho Point
struct:
Filename: src/main.rs
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 } ); }
Listing 19-14: Implementing Add
trait để nạp chồng toán tử +
cho instances Point
Method add
sẽ cộng hoành độ và tung độ tương ứng của 2 Point
. Trait Add
lúc này sẽ có một associated type là Output
.
Generic type mặc định được nằm trong phần định nghĩa Add
trait, như sau:
#![allow(unused)] fn main() { trait Add<Rhs=Self> { type Output; fn add(self, rhs: Rhs) -> Self::Output; } }
Ta có thể thấy phần khác biệt ở đây là Rhs=Self
: cú pháp này được gọi là default type parameters. Rhs
(viết tắt của "right hand side") sẽ định nghĩa kiểu dữ liệu cho biến rhs
được dùng trong method add
. Nếu ta không chỉ định kiểu dữ liệu cho Rhs
khi implement, Rhs
khi đó sẽ mặc định có kiểu Self
.
Khi implement Add
cho Point
, ta sẽ sử dụng kiểu mặc định cho Rhs
vì mục đích cuối cùng là cộng 2 Point
instances. Cùng xem ví dụ mà ở đây ta sẽ implement Add
trait và không sử dụng kiểu mặc định cho Rhs
nữa.
Ở đây có 2 structs, Millimeters
và Meters
, thể hiện giá trị ở các đơn vị đo khác nhau. Các struct này sẽ bao bên ngoài của kiểu dữ liệu đã tồn tại (u32
), cách làm này được gọi là newtype pattern (xem thêm trong phần “Using the Newtype Pattern to Implement External Traits on External Types”). Ở đây ta sẽ cộng giá trị ở đơn vị millimeters với giá trị ở đơn vị meters với việc bắt buộc phải chuyển đổi đơn vị đo.
Filename: src/lib.rs
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))
}
}
Listing 19-15: Implementing Add
trait cho Millimeters
để cộng Millimeters
với Meters
Để làm được điều này, ta sẽ chỉ định impl Add<Meters>
để set giá trị cho tham số Rhs
thay vì dùng tham số mặc định Self
.
Gọi các method có cùng tên
Rust không ngăn cản việc bạn tạo method có cùng tên với method của trait khác, cũng như cấm việc implement 2 trait có cùng một kiểu. Ta hoàn toàn có thể implement một method có cùng tên với các method của các traits khác.
Khi gọi các methods có cùng tên , bạn sẽ cần chỉ ra đâu là method mà bạn cần. Xem xét Listing 19-16 sau đây, có 2 trait là Pilot
và Wizard
đều định nghĩa method fly
. Sau đó implement cả 2 cho kiểu Human
cũng đã có sẵn method là fly
.
Filename: src/main.rs
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() {}
Listing 19-16: Định nghĩa method fly
Khi gọi fly
ở Human
instance, compiler sẽ mặc định gọi method nào được implement trực tiếp, được thể hiện trong Listing 19-17.
Filename: src/main.rs
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(); }
Listing 19-17: Gọi fly
ở instance Human
Kết quả là dòng chữ *waving arms furiously*
được in ra, thể hiện rằng Rust đã gọi fly
trực tiếp từ Human
.
Nếu muốn gọi methods fly
từ Pilot
hoặc Wizard
, ta cần phải khai báo rõ ràng hơn bằng một cú pháp khác trong Listing 19-18.
Filename: src/main.rs
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(); }
Listing 19-18: Chỉ định method fly
nào sẽ được gọi
Sau khi chạy, ta sẽ được kết quả:
$ cargo run
Compiling traits-example v0.1.0 (file:///projects/traits-example)
Finished dev [unoptimized + debuginfo] target(s) in 0.46s
Running `target/debug/traits-example`
This is your captain speaking.
Up!
*waving arms furiously*
Ở đây, method fly
có tham số self
, vì vậy ta có thể truyền person
vào và Rust có thể tìm ra trait nào cần sử dụng trong trường hợp này.
Vậy trong trường hợp sử dụng associated functions (không có tham số self
) thì sao? Rust sẽ không thể biết được bạn cần gọi method của trait nào nếu không sử dụng fully qualified syntax. Xét ví dụ dưới đây:
Filename: src/main.rs
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()); }
Listing 19-19: Gọi một associated function có cùng tên với các associated function của traits khác
Trong hàm main
, hàm Dog::baby_name
được gọi, khi đó ta sẽ có kết quả:
$ cargo run
Compiling traits-example v0.1.0 (file:///projects/traits-example)
Finished dev [unoptimized + debuginfo] target(s) in 0.54s
Running `target/debug/traits-example`
A baby dog is called a Spot
Kết quả này không phải cái ta mong muốn. Hàm baby_name
phải in ra dòng chữ A baby dog is called a puppy
. Do vậy, kĩ thuật được sử dụng trong Listing 19-18 không áp dụng được trong trường hợp này; nếu thay đổi code như là Listing 19-20 thì sao:
Filename: src/main.rs
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());
}
Listing 19-20: Gọi hàm baby_name
từ trait Animal
Vì Animal::baby_name
không có tham số self
, và có thể có các struct khác cũng sẽ implement Animal
trait, do đó Rust không thể biết được hàm Animal::baby_name
sẽ sử dụng implementation nào. Lỗi sẽ như sau:
$ cargo run
Compiling traits-example v0.1.0 (file:///projects/traits-example)
error[E0283]: type annotations needed
--> src/main.rs:20:43
|
20 | println!("A baby dog is called a {}", Animal::baby_name());
| ^^^^^^^^^^^^^^^^^ cannot infer type
|
= note: cannot satisfy `_: Animal`
For more information about this error, try `rustc --explain E0283`.
error: could not compile `traits-example` due to previous error
Vậy để pass qua được lỗi này, cùng xem Listing 19-21:
Filename: src/main.rs
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()); }
Listing 19-21: Sử dụng fully qualified syntax để chỉ định hàm baby_name
được implement từ Dog
sẽ được gọi
Ta sẽ cung cấp cho Rust một kiểu chú thích trong cặp ngoặc <>
, trong đó sẽ chỉ rõ rằng phương thức baby_name
của Animal
trait được implement từ Dog
. Khi đó kết quả sẽ như ta mong muốn:
$ cargo run
Compiling traits-example v0.1.0 (file:///projects/traits-example)
Finished dev [unoptimized + debuginfo] target(s) in 0.48s
Running `target/debug/traits-example`
A baby dog is called a puppy
Một cách tổng quát, fully qualified syntax được định nghĩa như sau:
<Type as Trait>::function(receiver_if_method, next_arg, ...);
Sẽ không có receiver
trong trường hợp đó là một associated functions chứ không phải methods. Bạn có thể sẽ phải sử dụng fully qualified syntax, tuy nhiên hoàn toàn có thể bỏ qua một phải phần nếu Rust có đủ thông tin để tự mình tìm ra được bạn sẽ muốn gọi hàm nào, giống như các ví dụ đã bàn ở trên.
Sử dụng Supertraits để gọi hàm của một trait từ trait khác.
Trong một vài trường hợp, ta cần sử dụng hàm của một trait từ trait khác. Khi đó, bạn cần phải dựa vào supertrait!
Ví dụ, ta có một trait là OutlinePrint
với method outline_print
sẽ in ra màn hình một giá trị với khung bao quanh. Nếu có một struct Point
implement Display
trait, khi gọi method outline_print
với đầu vào x bằng 1 và y bằng 3, ta sẽ có kết quả:
**********
* *
* (1, 3) *
* *
**********
Trong phần cài đặt hàm outline_print
, ta sẽ cần đến hàm ở bên trong Display
trait. Cú pháp ở đây là OutlinePrint::Display
. Xem thêm ở listing 19-22:
Filename: src/main.rs
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() {}
Listing 19-22: Implementing OutlinePrint
trait sử dụng hàm của Display
Do OutlinePrint
yêu cầu sử dụng Display
, ta có thể sử dụng hàm to_string
của Display
trait. Nếu không sử dụng cú pháp :Display
như trên, ta sẽ gặp lỗi no method named to_string
was found for the types &Self
in current scope.
Tuy nhiên, hãy xem điều gì xảy ra nếu ta implement OutlinePrint
cho một struct không implement Display
, ví dụ như Point
:
Filename: src/main.rs
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();
}
Lỗi ở đây do Display
là bắt buộc phải được implement, nhưng Point chưa làm điều đó:
$ 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:6
|
20 | impl OutlinePrint for Point {}
| ^^^^^^^^^^^^ `Point` cannot be formatted with the default formatter
|
= help: the trait `std::fmt::Display` is not implemented for `Point`
= note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead
note: required by a bound in `OutlinePrint`
--> src/main.rs:3:21
|
3 | trait OutlinePrint: fmt::Display {
| ^^^^^^^^^^^^ required by this bound in `OutlinePrint`
For more information about this error, try `rustc --explain E0277`.
error: could not compile `traits-example` due to previous error
Vì vậy, hãy implement Display
cho struct Point
:
Filename: src/main.rs
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(); }
Sử dụng Newtype Pattern để bỏ qua Orphan rule
Trong chương 10 phần “Implementing a Trait on a Type”, ta đã đề cập đến orphan rule, đó là một quy tắc cho phép implement trait cho một type miễn là trait hoặc type đó thuộc crate mà ta đang implement. Tuy nhiên ta hoàn toàn có thể lách luật bằng cách sử dụng newtype pattern, liên quan đến việc tạo một kiểu mới bằng tuple struct. (Đã đề cập đến trong phần “Using Tuple Structs without Named Fields to Create Different Types” của chương 5). Tuple struct này sẽ có 1 trường duy nhất và bọc bên ngoài kiểu mà ta muốn implement (wrapper type). Khi đó wrapper type này sẽ thuộc local của crate và ta hoàn toàn có thể implement trait cho wrapper type này.
Ví dụ, giả sử ta muốn implement Display
cho Vec<T>
, trait và type này đều mắc phải orphan rule (vì đều không nằm trong local của crate), vì vậy ta không thể implement Display
cho Vec<T>
một cách trực tiếp. Ta cần phải tạo một wapper type có tên Wrapper
bao bên ngoài của Vev<T>
; sau đó implement Display
cho Wrapper
, như listing 19-23.
Filename: src/main.rs
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); }
Listing 19-23: Tạo Wrapper
type bao bên ngoài Vec<String>
để implement Display
Ta sẽ sử dụng self.0
để truy cập vào biến Vec<T>
như ví dụ trên.
Với việc sử dụng Wrapper
, ta có thể implement mọi method cho Vec<T>
một cách gián tiếp. Nếu bạn muốn Wapper
có mọi method mà Vec<T>
có, hãy implement Deref
trait (được nói đến ở chương 15 “Treating Smart Pointers Like Regular References with the Deref
Trait”).
Bây giờ bạn đã hiểu về newtype pattern trong Rust rồi đó, nó thực sự hữu dụng khi đừng bên cạnh trait. Và bây giờ, hãy chuyển qua các phần khác trong chương nhé.