Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

นิยามพฤติกรรมร่วมด้วยเทรต

เทรต (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 ได้เลื่อนการตรวจสอบข้อผิดพลาดเหล่านี้มาไว้ตั้งแต่ตอนคอมไพล์ เพื่อบังคับให้เราแก้ไขปัญหาให้เรียบร้อยตั้งแต่ก่อนที่โค้ดจะสามารถรันได้ด้วยซ้ำ นอกจากนี้ เรายังไม่ต้องเสียเวลาเขียนโค้ดเพื่อตรวจสอบพฤติกรรมในตอนรันไทม์อีก เพราะคอมไพเลอร์ได้ตรวจสอบให้เรียบร้อยแล้ว ซึ่งช่วยเพิ่มประสิทธิภาพการทำงานให้สูงสุดโดยไม่ต้องสูญเสียความยืดหยุ่นของเจเนอริกไปเลย