นิยามพฤติกรรมร่วมด้วยเทรต
เทรต (trait) ทำหน้าที่กำหนดฟังก์ชันการทำงานที่ประเภทข้อมูลหนึ่งๆ มีและสามารถนำไปแบ่งปันให้กับประเภทข้อมูลอื่นๆ ได้ เราสามารถนำเทรตมาใช้ในการนิยามพฤติกรรมร่วม (shared behavior) ในเชิงนามธรรม และสามารถใช้ บาวด์ของเทรต (trait bounds) เพื่อระบุว่าประเภทข้อมูลแบบเจเนอริกจะเป็นประเภทใดก็ได้ที่มีพฤติกรรมตามที่กำหนด
หมายเหตุ: เทรตมีความคล้ายคลึงกับฟีเจอร์ที่ภาษาโปรแกรมอื่นๆ มักเรียกว่า อินเทอร์เฟซ (interface) แม้ว่าจะมีรายละเอียดปลีกย่อยที่แตกต่างกันอยู่บ้างก็ตาม
การนิยามเทรต
พฤติกรรมของประเภทข้อมูลประกอบไปด้วยเมธอดต่างๆ ที่เราสามารถเรียกใช้งานบนประเภทข้อมูลนั้นได้ และประเภทข้อมูลที่แตกต่างกันจะถือว่ามีพฤติกรรมร่วมกัน หากเราสามารถเรียกใช้เมธอดเดียวกันบนประเภทข้อมูลเหล่านั้นได้ทั้งหมด การนิยามเทรตจึงเป็นเสมือนการจัดกลุ่มลายเซ็นของเมธอด (method signatures) เข้าไว้ด้วยกัน เพื่อกำหนดชุดของพฤติกรรมที่จำเป็นต่อการบรรลุเป้าหมายอย่างใดอย่างหนึ่ง
ตัวอย่างเช่น สมมติว่าเรามี struct หลายตัวที่เก็บข้อความประเภทและปริมาณที่แตกต่างกัน: struct NewsArticle ใช้เก็บข่าวสารที่รายงานมาจากสถานที่ใดที่หนึ่ง และ SocialPost ใช้เก็บข้อความความยาวไม่เกิน 280 ตัวอักษร พร้อมกับข้อมูลเมทาดาตาที่ระบุว่าเป็นโพสต์ใหม่, รีโพสต์ หรือเป็นการตอบกลับโพสต์อื่น
เราต้องการสร้างเครตไลบรารีรวบรวมสื่อชื่อ aggregator ที่สามารถแสดงบทสรุปข้อมูลของสิ่งที่จัดเก็บอยู่ในอินสแตนซ์ของ NewsArticle หรือ SocialPost ได้ ในการทำเช่นนี้ เราจำเป็นต้องดึงบทสรุปออกมาจากแต่ละประเภทข้อมูล โดยการเรียกใช้เมธอด summarize บนอินสแตนซ์นั้นๆ ลิสติ้ง 10-12 แสดงการนิยามเทรตสาธารณะ (public trait) ชื่อ Summary ที่ทำหน้าที่กำหนดพฤติกรรมนี้
pub trait Summary {
fn summarize(&self) -> String;
}
ในตัวอย่างนี้ เราประกาศเทรตโดยใช้คีย์เวิร์ด trait ตามด้วยชื่อของเทรต ซึ่งในที่นี้คือ Summary นอกจากนี้เรายังประกาศให้เทรตนี้เป็น pub เพื่อให้เครตอื่นที่นำเครตนี้ไปใช้เป็น dependency สามารถนำเทรตนี้ไปใช้งานต่อได้ด้วย ดังที่เราจะได้เห็นในตัวอย่างถัดไป ภายในวงเล็บปีกกา เราจะประกาศลายเซ็นของเมธอดที่อธิบายพฤติกรรมของประเภทข้อมูลที่อิมพลีเมนต์เทรตนี้ ซึ่งในที่นี้คือ fn summarize(&self) -> String
สังเกตว่าต่อท้ายลายเซ็นของเมธอด แทนที่เราจะใส่วงเล็บปีกกาเพื่อเขียนโค้ดการทำงาน เรากลับลงท้ายด้วยเครื่องหมายเซมิโคลอน (;) แทน นั่นเพราะประเภทข้อมูลแต่ละประเภทที่อิมพลีเมนต์เทรตนี้จะต้องเป็นผู้กำหนดพฤติกรรมเฉพาะของตนเองลงในเนื้อหาของเมธอด โดยคอมไพเลอร์จะคอยบังคับว่า ประเภทข้อมูลใดก็ตามที่ระบุว่าตนเองมีเทรต Summary จะต้องมีเมธอด summarize ที่มีลายเซ็นตรงตามนี้ทุกประการ
เทรตหนึ่งๆ สามารถบรรจุเมธอดไว้ภายในได้หลายเมธอด โดยระบุลายเซ็นของแต่ละเมธอดไว้บรรทัดละหนึ่งอัน และลงท้ายแต่ละบรรทัดด้วยเซมิโคลอน
การอิมพลีเมนต์เทรตบนชนิดข้อมูล
เมื่อเราได้นิยามลายเซ็นของเมธอดที่ต้องการในเทรต Summary เรียบร้อยแล้ว เราก็สามารถนำมันไปอิมพลีเมนต์ให้กับประเภทข้อมูลต่างๆ ในไลบรารีรวบรวมสื่อของเราได้ ลิสติ้ง 10-13 แสดงการอิมพลีเมนต์เทรต Summary ให้กับ struct NewsArticle โดยนำพาดหัวข่าว, ผู้เขียน และสถานที่มารวมกันเป็นข้อความสรุปของ summarize ส่วนสำหรับ struct SocialPost เรานิยาม summarize ให้ส่งคืนชื่อผู้ใช้ตามด้วยข้อความทั้งหมดของโพสต์ โดยถือว่าเนื้อหาของโพสต์ถูกจำกัดไว้ที่ไม่เกิน 280 ตัวอักษรอยู่แล้ว
pub trait Summary {
fn summarize(&self) -> String;
}
pub struct NewsArticle {
pub headline: String,
pub location: String,
pub author: String,
pub content: String,
}
impl Summary for NewsArticle {
fn summarize(&self) -> String {
format!("{}, by {} ({})", self.headline, self.author, self.location)
}
}
pub struct SocialPost {
pub username: String,
pub content: String,
pub reply: bool,
pub repost: bool,
}
impl Summary for SocialPost {
fn summarize(&self) -> String {
format!("{}: {}", self.username, self.content)
}
}
การอิมพลีเมนต์เทรตให้กับประเภทข้อมูลจะคล้ายคลึงกับการเขียนเมธอดทั่วไปเป็นส่วนใหญ่ จุดที่แตกต่างคือ หลังคำสั่ง impl เราจะระบุชื่อเทรตที่ต้องการอิมพลีเมนต์ ตามด้วยคีย์เวิร์ด for แล้วจึงตามด้วยชื่อของประเภทข้อมูลที่เราต้องการอิมพลีเมนต์เทรตให้ และภายในบล็อก impl เราจะใส่ลายเซ็นของเมธอดตามที่เทรตได้กำหนดไว้ แต่แทนที่จะลงท้ายด้วยเซมิโคลอน เราจะเปิดวงเล็บปีกกาแล้วเขียนเนื้อหาของเมธอดเพื่อกำหนดพฤติกรรมเฉพาะของประเภทข้อมูลนั้นๆ ลงไป
หลังจากที่ไลบรารีได้อิมพลีเมนต์เทรต Summary ให้กับ NewsArticle และ SocialPost เรียบร้อยแล้ว ผู้ใช้งานเครตนี้ก็จะสามารถเรียกใช้เมธอดของเทรตบนอินสแตนซ์ของ NewsArticle และ SocialPost ได้เฉกเช่นเดียวกับการเรียกใช้เมธอดทั่วไป ข้อแตกต่างเพียงอย่างเดียวคือ ผู้ใช้จำเป็นต้อง use ดึงตัวเทรตเข้าสู่ขอบเขต (scope) ร่วมกับประเภทข้อมูลด้วย นี่คือตัวอย่างการใช้งานเครตไลบรารี aggregator จากเครตไบนารีภายนอก:
use aggregator::{SocialPost, Summary};
fn main() {
let post = SocialPost {
username: String::from("horse_ebooks"),
content: String::from(
"of course, as you probably already know, people",
),
reply: false,
repost: false,
};
println!("1 new post: {}", post.summarize());
}
โค้ดนี้จะพิมพ์ 1 new post: horse_ebooks: of course, as you probably already know, people ออกมา
เครตอื่นๆ ที่ดึงเครต aggregator ไปเป็น dependency ก็สามารถนำเทรต Summary เข้าสู่สโคปเพื่อนำไปอิมพลีเมนต์ให้กับประเภทข้อมูลของพวกเขาเองได้เช่นกัน แต่มีข้อจำกัดสำคัญประการหนึ่งที่ต้องรู้ นั่นคือ เราจะสามารถอิมพลีเมนต์เทรตให้กับประเภทข้อมูลใดๆ ได้ก็ต่อเมื่อ เทรต หรือ ประเภทข้อมูลนั้น (อย่างใดอย่างหนึ่ง หรือทั้งคู่) ต้องเป็นของเครตเราเอง (local) ตัวอย่างเช่น เราสามารถอิมพลีเมนต์เทรตของไลบรารีมาตรฐานอย่าง Display ให้กับประเภทข้อมูลที่เราสร้างขึ้นเองอย่าง SocialPost ได้ เพราะ SocialPost เป็นประเภทข้อมูลที่อยู่ในเครต aggregator ของเรา หรือในทางกลับกัน เราก็สามารถอิมพลีเมนต์ Summary ให้กับ Vec<T> ในเครต aggregator ของเราได้ เพราะเทรต Summary เป็นของเครตเรา
ทว่า เราไม่สามารถอิมพลีเมนต์เทรตภายนอกให้กับประเภทข้อมูลภายนอกได้ เช่น เราไม่สามารถอิมพลีเมนต์เทรต Display ให้กับ Vec<T> ภายในเครต aggregator ของเราได้ เพราะทั้ง Display และ Vec<T> ต่างก็ถูกนิยามขึ้นในไลบรารีมาตรฐาน และไม่ได้เป็นของเครต aggregator เลย ข้อจำกัดนี้เป็นส่วนหนึ่งของคุณสมบัติที่เรียกว่า ความสอดคล้อง (coherence) หรือที่รู้จักกันอย่างเจาะจงว่า กฎเด็กกำพร้า (orphan rule) ซึ่งตั้งชื่อตามลักษณะที่ประเภทข้อมูลต้นกำเนิดไม่ได้อยู่ร่วมด้วย กฎนี้ช่วยรับประกันได้ว่า โค้ดของคนอื่นจะไม่สามารถทำให้โค้ดของคุณพัง และโค้ดของคุณก็จะไม่ไปทำให้โค้ดของคนอื่นพังเช่นกัน เพราะหากไม่มีกฎนี้ เครตสองเครตอาจจะต่างคนต่างอิมพลีเมนต์เทรตเดียวกันให้กับประเภทข้อมูลเดียวกัน จนทำให้ Rust สับสนและไม่รู้ว่าจะเลือกใช้การอิมพลีเมนต์ของใคร
การใช้การอิมพลีเมนต์ค่าเริ่มต้น
ในบางสถานการณ์ การกำหนดพฤติกรรมเริ่มต้น (default behavior) ให้กับบางเมธอดหรือทุกเมธอดในเทรตก็มีประโยชน์อย่างมาก แทนที่จะต้องบังคับให้ทุกประเภทข้อมูลต้องมานั่งเขียนโค้ดอิมพลีเมนต์ทุกเมธอดใหม่ทั้งหมด จากนั้นเมื่อเรานำเทรตไปอิมพลีเมนต์ให้กับประเภทข้อมูลใด เราจะเลือกคงพฤติกรรมเริ่มต้นนั้นไว้ หรือจะเขียนทับ (override) พฤติกรรมเริ่มต้นของแต่ละเมธอดก็ได้
ในลิสติ้ง 10-14 เราได้กำหนดข้อความเริ่มต้นให้กับเมธอด summarize ของเทรต Summary แทนที่จะปล่อยว่างไว้เฉพาะลายเซ็นของเมธอดเหมือนในลิสติ้ง 10-12
pub trait Summary {
fn summarize(&self) -> String {
String::from("(Read more...)")
}
}
pub struct NewsArticle {
pub headline: String,
pub location: String,
pub author: String,
pub content: String,
}
impl Summary for NewsArticle {}
pub struct SocialPost {
pub username: String,
pub content: String,
pub reply: bool,
pub repost: bool,
}
impl Summary for SocialPost {
fn summarize(&self) -> String {
format!("{}: {}", self.username, self.content)
}
}
หากต้องการใช้พฤติกรรมเริ่มต้นเพื่อสรุปข้อมูลของอินสแตนซ์ NewsArticle เราเพียงแค่ระบุบล็อก impl ว่างๆ ไว้ว่า impl Summary for NewsArticle {}
แม้ว่าเราจะไม่ได้เขียนเนื้อหาของเมธอด summarize ลงใน NewsArticle โดยตรงอีกต่อไป แต่เนื่องจากเราได้จัดเตรียมการอิมพลีเมนต์ค่าเริ่มต้นไว้แล้ว และได้ประกาศว่า NewsArticle อิมพลีเมนต์เทรต Summary ผลลัพธ์คือเราจึงยังสามารถเรียกใช้เมธอด summarize บนอินสแตนซ์ของ NewsArticle ได้ตามปกติ ดังนี้:
use aggregator::{self, NewsArticle, Summary};
fn main() {
let article = NewsArticle {
headline: String::from("Penguins win the Stanley Cup Championship!"),
location: String::from("Pittsburgh, PA, USA"),
author: String::from("Iceburgh"),
content: String::from(
"The Pittsburgh Penguins once again are the best \
hockey team in the NHL.",
),
};
println!("New article available! {}", article.summarize());
}
โค้ดนี้จะพิมพ์ New article available! (Read more...) ออกมา
การสร้างการอิมพลีเมนต์ค่าเริ่มต้นนี้ ไม่ได้ส่งผลให้เราต้องไปแก้ไขโค้ดการอิมพลีเมนต์ของ Summary บน SocialPost ในลิสติ้ง 10-13 แต่อย่างใด เนื่องจากไวยากรณ์ในการเขียนทับการอิมพลีเมนต์ค่าเริ่มต้นนั้นเหมือนกับไวยากรณ์ในการอิมพลีเมนต์เมธอดของเทรตที่ไม่มีค่าเริ่มต้นทุกประการ
นอกจากนี้ การอิมพลีเมนต์ค่าเริ่มต้นยังสามารถเรียกใช้เมธอดอื่นๆ ภายในเทรตเดียวกันได้ด้วย แม้ว่าเมธอดอื่นๆ เหล่านั้นจะไม่มีการอิมพลีเมนต์ค่าเริ่มต้นก็ตาม ด้วยวิธีนี้ เทรตจะสามารถมอบความสามารถที่มีประโยชน์มากมายได้ โดยต้องการให้ผู้อิมพลีเมนต์เขียนโค้ดเพิ่มเพียงแค่ส่วนเล็กๆ เท่านั้น ตัวอย่างเช่น เราสามารถนิยามเทรต Summary ให้มีเมธอด summarize_author ที่บังคับให้ต้องอิมพลีเมนต์เอง แล้วนิยามเมธอด summarize ที่มีการอิมพลีเมนต์ค่าเริ่มต้นซึ่งเรียกใช้ summarize_author อีกทอดหนึ่ง:
pub trait Summary {
fn summarize_author(&self) -> String;
fn summarize(&self) -> String {
format!("(Read more from {}...)", self.summarize_author())
}
}
pub struct SocialPost {
pub username: String,
pub content: String,
pub reply: bool,
pub repost: bool,
}
impl Summary for SocialPost {
fn summarize_author(&self) -> String {
format!("@{}", self.username)
}
}
เมื่อต้องการใช้งาน Summary เวอร์ชันนี้ เราจึงจำเป็นต้องนิยามเฉพาะเมธอด summarize_author เท่านั้นเมื่ออิมพลีเมนต์เทรตให้กับประเภทข้อมูล:
pub trait Summary {
fn summarize_author(&self) -> String;
fn summarize(&self) -> String {
format!("(Read more from {}...)", self.summarize_author())
}
}
pub struct SocialPost {
pub username: String,
pub content: String,
pub reply: bool,
pub repost: bool,
}
impl Summary for SocialPost {
fn summarize_author(&self) -> String {
format!("@{}", self.username)
}
}
หลังจากที่เรานิยาม summarize_author เสร็จแล้ว เราก็สามารถเรียกใช้ summarize บนอินสแตนซ์ของ struct SocialPost ได้ทันที โดยการอิมพลีเมนต์ค่าเริ่มต้นของ summarize จะไปเรียกการทำงานของ summarize_author ที่เราเขียนไว้ให้เองโดยอัตโนมัติ และเพราะเราได้อิมพลีเมนต์ summarize_author ไปแล้ว เทรต Summary จึงมอบความสามารถของเมธอด summarize ให้เราใช้งานได้ทันทีโดยไม่ต้องเขียนโค้ดเพิ่มเติม นี่คือตัวอย่างการเรียกใช้งาน:
use aggregator::{self, SocialPost, Summary};
fn main() {
let post = SocialPost {
username: String::from("horse_ebooks"),
content: String::from(
"of course, as you probably already know, people",
),
reply: false,
repost: false,
};
println!("1 new post: {}", post.summarize());
}
โค้ดนี้จะพิมพ์ 1 new post: (Read more from @horse_ebooks...) ออกมา
ข้อควรจำคือ เราไม่สามารถเรียกใช้การอิมพลีเมนต์ค่าเริ่มต้นจากภายในเมธอดที่เขียนทับการอิมพลีเมนต์นั้นได้
การใช้เทรตเป็นพารามิเตอร์
เมื่อคุณได้เรียนรู้วิธีการนิยามและอิมพลีเมนต์เทรตแล้ว เรามาดูวิธีการนำเทรตไปใช้เพื่อนิยามฟังก์ชันที่สามารถเปิดรับประเภทข้อมูลที่หลากหลายกันต่อ เราจะนำเทรต Summary ที่เราอิมพลีเมนต์ให้กับประเภท NewsArticle และ SocialPost ในลิสติ้ง 10-13 มาใช้ในการนิยามฟังก์ชัน notify ซึ่งจะเรียกใช้เมธอด summarize บนพารามิเตอร์ item ที่เป็นประเภทข้อมูลใดๆ ก็ตามที่อิมพลีเมนต์เทรต Summary ในการทำเช่นนี้ เราจะใช้ไวยากรณ์ impl Trait ดังนี้:
pub trait Summary {
fn summarize(&self) -> String;
}
pub struct NewsArticle {
pub headline: String,
pub location: String,
pub author: String,
pub content: String,
}
impl Summary for NewsArticle {
fn summarize(&self) -> String {
format!("{}, by {} ({})", self.headline, self.author, self.location)
}
}
pub struct SocialPost {
pub username: String,
pub content: String,
pub reply: bool,
pub repost: bool,
}
impl Summary for SocialPost {
fn summarize(&self) -> String {
format!("{}: {}", self.username, self.content)
}
}
pub fn notify(item: &impl Summary) {
println!("Breaking news! {}", item.summarize());
}
แทนที่จะระบุประเภทข้อมูลรูปธรรมให้กับพารามิเตอร์ item เรากลับใส่คีย์เวิร์ด impl ตามด้วยชื่อเทรต ซึ่งพารามิเตอร์นี้จะยอมรับประเภทข้อมูลใดก็ได้ที่อิมพลีเมนต์เทรตที่ระบุไว้ และภายในเนื้อหาของฟังก์ชัน notify เราจะสามารถเรียกใช้เมธอดใดๆ บน item ที่มาจากเทรต Summary ได้ เช่น summarize ทำให้เราสามารถเรียกใช้ notify โดยส่งอินสแตนซ์ของ NewsArticle หรือ SocialPost เข้ามาได้อย่างอิสระ แต่หากโค้ดใดพยายามเรียกฟังก์ชันนี้ด้วยประเภทข้อมูลอื่น เช่น String หรือ i32 โค้ดนั้นจะไม่สามารถคอมไพล์ผ่านได้ เพราะประเภทเหล่านั้นไม่ได้อิมพลีเมนต์เทรต Summary
ไวยากรณ์บาวด์ของเทรต
ไวยากรณ์ impl Trait นั้นเหมาะกับกรณีที่ตรงไปตรงมา แต่ในความเป็นจริงแล้ว มันคือไวยากรณ์แบบย่อ (syntax sugar) ของรูปแบบที่ยาวกว่าซึ่งเรียกว่า บาวด์ของเทรต (trait bound) โดยมีหน้าตาดังนี้:
pub fn notify<T: Summary>(item: &T) {
println!("Breaking news! {}", item.summarize());
}
รูปแบบที่ยาวกว่านี้ให้ผลลัพธ์เทียบเท่ากับตัวอย่างในหัวข้อก่อนหน้าทุกประการ เพียงแต่มีความยาวกว่า โดยเราจะวางบาวด์ของเทรตไว้ร่วมกับการประกาศพารามิเตอร์ประเภทข้อมูลเจเนอริก ต่อท้ายเครื่องหมายโคลอน (:) ภายในวงเล็บสามเหลี่ยม
ไวยากรณ์ impl Trait ให้ความสะดวกและช่วยให้โค้ดดูกระชับในกรณีง่ายๆ ทว่าไวยากรณ์บาวด์ของเทรตแบบเต็มรูปจะสามารถแสดงความซับซ้อนได้มากกว่าในกรณีอื่นๆ ตัวอย่างเช่น สมมติว่าเรามีสองพารามิเตอร์ที่อิมพลีเมนต์เทรต Summary หากเขียนด้วยไวยากรณ์ impl Trait จะเป็นดังนี้:
pub fn notify(item1: &impl Summary, item2: &impl Summary) {
การใช้ impl Trait เช่นนี้เหมาะสมหากเราต้องการให้ฟังก์ชันเปิดให้ item1 และ item2 เป็นประเภทข้อมูลที่ต่างกันได้ (ตราบใดที่ทั้งคู่ต่างก็อิมพลีเมนต์ Summary) แต่หากเราต้องการบังคับให้พารามิเตอร์ทั้งสองต้องเป็นประเภทข้อมูลเดียวกันเสมอ เราจำเป็นต้องใช้บาวด์ของเทรต ดังนี้:
pub fn notify<T: Summary>(item1: &T, item2: &T) {
การระบุประเภทเจเนอริก T ให้เป็นประเภทของทั้งพารามิเตอร์ item1 และ item2 จะเป็นการกำหนดข้อจำกัดให้กับฟังก์ชันว่า ค่ารูปธรรมที่ส่งเข้ามาเป็นอาร์กิวเมนต์ของ item1 และ item2 จะต้องเป็นประเภทเดียวกันเท่านั้น
บาวด์ของเทรตหลายตัวด้วยไวยากรณ์ +
เรายังสามารถกำหนดบาวด์ของเทรตมากกว่าหนึ่งตัวได้ด้วย สมมติว่าเราต้องการให้ฟังก์ชัน notify สามารถแสดงผลด้วย {} ไปพร้อมๆ กับการเรียกใช้ summarize บน item: เราก็สามารถระบุในนิยามของ notify ได้ว่า item จะต้องอิมพลีเมนต์ทั้งเทรต Display และ Summary โดยใช้ไวยากรณ์เครื่องหมายบวก + ดังนี้:
pub fn notify(item: &(impl Summary + Display)) {
ไวยากรณ์ + นี้ยังสามารถนำไปใช้กับบาวด์ของเทรตบนประเภทเจเนอริกได้เช่นกัน:
pub fn notify<T: Summary + Display>(item: &T) {
เมื่อกำหนดบาวด์ของเทรตทั้งสองตัวเรียบร้อยแล้ว เนื้อหาของฟังก์ชัน notify ก็จะสามารถเรียกใช้ summarize และใช้ {} เพื่อจัดรูปแบบการแสดงผลของ item ได้อย่างถูกต้อง
บาวด์ของเทรตที่ชัดเจนขึ้นด้วยอนุประโยค where
การใส่บาวด์ของเทรตมากเกินไปก็มีข้อเสีย เนื่องจากเจเนอริกแต่ละตัวต่างมีบาวด์ของตนเอง ฟังก์ชันที่มีพารามิเตอร์ประเภทข้อมูลเจเนอริกหลายตัวจึงอาจเต็มไปด้วยข้อกำหนดบาวด์ของเทรตที่อัดแน่นอยู่ระหว่างชื่อฟังก์ชันกับรายการพารามิเตอร์ ซึ่งทำให้ลายเซ็นฟังก์ชันอ่านยากมาก ด้วยเหตุนี้ Rust จึงมีไวยากรณ์ทางเลือกสำหรับระบุบาวด์ของเทรตไว้ภายในอนุประโยค (clause) where หลังลายเซ็นฟังก์ชัน ดังนั้นแทนที่จะเขียนแบบนี้:
fn some_function<T: Display + Clone, U: Clone + Debug>(t: &T, u: &U) -> i32 {
เราสามารถเปลี่ยนมาใช้อนุประโยค where ได้ดังนี้:
fn some_function<T, U>(t: &T, u: &U) -> i32
where
T: Display + Clone,
U: Clone + Debug,
{
unimplemented!()
}
ลายเซ็นของฟังก์ชันนี้จะดูสะอาดตาและเป็นระเบียบขึ้นมาก: ชื่อฟังก์ชัน, รายการพารามิเตอร์ และประเภทส่งกลับจะอยู่ติดกัน คล้ายกับฟังก์ชันทั่วไปที่ไม่ได้มีบาวด์ของเทรตมากมายมารบกวนสายตา
การคืนชนิดข้อมูลที่อิมพลีเมนต์เทรต
เรายังสามารถนำไวยากรณ์ impl Trait ไปใช้ในตำแหน่งของค่าส่งกลับ เพื่อส่งคืนค่าของประเภทข้อมูลใดๆ ที่อิมพลีเมนต์เทรตนั้นได้ด้วย ดังแสดงในตัวอย่างนี้:
pub trait Summary {
fn summarize(&self) -> String;
}
pub struct NewsArticle {
pub headline: String,
pub location: String,
pub author: String,
pub content: String,
}
impl Summary for NewsArticle {
fn summarize(&self) -> String {
format!("{}, by {} ({})", self.headline, self.author, self.location)
}
}
pub struct SocialPost {
pub username: String,
pub content: String,
pub reply: bool,
pub repost: bool,
}
impl Summary for SocialPost {
fn summarize(&self) -> String {
format!("{}: {}", self.username, self.content)
}
}
fn returns_summarizable() -> impl Summary {
SocialPost {
username: String::from("horse_ebooks"),
content: String::from(
"of course, as you probably already know, people",
),
reply: false,
repost: false,
}
}
การระบุ impl Summary เป็นประเภทส่งกลับ เป็นการประกาศว่าฟังก์ชัน returns_summarizable จะส่งคืนค่าของประเภทข้อมูลบางประเภทที่อิมพลีเมนต์เทรต Summary โดยที่เราไม่จำเป็นต้องระบุชื่อประเภทรูปธรรมที่แท้จริง ในกรณีนี้ ฟังก์ชัน returns_summarizable ส่งคืนค่า SocialPost ออกมา แต่โค้ดภายนอกที่เรียกใช้ฟังก์ชันนี้ไม่จำเป็นต้องรู้ถึงรายละเอียดนั้นเลย
ความสามารถในการระบุประเภทส่งกลับด้วยเทรตที่มันอิมพลีเมนต์เพียงอย่างเดียวนั้น มีประโยชน์อย่างยิ่งเมื่อใช้งานร่วมกับโคลเชอร์ (closures) และตัววนซ้ำ (iterators) ซึ่งเราจะกล่าวถึงในบทที่ 13 เนื่องจากโคลเชอร์และตัววนซ้ำมักสร้างประเภทข้อมูลที่มีเพียงคอมไพเลอร์เท่านั้นที่รู้จัก หรือเป็นประเภทข้อมูลที่มีชื่อยาวเหยียดจนเขียนระบุได้ยาก ไวยากรณ์ impl Trait จึงช่วยให้คุณระบุได้อย่างกระชับว่าฟังก์ชันจะส่งคืนประเภทข้อมูลที่อิมพลีเมนต์เทรต Iterator ออกมา โดยไม่ต้องมานั่งพิมพ์ชื่อประเภทข้อมูลที่ยาวเป็นหางว่าว
อย่างไรก็ตาม คุณจะสามารถใช้ impl Trait ได้ก็ต่อเมื่อฟังก์ชันนั้นส่งคืนประเภทข้อมูลเพียงประเภทเดียวเท่านั้น ตัวอย่างเช่น โค้ดที่พยายามส่งคืนค่าไม่เป็น NewsArticle ก็เป็น SocialPost โดยระบุประเภทส่งกลับเป็น impl Summary แบบนี้จะใช้งานไม่ได้:
pub trait Summary {
fn summarize(&self) -> String;
}
pub struct NewsArticle {
pub headline: String,
pub location: String,
pub author: String,
pub content: String,
}
impl Summary for NewsArticle {
fn summarize(&self) -> String {
format!("{}, by {} ({})", self.headline, self.author, self.location)
}
}
pub struct SocialPost {
pub username: String,
pub content: String,
pub reply: bool,
pub repost: bool,
}
impl Summary for SocialPost {
fn summarize(&self) -> String {
format!("{}: {}", self.username, self.content)
}
}
fn returns_summarizable(switch: bool) -> impl Summary {
if switch {
NewsArticle {
headline: String::from(
"Penguins win the Stanley Cup Championship!",
),
location: String::from("Pittsburgh, PA, USA"),
author: String::from("Iceburgh"),
content: String::from(
"The Pittsburgh Penguins once again are the best \
hockey team in the NHL.",
),
}
} else {
SocialPost {
username: String::from("horse_ebooks"),
content: String::from(
"of course, as you probably already know, people",
),
reply: false,
repost: false,
}
}
}
การส่งคืนค่าที่ไม่แน่นอนระหว่าง NewsArticle หรือ SocialPost นั้นไม่ได้รับอนุญาตเนื่องจากข้อจำกัดในการอิมพลีเมนต์ไวยากรณ์ impl Trait ภายในคอมไพเลอร์ ซึ่งเราจะอธิบายวิธีการเขียนฟังก์ชันที่มีพฤติกรรมในลักษณะนี้ในหัวข้อ “การใช้เทรตออบเจกต์เพื่อนามธรรมพฤติกรรมร่วม” ในบทที่ 18
การใช้บาวด์ของเทรตเพื่ออิมพลีเมนต์เมธอดแบบมีเงื่อนไข
การนำบาวด์ของเทรตมาใช้ร่วมกับบล็อก impl ที่ใช้พารามิเตอร์ประเภทข้อมูลเจเนอริก จะช่วยให้เราสามารถอิมพลีเมนต์เมธอดแบบมีเงื่อนไข (conditionally) ให้กับประเภทข้อมูลที่อิมพลีเมนต์เทรตตามที่ระบุไว้ได้ ตัวอย่างเช่น ประเภท Pair<T> ในลิสติ้ง 10-15 จะอิมพลีเมนต์ฟังก์ชัน new เพื่อส่งคืนอินสแตนซ์ใหม่ของ Pair<T> เสมอ (จำได้ไหมจากหัวข้อ “วากยสัมพันธ์ของเมธอด” ในบทที่ 5 ว่า Self เป็นนามแฝงประเภทข้อมูลของบล็อก impl ซึ่งในที่นี้คือ Pair<T>) ทว่าในบล็อก impl ถัดมา Pair<T> จะอิมพลีเมนต์เมธอด cmp_display ก็ต่อเมื่อประเภทข้อมูลภายใน T ของมันอิมพลีเมนต์ทั้งเทรต PartialOrd ที่เปิดใช้งานการเปรียบเทียบ และ เทรต Display ที่เปิดใช้งานการพิมพ์ผลลัพธ์เท่านั้น
use std::fmt::Display;
struct Pair<T> {
x: T,
y: T,
}
impl<T> Pair<T> {
fn new(x: T, y: T) -> Self {
Self { x, y }
}
}
impl<T: Display + PartialOrd> Pair<T> {
fn cmp_display(&self) {
if self.x >= self.y {
println!("The largest member is x = {}", self.x);
} else {
println!("The largest member is y = {}", self.y);
}
}
}
ยิ่งไปกว่านั้น เรายังสามารถอิมพลีเมนต์เทรตแบบมีเงื่อนไขให้กับประเภทข้อมูลใดๆ ก็ตามที่อิมพลีเมนต์เทรตอื่นอยู่แล้วได้ด้วย การอิมพลีเมนต์เทรตให้กับประเภทข้อมูลใดก็ตามที่ผ่านเงื่อนไขของบาวด์ของเทรตเช่นนี้ เรียกว่า การอิมพลีเมนต์แบบครอบคลุม (blanket implementation) ซึ่งถูกนำมาใช้อย่างแพร่หลายในไลบรารีมาตรฐานของ Rust ตัวอย่างเช่น ไลบรารีมาตรฐานจะอิมพลีเมนต์เทรต ToString ให้กับทุกประเภทข้อมูลที่อิมพลีเมนต์เทรต Display โดยบล็อก impl ในไลบรารีมาตรฐานจะมีหน้าตาคล้ายกับโค้ดนี้:
impl<T: Display> ToString for T {
// --snip--
}
และด้วยความที่ไลบรารีมาตรฐานมีการอิมพลีเมนต์แบบครอบคลุมเช่นนี้ เราจึงสามารถเรียกใช้เมธอด to_string ของเทรต ToString บนทุกประเภทข้อมูลที่อิมพลีเมนต์เทรต Display ได้ทันที ตัวอย่างเช่น เราสามารถแปลงจำนวนเต็มให้กลายเป็นค่า String ได้ดังนี้ เพราะประเภทจำนวนเต็มได้อิมพลีเมนต์ Display ไว้แล้ว:
#![allow(unused)]
fn main() {
let s = 3.to_string();
}
การอิมพลีเมนต์แบบครอบคลุมนี้จะปรากฏให้เห็นในเอกสารประกอบของเทรตภายใต้หัวข้อ “Implementors”
เทรตและบาวด์ของเทรตช่วยให้เราสามารถเขียนโค้ดที่ใช้พารามิเตอร์ประเภทข้อมูลเจเนอริกเพื่อลดความซ้ำซ้อน ขณะเดียวกันก็ยังสามารถระบุให้คอมไพเลอร์ทราบได้อย่างแม่นยำว่าเราต้องการให้ประเภทเจเนอริกนั้นมีพฤติกรรมอย่างไร ซึ่งคอมไพเลอร์จะนำข้อมูลบาวด์ของเทรตนี้ไปตรวจสอบว่าประเภทข้อมูลรูปธรรมทั้งหมดที่นำมาใช้กับโค้ดของเรามีพฤติกรรมที่ถูกต้องครบถ้วนหรือไม่ ในภาษาแบบไดนามิก (dynamically typed languages) เราอาจต้องเผชิญกับข้อผิดพลาดในตอนรันไทม์หากเราเผลอเรียกใช้เมธอดบนประเภทข้อมูลที่ไม่ได้นิยามเมธอดนั้นไว้ แต่ Rust ได้เลื่อนการตรวจสอบข้อผิดพลาดเหล่านี้มาไว้ตั้งแต่ตอนคอมไพล์ เพื่อบังคับให้เราแก้ไขปัญหาให้เรียบร้อยตั้งแต่ก่อนที่โค้ดจะสามารถรันได้ด้วยซ้ำ นอกจากนี้ เรายังไม่ต้องเสียเวลาเขียนโค้ดเพื่อตรวจสอบพฤติกรรมในตอนรันไทม์อีก เพราะคอมไพเลอร์ได้ตรวจสอบให้เรียบร้อยแล้ว ซึ่งช่วยเพิ่มประสิทธิภาพการทำงานให้สูงสุดโดยไม่ต้องสูญเสียความยืดหยุ่นของเจเนอริกไปเลย