เทรตขั้นสูง
เราได้แนะนำให้รู้จักกับเทรต (trait) เป็นครั้งแรกในหัวข้อ“นิยามพฤติกรรมร่วมด้วยเทรต” ในบทที่ 10 แต่ในตอนนั้นเรายังไม่ได้ลงลึกถึงรายละเอียดขั้นสูง เมื่อตอนนี้คุณมีความเข้าใจเกี่ยวกับ Rust มากขึ้นแล้ว เราจึงพร้อมที่จะมาเจาะลึกในรายละเอียดปลีกย่อยกัน
การนิยามเทรตด้วยชนิดข้อมูลที่เชื่อมโยง
ชนิดข้อมูลที่เชื่อมโยง (associated types) ทำหน้าที่เชื่อมตัวแทนชนิดข้อมูล (type placeholder) เข้ากับเทรต เพื่อให้นิยามเมธอดของเทรตสามารถนำชนิดข้อมูลตัวแทนเหล่านี้ไปใช้ในซิกเนเจอร์ได้ โดยผู้ที่อิมพลีเมนต์เทรตจะเป็นผู้ระบุชนิดข้อมูลที่เป็นรูปธรรม (concrete type) ที่จะนำมาใช้งานแทนตัวแทนชนิดข้อมูลสำหรับการอิมพลีเมนต์นั้น ๆ ด้วยวิธีนี้ เราจึงสามารถนิยามเทรตที่ใช้ชนิดข้อมูลบางอย่างได้ โดยไม่จำเป็นต้องรู้ล่วงหน้าว่าชนิดข้อมูลจริง ๆ คืออะไร จนกระทั่งถึงเวลาที่เทรตนั้นถูกนำไปอิมพลีเมนต์
เราได้เกริ่นไว้ว่าฟีเจอร์ขั้นสูงส่วนใหญ่ในบทนี้มักไม่ค่อยได้ใช้งานบ่อยนัก แต่ชนิดข้อมูลที่เชื่อมโยงจะอยู่ตรงกึ่งกลาง กล่าวคือ มีการใช้งานน้อยกว่าฟีเจอร์ทั่วไปที่อธิบายไว้ในส่วนอื่น ๆ ของหนังสือ แต่ก็ยังพบบ่อยกว่าฟีเจอร์ขั้นสูงตัวอื่น ๆ ที่กล่าวถึงในบทนี้
ตัวอย่างหนึ่งของเทรตที่มีชนิดข้อมูลที่เชื่อมโยงคือเทรต Iterator ในไลบรารีมาตรฐาน ชนิดข้อมูลที่เชื่อมโยงนี้มีชื่อว่า Item ซึ่งทำหน้าที่เป็นตัวแทนของชนิดข้อมูลของค่าที่ชนิดข้อมูลผู้อิมพลีเมนต์เทรต Iterator กำลังวนซ้ำอยู่ นิยามของเทรต Iterator มีลักษณะดังที่แสดงในลิสติ้ง 20-13
pub trait Iterator {
type Item;
fn next(&mut self) -> Option<Self::Item>;
}
ชนิดข้อมูล Item เป็นเพียงตัวแทน และนิยามของเมธอด next แสดงให้เห็นว่าจะคืนค่าเป็นชนิด Option<Self::Item> โดยผู้ที่อิมพลีเมนต์เทรต Iterator จะเป็นผู้ระบุชนิดข้อมูลที่เป็นรูปธรรมสำหรับ Item และเมธอด next จะคืนค่า Option ที่บรรจุค่าของชนิดข้อมูลที่เป็นรูปธรรมนั้น
ชนิดข้อมูลที่เชื่อมโยงอาจดูคล้ายกับแนวคิดของเจเนอริก (generics) ตรงที่เปิดให้เรานิยามฟังก์ชันได้โดยไม่ต้องระบุชนิดข้อมูลที่เจาะจงล่วงหน้า เพื่อทำความเข้าใจความแตกต่างระหว่างสองแนวคิดนี้ เราจะมาดูการอิมพลีเมนต์เทรต Iterator บนชนิดข้อมูลที่ชื่อว่า Counter ซึ่งระบุให้ชนิดข้อมูล Item เป็น 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
}
}
}
ไวยากรณ์นี้ดูเทียบเคียงได้กับไวยากรณ์ของเจเนอริก แล้วทำไมเราถึงไม่นิยามเทรต Iterator ด้วยเจเนอริกไปเลยล่ะ ดังที่แสดงในลิสติ้ง 20-14?
pub trait Iterator<T> {
fn next(&mut self) -> Option<T>;
}
ความแตกต่างคือ เมื่อใช้เจเนอริกดังในลิสติ้ง 20-14 เราจะต้องระบุชนิดข้อมูลในการอิมพลีเมนต์แต่ละครั้ง และเนื่องจากเราสามารถอิมพลีเมนต์ Iterator<String> for Counter หรือชนิดข้อมูลอื่นใดก็ได้ เราจึงอาจมีโค้ดการอิมพลีเมนต์ Iterator ให้กับ Counter ได้หลายแบบ กล่าวคือ เมื่อเทรตมีพารามิเตอร์เจเนอริก เทรตนั้นจะสามารถอิมพลีเมนต์ให้กับชนิดข้อมูลหนึ่ง ๆ ได้หลายครั้ง โดยเปลี่ยนชนิดข้อมูลที่เป็นรูปธรรมของพารามิเตอร์เจเนอริกในแต่ละครั้ง ส่งผลให้เวลาที่เราเรียกใช้เมธอด next บน Counter เราจะต้องระบุชนิดข้อมูลกำกับไว้ด้วยเสมอ เพื่อบอกว่าเราต้องการเรียกใช้การอิมพลีเมนต์ของ Iterator ตัวใด
แต่สำหรับชนิดข้อมูลที่เชื่อมโยง เราไม่จำเป็นต้องระบุชนิดข้อมูลกำกับซ้ำ ๆ เพราะเราสามารถอิมพลีเมนต์เทรตบนชนิดข้อมูลหนึ่งได้เพียงครั้งเดียวเท่านั้น ในลิสติ้ง 20-13 ที่ใช้นิยามแบบชนิดข้อมูลที่เชื่อมโยง เราเลือกได้ว่าชนิดข้อมูลของ Item จะเป็นอะไรเพียงครั้งเดียว เนื่องจากมีบล็อก impl Iterator for Counter ได้เพียงบล็อกเดียวเท่านั้น เราจึงไม่จำเป็นต้องระบุว่าต้องการอิเทอเรเตอร์ (iterator) ของค่า u32 ทุกครั้งที่เรียกใช้ next บน Counter
นอกจากนี้ ชนิดข้อมูลที่เชื่อมโยงยังกลายเป็นส่วนหนึ่งของข้อตกลง (contract) ของเทรตด้วย กล่าวคือ ผู้อิมพลีเมนต์เทรตจะต้องเตรียมชนิดข้อมูลจริงมาแทนที่ตัวแทนของชนิดข้อมูลที่เชื่อมโยงเสมอ โดยชนิดข้อมูลที่เชื่อมโยงมักจะมีชื่อที่สื่อถึงการนำไปใช้งาน และการอธิบายรายละเอียดของชนิดข้อมูลที่เชื่อมโยงไว้ในเอกสาร API ก็ถือเป็นแนวทางปฏิบัติที่ดี
การใช้พารามิเตอร์ชนิดข้อมูลเริ่มต้นและการโอเวอร์โหลดตัวดำเนินการ
เมื่อเราใช้พารามิเตอร์ชนิดข้อมูลเจเนอริก เราสามารถกำหนดชนิดข้อมูลที่เป็นรูปธรรมเริ่มต้น (default concrete type) ให้กับชนิดข้อมูลเจเนอริกนั้นได้ ซึ่งจะช่วยให้ผู้ที่อิมพลีเมนต์เทรตไม่จำเป็นต้องระบุชนิดข้อมูลที่เป็นรูปธรรม หากค่าเริ่มต้นนั้นสามารถใช้งานได้อยู่แล้ว คุณสามารถกำหนดชนิดข้อมูลเริ่มต้นเมื่อประกาศชนิดข้อมูลเจเนอริกด้วยไวยากรณ์ <PlaceholderType=ConcreteType>
ตัวอย่างสถานการณ์ที่เห็นประโยชน์ของเทคนิคนี้ได้อย่างชัดเจนคือ การโอเวอร์โหลดตัวดำเนินการ (operator overloading) ซึ่งคุณสามารถปรับแต่งพฤติกรรมการทำงานของตัวดำเนินการ (เช่น +) ในสถานการณ์เฉพาะเจาะจงได้
Rust ไม่อนุญาตให้คุณสร้างตัวดำเนินการขึ้นมาเอง หรือโอเวอร์โหลดตัวดำเนินการใด ๆ ได้ตามใจชอบ แต่คุณสามารถโอเวอร์โหลดการดำเนินการและเทรตที่เกี่ยวข้องซึ่งระบุไว้ใน std::ops ได้ โดยการอิมพลีเมนต์เทรตที่เชื่อมโยงกับตัวดำเนินการนั้น ๆ ตัวอย่างเช่น ในลิสติ้ง 20-15 เราโอเวอร์โหลดตัวดำเนินการ + เพื่อนำอินสแตนซ์ของ Point สองตัวมาบวกเข้าด้วยกัน ซึ่งทำได้โดยการอิมพลีเมนต์เทรต Add ให้กับ 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 นำค่า x ของอินสแตนซ์ Point ทั้งสองตัวมาบวกกัน และนำค่า y ของอินสแตนซ์ Point ทั้งสองตัวมาบวกกัน เพื่อสร้างเป็น Point ตัวใหม่ขึ้นมา เทรต Add มีชนิดข้อมูลที่เชื่อมโยงชื่อ Output ซึ่งทำหน้าที่กำหนดชนิดข้อมูลที่จะถูกส่งกลับคืนมาจากเมธอด add
ชนิดข้อมูลเจเนอริกเริ่มต้นในโค้ดนี้อยู่ภายในเทรต Add โดยมีนิยามดังต่อไปนี้:
#![allow(unused)]
fn main() {
trait Add<Rhs=Self> {
type Output;
fn add(self, rhs: Rhs) -> Self::Output;
}
}
โค้ดนี้น่าจะดูคุ้นเคยเป็นส่วนใหญ่: เป็นเทรตที่มีหนึ่งเมธอดและหนึ่งชนิดข้อมูลที่เชื่อมโยง ส่วนใหม่ที่เพิ่มเข้ามาคือ Rhs=Self: ไวยากรณ์นี้เรียกว่า พารามิเตอร์ชนิดข้อมูลเริ่มต้น (default type parameters) โดยพารามิเตอร์ชนิดข้อมูลเจเนอริก Rhs (ย่อมาจาก “right-hand side” หรือด้านขวามือ) เป็นตัวกำหนดชนิดข้อมูลของพารามิเตอร์ rhs ในเมธอด add หากเราไม่ได้ระบุชนิดข้อมูลที่เป็นรูปธรรมให้กับ Rhs เมื่อเราอิมพลีเมนต์เทรต Add ชนิดข้อมูลของ Rhs จะใช้ค่าเริ่มต้นเป็น Self ซึ่งก็คือชนิดข้อมูลที่เรากำลังอิมพลีเมนต์เทรต Add ให้นั่นเอง
ตอนที่เราอิมพลีเมนต์ Add ให้กับ Point เราใช้ค่าเริ่มต้นของ Rhs เพราะเราต้องการนำอินสแตนซ์ของ Point สองตัวมาบวกกัน คราวนี้มาดูตัวอย่างการอิมพลีเมนต์เทรต Add ในกรณีที่เราต้องการปรับแต่งชนิดข้อมูลของ Rhs แทนที่จะใช้ค่าเริ่มต้นกันบ้าง
สมมติว่าเรามี struct สองตัวคือ Millimeters และ Meters ซึ่งเก็บค่าในหน่วยวัดที่แตกต่างกัน การนำชนิดข้อมูลที่มีอยู่แล้วมาห่อหุ้มไว้ในอีก struct หนึ่งแบบบาง ๆ นี้เป็นที่รู้จักกันในชื่อ รูปแบบนิวไทป์ (newtype pattern) ซึ่งเราจะอธิบายอย่างละเอียดในหัวข้อ“การอิมพลีเมนต์เทรตภายนอกด้วยแพตเทิร์นนิวไทป์” เราต้องการนำค่าในหน่วยมิลลิเมตรมาบวกกับค่าในหน่วยเมตร และให้โค้ดการอิมพลีเมนต์ Add ทำการแปลงหน่วยให้ถูกต้อง เราสามารถอิมพลีเมนต์ Add ให้กับ Millimeters โดยกำหนดให้ Meters เป็น Rhs ได้ ดังที่แสดงในลิสติ้ง 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))
}
}
ในการบวกค่าระหว่าง Millimeters กับ Meters เราระบุเป็น impl Add<Meters> เพื่อกำหนดค่าให้กับพารามิเตอร์ชนิดข้อมูล Rhs แทนที่จะใช้ค่าเริ่มต้นซึ่งเป็น Self
คุณจะได้ใช้งานพารามิเตอร์ชนิดข้อมูลเริ่มต้นใน 2 วัตถุประสงค์หลัก ได้แก่:
- เพื่อต่อขยายชนิดข้อมูลโดยไม่ส่งผลกระทบให้โค้ดเดิมเสียหาย (non-breaking extension)
- เพื่อเปิดโอกาสให้ปรับแต่งได้ในกรณีเฉพาะที่ผู้ใช้ส่วนใหญ่ไม่จำเป็นต้องใช้
เทรต Add ในไลบรารีมาตรฐานเป็นตัวอย่างที่ดีของวัตถุประสงค์ข้อที่สอง: โดยทั่วไปแล้ว คุณมักจะบวกข้อมูลที่มีชนิดเดียวกัน แต่เทรต Add ก็เปิดความสามารถให้ปรับแต่งได้มากกว่านั้น การใช้พารามิเตอร์ชนิดข้อมูลเริ่มต้นในนิยามของเทรต Add ทำให้คุณไม่จำเป็นต้องระบุพารามิเตอร์เสริมในกรณีใช้งานทั่วไป ช่วยลดโค้ดส่วนเกินที่ซ้ำซ้อน (boilerplate) และทำให้เรียกใช้งานเทรตได้สะดวกยิ่งขึ้น
ส่วนวัตถุประสงค์ข้อแรกมีลักษณะคล้ายกันแต่เป็นมุมกลับ: หากคุณต้องการเพิ่มพารามิเตอร์ชนิดข้อมูลให้กับเทรตเดิมที่มีอยู่แล้ว คุณสามารถกำหนดค่าเริ่มต้นให้กับพารามิเตอร์นั้น เพื่อให้สามารถขยายฟังก์ชันการทำงานของเทรตได้โดยไม่ทำให้โค้ดที่อิมพลีเมนต์เทรตเดิมไว้พังทลายลง
การแยกแยะระหว่างเมธอดที่ชื่อเหมือนกัน
ไม่มีสิ่งใดใน Rust ที่ห้ามไม่ให้เทรตหนึ่งมีเมธอดชื่อซ้ำกับเมธอดของเทรตอื่น และ Rust ก็ไม่ได้ห้ามคุณอิมพลีเมนต์ทั้งสองเทรตให้กับชนิดข้อมูลเดียวกัน นอกจากนี้ยังสามารถนิยามเมธอดบนชนิดข้อมูลโดยตรงให้มีชื่อซ้ำกับเมธอดจากเทรตได้อีกด้วย
เมื่อต้องการเรียกใช้เมธอดที่มีชื่อเหมือนกัน คุณจะต้องบอก Rust ให้ชัดเจนว่าคุณต้องการเรียกใช้ตัวไหน ลองพิจารณาโค้ดในลิสติ้ง 20-17 ซึ่งเรานิยามเทรตสองตัวคือ Pilot และ Wizard โดยทั้งคู่ต่างก็มีเมธอดชื่อ fly จากนั้นเราอิมพลีเมนต์ทั้งสองเทรตให้กับชนิดข้อมูล Human ซึ่งมีเมธอดชื่อ fly ที่นิยามไว้บนตัวมันเองโดยตรงอยู่ก่อนแล้ว โดยเมธอด fly แต่ละตัวทำงานแตกต่างกัน
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 บนอินสแตนซ์ของ Human คอมไพเลอร์จะเลือกเรียกเมธอดที่อิมพลีเมนต์บนชนิดข้อมูลโดยตรงเป็นค่าเริ่มต้น ดังที่แสดงในลิสติ้ง 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();
}
การรันโค้ดนี้จะพิมพ์ *waving arms furiously* ออกมา ซึ่งแสดงให้เห็นว่า Rust เรียกใช้เมธอด fly ที่อิมพลีเมนต์ไว้บน Human โดยตรง
หากต้องการเรียกใช้เมธอด fly จากเทรต Pilot หรือเทรต Wizard เราจำเป็นต้องใช้ไวยากรณ์ที่ระบุเจาะจงยิ่งขึ้น เพื่อบ่งบอกว่าเราหมายถึงเมธอด fly ตัวใด ลิสติ้ง 20-19 สาธิตการใช้งานไวยากรณ์นี้
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();
}
การระบุชื่อเทรตนำหน้าชื่อเมธอดทำให้ Rust ทราบชัดเจนว่าเราต้องการเรียกการอิมพลีเมนต์ของ fly ตัวใด นอกจากนี้เรายังสามารถเขียนเป็น Human::fly(&person) ได้ด้วย ซึ่งให้ผลเหมือนกับ person.fly() ในลิสติ้ง 20-19 เพียงแต่วิธีนี้จะเขียนยาวกว่าเล็กน้อยหากเราไม่จำเป็นต้องแยกแยะความกำกวม
เมื่อรันโค้ดนี้จะได้ผลลัพธ์ดังนี้:
$ 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*
เนื่องจากเมธอด fly รับพารามิเตอร์ self หากเรามีสอง_ชนิดข้อมูล_ที่ต่างก็อิมพลีเมนต์_เทรต_เดียวกัน Rust จะสามารถตัดสินใจได้ว่าควรเรียกใช้การอิมพลีเมนต์ของเทรตตัวใด โดยพิจารณาจากชนิดข้อมูลของ self
อย่างไรก็ตาม สำหรับฟังก์ชันที่เชื่อมโยง (associated functions) ซึ่งไม่ใช่เมธอด จะไม่มีพารามิเตอร์ self เมื่อมีหลายชนิดข้อมูลหรือหลายเทรตที่นิยามฟังก์ชันที่ไม่ใช่เมธอดด้วยชื่อเดียวกัน Rust จะไม่สามารถทราบได้เสมอไปว่าคุณหมายถึงฟังก์ชันของชนิดข้อมูลใด เว้นแต่คุณจะใช้ไวยากรณ์แบบระบุชื่อเต็ม (fully qualified syntax) ตัวอย่างเช่น ในลิสติ้ง 20-20 เราสร้างเทรตสำหรับศูนย์พักพิงสัตว์ที่ต้องการตั้งชื่อลูกสุนัขทุกตัวว่า Spot เราสร้างเทรต Animal ที่มีฟังก์ชันเชื่อมโยงที่ไม่ใช่เมธอดชื่อ baby_name จากนั้นเราอิมพลีเมนต์เทรต Animal ให้กับ struct Dog ซึ่งบน Dog เองก็มีฟังก์ชันเชื่อมโยงที่ไม่ใช่เมธอดชื่อ baby_name นิยามไว้โดยตรงเช่นเดียวกัน
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());
}
เราเขียนโค้ดสำหรับตั้งชื่อลูกสุนัขทุกตัวว่า Spot ไว้ในฟังก์ชันเชื่อมโยง baby_name ที่นิยามบน Dog ในขณะเดียวกันชนิดข้อมูล Dog ก็อิมพลีเมนต์เทรต Animal ซึ่งอธิบายลักษณะทั่วไปที่สัตว์ทุกตัวพึงมี โดยลูกสุนัขจะเรียกว่า puppies ซึ่งข้อเท็จจริงนี้ถูกสื่อไว้ในการอิมพลีเมนต์เทรต Animal ให้กับ Dog ผ่านฟังก์ชัน baby_name ที่เชื่อมโยงกับเทรต Animal
ในฟังก์ชัน main เราเรียกใช้ Dog::baby_name ซึ่งจะไปเรียกฟังก์ชันเชื่อมโยงที่นิยามไว้บน Dog โดยตรง โค้ดนี้จะพิมพ์ผลลัพธ์ออกมาดังนี้:
$ 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
ผลลัพธ์นี้ไม่ใช่สิ่งที่เราต้องการ เราต้องการเรียกใช้ฟังก์ชัน baby_name ที่เป็นส่วนหนึ่งของเทรต Animal ตามที่อิมพลีเมนต์ไว้ให้ Dog เพื่อให้พิมพ์ข้อความ A baby dog is called a puppy ออกมา เทคนิคการระบุชื่อเทรตนำหน้าอย่างที่เราใช้ในลิสติ้ง 20-19 ไม่สามารถช่วยในกรณีนี้ได้ หากเราเปลี่ยนโค้ดใน main เป็นลิสติ้ง 20-21 เราจะพบกับข้อผิดพลาดในการคอมไพล์
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());
}
เนื่องจาก Animal::baby_name ไม่มีพารามิเตอร์ self และอาจมีชนิดข้อมูลอื่น ๆ อีกที่อิมพลีเมนต์เทรต Animal ไว้ Rust จึงไม่สามารถคาดเดาได้ว่าเราต้องการเรียกการอิมพลีเมนต์ Animal::baby_name ของชนิดข้อมูลใด เราจึงได้รับข้อผิดพลาดจากคอมไพเลอร์ดังนี้:
$ 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
ในการขจัดความกำกวมและบอกกับ Rust ให้ชัดเจนว่าเราต้องการเรียกใช้การอิมพลีเมนต์ Animal สำหรับ Dog ไม่ใช่การอิมพลีเมนต์ Animal สำหรับชนิดข้อมูลอื่น เราจำเป็นต้องใช้ไวยากรณ์แบบระบุชื่อเต็ม (fully qualified syntax) ลิสติ้ง 20-22 สาธิตวิธีใช้งานไวยากรณ์ดังกล่าว
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());
}
เราได้ระบุชนิดข้อมูลกำกับไว้ภายในเครื่องหมายวงเล็บเหลี่ยมมุม <Dog as Animal> ซึ่งเป็นการบอกกับ Rust ว่าเราต้องการเรียกเมธอด baby_name จากเทรต Animal ตามที่อิมพลีเมนต์ไว้ให้กับ Dog โดยมองชนิดข้อมูล Dog เสมือนเป็น Animal สำหรับการเรียกฟังก์ชันนี้ คราวนี้โค้ดจะพิมพ์ผลลัพธ์ตามที่เราต้องการ:
$ 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
โดยทั่วไปแล้ว ไวยากรณ์แบบระบุชื่อเต็มจะมีโครงสร้างดังนี้:
<Type as Trait>::function(receiver_if_method, next_arg, ...);
สำหรับฟังก์ชันเชื่อมโยงที่ไม่ใช่เมธอด จะไม่มีตัวรับค่า receiver จะมีเพียงรายการอาร์กิวเมนต์อื่น ๆ เท่านั้น คุณสามารถนำไวยากรณ์แบบระบุชื่อเต็มนี้ไปใช้ได้ในทุกที่ที่มีการเรียกฟังก์ชันหรือเมธอด อย่างไรก็ตาม คุณสามารถละเว้นส่วนใดก็ตามของไวยากรณ์นี้ที่ Rust สามารถอนุมานได้เองจากบริบทอื่น ๆ ในโปรแกรม คุณจำเป็นต้องใช้ไวยากรณ์แบบเต็มที่ยาวขึ้นนี้เฉพาะในกรณีที่มีหลายการอิมพลีเมนต์ที่ใช้ชื่อเดียวกัน และตัว Rust ต้องการความช่วยเหลือในการระบุว่าจะเรียกใช้การอิมพลีเมนต์ตัวใดเท่านั้น
การใช้ซูเปอร์เทรต
ในบางครั้งคุณอาจเขียนนิยามเทรตที่ต้องพึ่งพาเทรตอื่น: เพื่อให้ชนิดข้อมูลหนึ่งสามารถอิมพลีเมนต์เทรตแรกได้ คุณต้องการกำหนดให้ชนิดข้อมูลนั้นต้องอิมพลีเมนต์เทรตที่สองด้วยเช่นกัน เหตุผลที่ทำเช่นนี้เพื่อให้โค้ดนิยามเทรตของคุณสามารถดึงรายการที่เชื่อมโยงของเทรตที่สองมาใช้งานได้ โดยเทรตที่เทรตของคุณพึ่งพาอยู่นั้นจะเรียกว่า ซูเปอร์เทรต (supertrait)
ตัวอย่างเช่น สมมติว่าเราต้องการสร้างเทรต OutlinePrint ที่มีเมธอด outline_print ซึ่งจะพิมพ์ค่าที่กำหนดโดยจัดรูปแบบให้อยู่ภายในกรอบเครื่องหมายดอกจัน กล่าวคือ หากมี struct Point ที่อิมพลีเมนต์เทรต Display ของไลบรารีมาตรฐานเพื่อให้ผลลัพธ์เป็น (x, y) เมื่อเราเรียก outline_print บนอินสแตนซ์ Point ที่มีค่า x เป็น 1 และ y เป็น 3 ควรจะพิมพ์ผลลัพธ์ออกมาดังนี้:
**********
* *
* (1, 3) *
* *
**********
ในการอิมพลีเมนต์เมธอด outline_print เราจำเป็นต้องอาศัยฟังก์ชันการทำงานของเทรต Display ดังนั้น เราจึงต้องระบุว่าเทรต OutlinePrint จะใช้งานได้เฉพาะกับชนิดข้อมูลที่อิมพลีเมนต์ Display ร่วมด้วยเท่านั้น เพื่อให้มีฟังก์ชันที่ OutlinePrint ต้องการใช้งาน เราสามารถกำหนดเช่นนั้นได้ในนิยามเทรตด้วยการระบุ OutlinePrint: Display ซึ่งเทคนิคนี้คล้ายกับการเพิ่มข้อกำหนดเทรต (trait bound) ให้กับตัวเทรต ลิสติ้ง 20-23 แสดงการอิมพลีเมนต์เทรต 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 ต้องการเทรต Display เราจึงสามารถเรียกใช้ฟังก์ชัน to_string ที่ได้รับการอิมพลีเมนต์โดยอัตโนมัติสำหรับชนิดข้อมูลใดก็ตามที่อิมพลีเมนต์ Display ได้ หากเราพยายามใช้ to_string โดยไม่ใส่เครื่องหมายโคลอนและระบุเทรต Display ไว้หลังชื่อเทรต เราจะได้รับข้อผิดพลาดแจ้งว่าไม่พบเมธอดชื่อ to_string สำหรับชนิดข้อมูล &Self ในขอบเขตปัจจุบัน
ลองมาดูกันว่าจะเกิดอะไรขึ้นเมื่อเราพยายามอิมพลีเมนต์ OutlinePrint บนชนิดข้อมูลที่ไม่ได้อิมพลีเมนต์ Display เช่น 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();
}
เราจะได้รับข้อผิดพลาดที่ระบุว่าจำเป็นต้องมี Display แต่อิมพลีเมนต์ยังไม่ครบถ้วน:
$ 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
เพื่อแก้ไขปัญหานี้ เราจึงอิมพลีเมนต์ Display ให้กับ Point เพื่อให้เป็นไปตามข้อกำหนดที่ OutlinePrint ต้องการ ดังนี้:
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();
}
หลังจากนั้น การอิมพลีเมนต์เทรต OutlinePrint ให้กับ Point ก็จะคอมไพล์ผ่านได้อย่างราบรื่น และเราสามารถเรียก outline_print บนอินสแตนซ์ของ Point เพื่อแสดงผลภายในกรอบเครื่องหมายดอกจันได้ตามต้องการ
การอิมพลีเมนต์เทรตภายนอกด้วยแพตเทิร์นนิวไทป์
ในหัวข้อ“การอิมพลีเมนต์เทรตบนชนิดข้อมูล” ในบทที่ 10 เราได้กล่าวถึงกฎเด็กกำพร้า (orphan rule) ซึ่งระบุว่าเราจะได้รับอนุญาตให้อิมพลีเมนต์เทรตบนชนิดข้อมูลได้ ก็ต่อเมื่อเทรตหรือชนิดข้อมูลนั้นอย่างใดอย่างหนึ่ง หรือทั้งสองอย่าง เป็นของเครตเราเองเท่านั้น เราสามารถหลีกเลี่ยงข้อจำกัดนี้ได้โดยใช้รูปแบบนิวไทป์ (newtype pattern) ซึ่งเกี่ยวข้องกับการสร้างชนิดข้อมูลใหม่ด้วยทูเพิล struct (เราได้อธิบายทูเพิล struct ไว้ในหัวข้อ“การสร้างชนิดข้อมูลที่แตกต่างกันด้วยทูเพิล struct” ในบทที่ 5) โดยทูเพิล struct นี้จะมีเพียงฟิลด์เดียว ทำหน้าที่เป็นตัวห่อหุ้มแบบบาง ๆ ครอบชนิดข้อมูลที่เราต้องการอิมพลีเมนต์เทรตให้ และเนื่องจากชนิดข้อมูลตัวห่อหุ้มนี้เป็นของเครตเราเอง เราจึงสามารถอิมพลีเมนต์เทรตให้กับตัวห่อหุ้มนี้ได้ คำว่า นิวไทป์ (newtype) มีที่มาจากภาษาการเขียนโปรแกรม Haskell การใช้รูปแบบนี้ไม่มีต้นทุนด้านประสิทธิภาพในตอนรันไทม์แต่อย่างใด เนื่องจากชนิดข้อมูลตัวห่อหุ้มจะถูกตัดทอนออกไปในขั้นตอนการคอมไพล์
ตัวอย่างเช่น สมมติว่าเราต้องการอิมพลีเมนต์ Display ให้กับ Vec<T> ซึ่งกฎออร์แฟนจะไม่อนุญาตให้เราทำได้โดยตรง เนื่องจากทั้งเทรต Display และชนิดข้อมูล Vec<T> ต่างก็ถูกนิยามไว้นอกเครตของเรา เราจึงสามารถสร้าง struct Wrapper ขึ้นมาเพื่อเก็บอินสแตนซ์ของ Vec<T> จากนั้นเราก็สามารถอิมพลีเมนต์ Display ให้กับ Wrapper และนำค่า Vec<T> ภายในไปใช้งานได้ ดังที่แสดงในลิสติ้ง 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}");
}
โค้ดการอิมพลีเมนต์ Display จะใช้ self.0 เพื่อเข้าถึง Vec<T> ที่อยู่ภายใน เนื่องจาก Wrapper เป็นทูเพิล struct และ Vec<T> คือสมาชิกที่ดัชนี 0 ของทูเพิล จากนั้น เราจึงสามารถใช้งานฟังก์ชันการทำงานของเทรต Display บน Wrapper ได้
ข้อเสียของการใช้เทคนิคนี้คือ Wrapper เป็นชนิดข้อมูลใหม่ จึงไม่มีเมธอดเดิมของค่าที่มันห่อหุ้มอยู่ หากต้องการให้ทำงานได้เหมือนเดิม เราจะต้องอิมพลีเมนต์เมธอดทั้งหมดของ Vec<T> ให้กับ Wrapper โดยตรง เพื่อให้เมธอดเหล่านั้นส่งต่อการทำงานไปยัง self.0 ซึ่งจะช่วยให้เราปฏิบัติต่อ Wrapper เสมือนเป็น Vec<T> ได้อย่างสมบูรณ์ หรือหากต้องการให้ชนิดข้อมูลใหม่มีครบทุกเมธอดที่ชนิดข้อมูลภายในมี การอิมพลีเมนต์เทรต Deref ให้กับ Wrapper เพื่อคืนชนิดข้อมูลภายในก็เป็นอีกหนึ่งทางออก (เราได้อธิบายการอิมพลีเมนต์เทรต Deref ไว้ในหัวข้อ“ปฏิบัติกับสมาร์ตพอยน์เตอร์เหมือนเรเฟอเรนซ์ทั่วไป” ในบทที่ 15) แต่หากเราไม่ต้องการให้ชนิดข้อมูล Wrapper มีเมธอดทุกตัวเหมือนชนิดข้อมูลภายใน—ตัวอย่างเช่น เพื่อจำกัดพฤติกรรมของชนิดข้อมูล Wrapper ไม่ให้ทำบางอย่างได้—เราก็เพียงแค่อิมพลีเมนต์เฉพาะเมธอดที่เราต้องการใช้งานจริง ๆ ด้วยตนเอง
รูปแบบนิวไทป์นี้ยังมีประโยชน์อย่างมากแม้ในกรณีที่ไม่เกี่ยวข้องกับเทรตเลยก็ตาม ตอนนี้ขอให้เราสลับความสนใจไปสำรวจแนวทางขั้นสูงในการทำงานร่วมกับระบบชนิดข้อมูลของ Rust กันต่อ