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

อิมพลีเมนต์แพตเทิร์นการออกแบบเชิงวัตถุ

แพตเทิร์นสถานะ (state pattern) เป็นหนึ่งในแบบแผนการออกแบบเชิงวัตถุ หัวใจสำคัญของแพตเทิร์นนี้คือการนิยามชุดของสถานะที่ค่าหนึ่ง ๆ สามารถมีได้ภายในตัว สถานะเหล่านี้จะถูกแทนด้วยชุดของ_ออบเจกต์สถานะ_ (state objects) และพฤติกรรมของค่านั้นจะเปลี่ยนไปตามสถานะที่เป็นอยู่ เราจะมาลงมือทำตัวอย่าง struct โพสต์บล็อกที่มีฟิลด์เก็บสถานะของมัน ซึ่งจะเป็นออบเจกต์สถานะจากชุด “draft” (ฉบับร่าง), “review” (รอตรวจสอบ) หรือ “published” (เผยแพร่แล้ว)

ออบเจกต์สถานะเหล่านี้จะใช้ฟังก์ชันการทำงานร่วมกัน: แน่นอนว่าใน Rust เราจะใช้ struct และเทรต แทนที่จะเป็นออบเจกต์และการสืบทอด ออบเจกต์สถานะแต่ละตัวจะรับผิดชอบพฤติกรรมของตนเองและคอยควบคุมว่าจะเปลี่ยนผ่านไปยังอีกสถานะหนึ่งเมื่อใด โดยที่ค่าตัวนอกที่ถือออบเจกต์สถานะนั้นไว้ ไม่จำเป็นต้องรู้เรื่องพฤติกรรมที่แตกต่างกันของแต่ละสถานะ หรือจังหวะเวลาในการเปลี่ยนสถานะเลย

ข้อดีของการใช้แพตเทิร์นสถานะคือ เมื่อความต้องการทางธุรกิจของโปรแกรมเปลี่ยนไป เราไม่จำเป็นต้องแก้ไขโค้ดของค่าที่เก็บสถานะหรือโค้ดส่วนอื่นที่เรียกใช้ค่านั้นเลย เราเพียงแค่อัปเดตโค้ดภายในออบเจกต์สถานะตัวใดตัวหนึ่งเพื่อปรับเปลี่ยนกฎเกณฑ์ หรือเพิ่มออบเจกต์สถานะใหม่เข้าไปเท่านั้น

ก่อนอื่น เราจะมาอิมพลีเมนต์แพตเทิร์นสถานะในสไตล์เชิงวัตถุแบบดั้งเดิมกันก่อน จากนั้นเราจะขยับไปใช้วิธีการที่เป็นธรรมชาติและเข้ากับ Rust มากกว่าเดิม ลองมาเจาะลึกเพื่ออิมพลีเมนต์เวิร์กโฟลว์ของโพสต์บล็อกโดยใช้แพตเทิร์นสถานะทีละขั้นตอนกัน

ฟังก์ชันการทำงานขั้นสุดท้ายจะมีหน้าตาดังนี้:

  1. โพสต์บล็อกจะเริ่มต้นจากการเป็นแบบร่างที่ว่างเปล่า (empty draft)
  2. เมื่อเขียนแบบร่างเสร็จแล้ว จะมีการส่งคำขอให้ตรวจสอบโพสต์ (request review)
  3. เมื่อโพสต์ได้รับการอนุมัติ (approved) จึงจะถูกเผยแพร่ (published)
  4. มีเพียงโพสต์บล็อกที่เผยแพร่แล้วเท่านั้นที่จะส่งคืนเนื้อหาออกมาพิมพ์ได้ เพื่อป้องกันไม่ให้โพสต์ที่ยังไม่ได้รับอนุมัติถูกเผยแพร่โดยไม่ได้ตั้งใจ

การพยายามเปลี่ยนแปลงอื่นใดนอกเหนือจากนี้กับโพสต์จะต้องไม่มีผลอะไรเกิดขึ้น ตัวอย่างเช่น หากเราพยายามอนุมัติโพสต์บล็อกที่ยังเป็นฉบับร่างอยู่ก่อนที่จะส่งคำขอตรวจสอบ โพสต์นั้นก็จะต้องยังคงเป็นฉบับร่างที่ยังไม่เผยแพร่อยู่เช่นเดิม

การลองใช้สไตล์เชิงวัตถุแบบดั้งเดิม

มีวิธีจัดโครงสร้างโค้ดเพื่อแก้ปัญหาเดียวกันนี้ได้หลากหลายรูปแบบนับไม่ถ้วน โดยแต่ละวิธีก็มีข้อแลกเปลี่ยนที่ต่างกันไป การอิมพลีเมนต์ในหัวข้อนี้จะเน้นไปที่สไตล์เชิงวัตถุแบบดั้งเดิม ซึ่งแม้จะสามารถเขียนใน Rust ได้ แต่ก็ยังไม่ได้ใช้ประโยชน์จากจุดแข็งหลายประการของ Rust อย่างเต็มที่ ในภายหลังเราจะสาธิตอีกวิธีแก้ปัญหาหนึ่งซึ่งยังคงประยุกต์ใช้แบบแผนการออกแบบเชิงวัตถุอยู่ แต่ถูกจัดโครงสร้างในรูปแบบที่อาจดูแปลกตาสำหรับโปรแกรมเมอร์ที่คุ้นชินกับ OOP มาก่อน เราจะเปรียบเทียบวิธีแก้ปัญหาทั้งสองแบบ เพื่อให้เห็นถึงข้อแลกเปลี่ยนในการออกแบบโค้ด Rust ที่แตกต่างไปจากภาษาอื่น ๆ

ลิสติ้ง 18-11 แสดงเวิร์กโฟลว์นี้ในรูปของโค้ด: นี่คือตัวอย่างการใช้งานของ API ที่เราจะอิมพลีเมนต์ในเครตไลบรารี (library crate) ชื่อ blog โค้ดนี้ยังไม่คอมไพล์เพราะเรายังไม่ได้อิมพลีเมนต์เครต blog

use blog::Post;

fn main() {
    let mut post = Post::new();

    post.add_text("I ate a salad for lunch today");
    assert_eq!("", post.content());

    post.request_review();
    assert_eq!("", post.content());

    post.approve();
    assert_eq!("I ate a salad for lunch today", post.content());
}

เราต้องการให้ผู้ใช้สามารถสร้างโพสต์บล็อกฉบับร่างใหม่ด้วย Post::new ได้ และสามารถเพิ่มข้อความลงในโพสต์ได้ หากเราพยายามอ่านเนื้อหาของโพสต์ทันทีก่อนที่จะได้รับการอนุมัติ เราก็ไม่ควรได้รับข้อความใด ๆ ออกมาเลย เพราะโพสต์ยังคงเป็นฉบับร่าง เราได้ใส่ assert_eq! ไว้ในโค้ดเพื่อจุดประสงค์ในการสาธิต โดยการเขียนยูนิตเทสต์ (unit test) ที่เหมาะสมสำหรับกรณีนี้คือการยืนยันว่าโพสต์บล็อกฉบับร่างจะต้องคืนสตริงว่างออกมาจากเมธอด content แต่ในตัวอย่างนี้เราจะไม่เขียนเทสต์จริง ๆ

ถัดไป เราต้องการให้สามารถส่งคำขอตรวจสอบโพสต์ได้ และต้องการให้ content ยังคงคืนสตริงว่างออกมาในระหว่างที่รอการตรวจสอบ และเมื่อโพสต์ได้รับการอนุมัติแล้ว มันก็ควรถูกเผยแพร่ ซึ่งหมายความว่าเมธอด content จะคืนข้อความทั้งหมดของโพสต์กลับมาเมื่อถูกเรียกใช้

โปรดสังเกตว่า ชนิดข้อมูลเดียวที่เรามีปฏิสัมพันธ์ด้วยจากเครตนี้คือชนิดข้อมูล Post ชนิดข้อมูลนี้จะประยุกต์ใช้แพตเทิร์นสถานะและถือค่าที่จะเป็นหนึ่งในสามออบเจกต์สถานะเพื่อแทนสถานะต่าง ๆ ของโพสต์ ได้แก่ draft (ฉบับร่าง), review (รอตรวจสอบ) หรือ published (เผยแพร่แล้ว) การเปลี่ยนผ่านจากสถานะหนึ่งไปยังอีกสถานะหนึ่งจะถูกจัดการอยู่ภายในชนิดข้อมูล Post ทั้งหมด สถานะจะเปลี่ยนไปตามเมธอดต่าง ๆ ที่ผู้ใช้ไลบรารีเรียกใช้บนอินสแตนซ์ของ Post โดยที่ผู้ใช้ไม่ต้องมาคอยจัดการการเปลี่ยนสถานะด้วยตนเอง นอกจากนี้ ผู้ใช้ยังไม่สามารถสร้างข้อผิดพลาดเกี่ยวกับสถานะได้ เช่น การเผยแพร่โพสต์ก่อนที่มันจะผ่านการตรวจสอบ

การนิยาม Post และการสร้างอินสแตนซ์ใหม่

มาเริ่มลงมืออิมพลีเมนต์ไลบรารีกันเลย! เรารู้ว่าเราต้องการ struct Post แบบพับลิกที่เก็บเนื้อหาเอาไว้ ดังนั้นเราจึงเริ่มต้นด้วยนิยามของ struct และฟังก์ชันแอสโซซิเอตแบบพับลิก new เพื่อสร้างอินสแตนซ์ของ Post ดังแสดงในลิสติ้ง 18-12 นอกจากนี้เรายังสร้างเทรต State แบบไพรเวตขึ้นมา เพื่อกำหนดพฤติกรรมร่วมที่ออบเจกต์สถานะทั้งหมดของ Post จำเป็นต้องมี

จากนั้น Post จะเก็บเทรตออบเจกต์ Box<dyn State> ไว้ภายใน Option<T> ในฟิลด์ไพรเวตชื่อ state เพื่อถือออบเจกต์สถานะนั้นไว้ เดี๋ยวคุณจะได้เห็นว่าทำไม Option<T> จึงจำเป็นในอีกสักครู่

pub struct Post {
    state: Option<Box<dyn State>>,
    content: String,
}

impl Post {
    pub fn new() -> Post {
        Post {
            state: Some(Box::new(Draft {})),
            content: String::new(),
        }
    }
}

trait State {}

struct Draft {}

impl State for Draft {}

เทรต State จะนิยามพฤติกรรมร่วมกันระหว่างสถานะต่าง ๆ ของโพสต์ โดยออบเจกต์สถานะได้แก่ Draft, PendingReview และ Published ซึ่งทั้งหมดนี้จะต้องอิมพลีเมนต์เทรต State ในตอนนี้ ตัวเทรตยังไม่มีเมธอดใด ๆ และเราจะเริ่มต้นด้วยการนิยามเฉพาะสถานะ Draft ก่อน เพราะเป็นสถานะเริ่มต้นของโพสต์

เมื่อเราสร้าง Post ขึ้นมาใหม่ เราจะกำหนดค่าฟิลด์ state ให้เป็น Some ที่บรรจุ Box เอาไว้ โดย Box นี้จะชี้ไปยังอินสแตนซ์ใหม่ของ struct Draft สิ่งนี้รับประกันว่าเมื่อใดก็ตามที่เราสร้างอินสแตนซ์ Post ใหม่ โพสต์นั้นจะเริ่มต้นเป็นแบบร่างเสมอ และเนื่องจากฟิลด์ state ของ Post เป็นแบบไพรเวต จึงไม่มีทางเลยที่จะสร้าง Post ในสถานะอื่นขึ้นมาได้โดยตรง! ในฟังก์ชัน Post::new เรายังได้กำหนดฟิลด์ content ให้เป็น String เปล่าตัวใหม่อีกด้วย

การจัดเก็บข้อความของเนื้อหาของโพสต์

จากลิสติ้ง 18-11 เราเห็นว่าเราต้องการเรียกใช้เมธอดชื่อ add_text พร้อมส่ง &str เข้าไปเพื่อเพิ่มข้อความลงในเนื้อหาของโพสต์บล็อก เราเลือกที่จะอิมพลีเมนต์สิ่งนี้เป็นเมธอด แทนที่จะเปิดฟิลด์ content ให้เป็น pub เพื่อให้เราสามารถเขียนเมธอดที่คอยควบคุมวิธีการอ่านข้อมูลจากฟิลด์ content ในภายหลังได้ เมธอด add_text ค่อนข้างตรงไปตรงมา เราจึงเพิ่มการอิมพลีเมนต์ในลิสติ้ง 18-13 เข้าไปในบล็อก impl Post

pub struct Post {
    state: Option<Box<dyn State>>,
    content: String,
}

impl Post {
    // --snip--
    pub fn new() -> Post {
        Post {
            state: Some(Box::new(Draft {})),
            content: String::new(),
        }
    }

    pub fn add_text(&mut self, text: &str) {
        self.content.push_str(text);
    }
}

trait State {}

struct Draft {}

impl State for Draft {}

เมธอด add_text จะรับเรเฟอเรนซ์แบบเปลี่ยนแปลงค่าได้ของ self เพราะเราจำเป็นต้องแก้ไขอินสแตนซ์ของ Post ที่เรียกใช้ add_text จากนั้นเราจะเรียก push_str บน String ในฟิลด์ content โดยส่งอาร์กิวเมนต์ text เข้าไปเพื่อต่อท้ายข้อความเดิม พฤติกรรมนี้ไม่ได้ขึ้นอยู่กับว่าโพสต์อยู่ในสถานะใด จึงไม่ได้เป็นส่วนหนึ่งของแพตเทิร์นสถานะ และเมธอด add_text ก็ไม่ได้ยุ่งเกี่ยวกับฟิลด์ state เลย เพียงแต่มันเป็นหนึ่งในพฤติกรรมที่เราต้องการรองรับการทำงาน

การตรวจสอบให้แน่ใจว่าเนื้อหาของโพสต์ฉบับร่างว่างเปล่า

แม้หลังจากที่เราเรียก add_text และเพิ่มข้อความลงในโพสต์ไปแล้ว เราก็ยังคงต้องการให้เมธอด content คืนค่าสตริงสไลซ์ (string slice) ที่ว่างเปล่ากลับมา เพราะโพสต์ยังอยู่ในสถานะฉบับร่าง ดังที่แสดงใน assert_eq! ตัวแรกของลิสติ้ง 18-11 ในตอนนี้ เรามาอิมพลีเมนต์เมธอด content ด้วยวิธีที่เรียบง่ายที่สุดเพื่อตอบโจทย์นี้กันก่อน: นั่นคือการคืนสตริงสไลซ์ว่างเปล่าเสมอ แล้วค่อยกลับมาแก้ไขในภายหลังเมื่อเราอิมพลีเมนต์ความสามารถในการเปลี่ยนสถานะของโพสต์จนเผยแพร่ได้สำเร็จ เมื่อโพสต์ยังอยู่ในสถานะฉบับร่างได้เพียงอย่างเดียว เนื้อหาของมันจึงควรว่างเปล่าเสมอ ลิสติ้ง 18-14 แสดงการอิมพลีเมนต์ชั่วคราวนี้

pub struct Post {
    state: Option<Box<dyn State>>,
    content: String,
}

impl Post {
    // --snip--
    pub fn new() -> Post {
        Post {
            state: Some(Box::new(Draft {})),
            content: String::new(),
        }
    }

    pub fn add_text(&mut self, text: &str) {
        self.content.push_str(text);
    }

    pub fn content(&self) -> &str {
        ""
    }
}

trait State {}

struct Draft {}

impl State for Draft {}

ด้วยเมธอด content ที่เพิ่มเข้ามานี้ ทุกอย่างในลิสติ้ง 18-11 จนถึง assert_eq! ตัวแรกก็ทำงานได้ตามที่ตั้งใจไว้

การขอให้ตรวจสอบ ซึ่งเปลี่ยนสถานะของโพสต์

ถัดไป เราต้องเพิ่มฟังก์ชันการทำงานสำหรับขอให้ตรวจสอบโพสต์ ซึ่งควรเปลี่ยนสถานะจาก Draft ไปเป็น PendingReview ลิสติ้ง 18-15 แสดงโค้ดในส่วนนี้

pub struct Post {
    state: Option<Box<dyn State>>,
    content: String,
}

impl Post {
    // --snip--
    pub fn new() -> Post {
        Post {
            state: Some(Box::new(Draft {})),
            content: String::new(),
        }
    }

    pub fn add_text(&mut self, text: &str) {
        self.content.push_str(text);
    }

    pub fn content(&self) -> &str {
        ""
    }

    pub fn request_review(&mut self) {
        if let Some(s) = self.state.take() {
            self.state = Some(s.request_review())
        }
    }
}

trait State {
    fn request_review(self: Box<Self>) -> Box<dyn State>;
}

struct Draft {}

impl State for Draft {
    fn request_review(self: Box<Self>) -> Box<dyn State> {
        Box::new(PendingReview {})
    }
}

struct PendingReview {}

impl State for PendingReview {
    fn request_review(self: Box<Self>) -> Box<dyn State> {
        self
    }
}

เราเพิ่มพับลิกเมธอดชื่อ request_review ให้กับ Post ซึ่งจะรับเรเฟอเรนซ์แบบเปลี่ยนแปลงค่าได้ของ self จากนั้นเราจะเรียกใช้เมธอด request_review ภายในบนสถานะปัจจุบันของ Post โดยเมธอด request_review ตัวที่สองนี้จะบริโภค (consume) สถานะปัจจุบันแล้วส่งคืนสถานะใหม่ออกมา

เราเพิ่มเมธอด request_review เข้าไปในเทรต State ดังนั้นทุกชนิดข้อมูลที่อิมพลีเมนต์เทรตนี้จะต้องมีเมธอด request_review ด้วย โปรดสังเกตว่า แทนที่จะใช้ self, &self หรือ &mut self เป็นพารามิเตอร์ตัวแรกของเมธอด เรากลับใช้ self: Box<Self> ไวยากรณ์นี้หมายความว่า เมธอดนี้จะเรียกใช้ได้เฉพาะเมื่อถูกเรียกบน Box ที่ถือชนิดข้อมูลนั้นอยู่เท่านั้น และไวยากรณ์นี้จะรับความเป็นเจ้าของ (ownership) Box<Self> ไป ทำให้สถานะเดิมใช้งานไม่ได้อีก เพื่อเปิดทางให้ค่าสถานะของ Post แปลงร่างไปเป็นสถานะใหม่

ในการบริโภคสถานะเดิม เมธอด request_review จำเป็นต้องรับความเป็นเจ้าของค่าของสถานะนั้น นี่คือจุดที่ Option ในฟิลด์ state ของ Post เข้ามามีบทบาทสำคัญ: เราจะเรียกเมธอด take เพื่อดึงค่า Some ออกจากฟิลด์ state แล้ววางค่า None ไว้แทนที่ เพราะ Rust ไม่อนุญาตให้เราปล่อยฟิลด์ใน struct ว่างเปล่าโดยไม่มีค่า สิ่งนี้ช่วยให้เราย้ายค่า (move) ของ state ออกจาก Post ได้แทนที่จะเป็นการยืม จากนั้นเราจะกำหนดค่า state ของโพสต์ให้เป็นผลลัพธ์ที่ได้จากการดำเนินการนี้

เราจำเป็นต้องตั้งค่า state ให้เป็น None ชั่วคราว แทนที่จะกำหนดค่าทับไปตรง ๆ ด้วยโค้ดอย่าง self.state = self.state.request_review(); เพื่อให้ได้รับความเป็นเจ้าของค่าของ state มา สิ่งนี้รับประกันว่า Post จะไม่สามารถนำค่า state เดิมกลับมาใช้ได้อีกหลังจากที่เราแปลงมันไปเป็นสถานะใหม่แล้ว

เมธอด request_review บน Draft จะคืนอินสแตนซ์ใหม่ที่อยู่ในบ็อกซ์ของ struct PendingReview ซึ่งเป็นตัวแทนของสถานะที่โพสต์กำลังรอการตรวจสอบ ส่วน struct PendingReview ก็อิมพลีเมนต์เมธอด request_review เช่นกัน แต่ไม่ได้ทำการแปลงร่างใด ๆ โดยจะคืนตัวมันเองกลับไป เพราะเมื่อเราส่งคำขอตรวจสอบโพสต์ที่อยู่ในสถานะ PendingReview อยู่แล้ว โพสต์นั้นก็ควรจะคงอยู่ในสถานะ PendingReview ต่อไป

ตอนนี้เราเริ่มเห็นข้อดีของแพตเทิร์นสถานะแล้ว: นั่นคือเมธอด request_review บน Post จะยังคงทำงานเหมือนเดิมไม่ว่าค่าของ state จะเป็นอะไร เพราะแต่ละสถานะจะรับผิดชอบกฎเกณฑ์ของตนเอง

เราจะปล่อยให้เมธอด content บน Post ทำงานเหมือนเดิม คือคืนค่าสตริงสไลซ์ว่างเปล่า แม้ว่าตอนนี้เราจะมี Post ที่อยู่ในสถานะ PendingReview เพิ่มขึ้นมา แต่เราก็ยังต้องการพฤติกรรมเดิมในสถานะนี้เช่นกัน ทำให้ตอนนี้โค้ดในลิสติ้ง 18-11 สามารถทำงานได้ถึงการเรียก assert_eq! ตัวที่สองแล้ว!

การเพิ่ม approve เพื่อเปลี่ยนพฤติกรรมของ content

เมธอด approve จะทำงานคล้ายกับเมธอด request_review: โดยจะกำหนดค่า state ให้เป็นค่าที่สถานะปัจจุบันระบุว่าควรเปลี่ยนไปเมื่อได้รับการอนุมัติ ดังแสดงในลิสติ้ง 18-16

pub struct Post {
    state: Option<Box<dyn State>>,
    content: String,
}

impl Post {
    // --snip--
    pub fn new() -> Post {
        Post {
            state: Some(Box::new(Draft {})),
            content: String::new(),
        }
    }

    pub fn add_text(&mut self, text: &str) {
        self.content.push_str(text);
    }

    pub fn content(&self) -> &str {
        ""
    }

    pub fn request_review(&mut self) {
        if let Some(s) = self.state.take() {
            self.state = Some(s.request_review())
        }
    }

    pub fn approve(&mut self) {
        if let Some(s) = self.state.take() {
            self.state = Some(s.approve())
        }
    }
}

trait State {
    fn request_review(self: Box<Self>) -> Box<dyn State>;
    fn approve(self: Box<Self>) -> Box<dyn State>;
}

struct Draft {}

impl State for Draft {
    // --snip--
    fn request_review(self: Box<Self>) -> Box<dyn State> {
        Box::new(PendingReview {})
    }

    fn approve(self: Box<Self>) -> Box<dyn State> {
        self
    }
}

struct PendingReview {}

impl State for PendingReview {
    // --snip--
    fn request_review(self: Box<Self>) -> Box<dyn State> {
        self
    }

    fn approve(self: Box<Self>) -> Box<dyn State> {
        Box::new(Published {})
    }
}

struct Published {}

impl State for Published {
    fn request_review(self: Box<Self>) -> Box<dyn State> {
        self
    }

    fn approve(self: Box<Self>) -> Box<dyn State> {
        self
    }
}

เราเพิ่มเมธอด approve เข้าไปในเทรต State และเพิ่ม struct ใหม่ที่อิมพลีเมนต์ State นั่นคือสถานะ Published

ในทำนองเดียวกับที่ request_review บน PendingReview ทำงาน หากเราเรียกเมธอด approve บน Draft มันจะไม่มีผลอะไรเกิดขึ้น เพราะ approve จะคืน self กลับมา แต่เมื่อเราเรียก approve บน PendingReview มันจะคืนอินสแตนซ์ใหม่ที่อยู่ในบ็อกซ์ของ struct Published กลับมา โดย struct Published นี้จะอิมพลีเมนต์เทรต State และสำหรับทั้งเมธอด request_review และ approve มันจะคืนตัวมันเองกลับไป เพราะโพสต์ควรคงอยู่ในสถานะ Published ต่อไปในกรณีเหล่านั้น

คราวนี้เราจำเป็นต้องอัปเดตเมธอด content บน Post เราต้องการให้ค่าที่คืนจาก content ขึ้นอยู่กับสถานะปัจจุบันของ Post เราจึงจะให้ Post มอบหมายงาน (delegate) ต่อไปยังเมธอด content ที่นิยามไว้บน state ของมัน ดังแสดงในลิสติ้ง 18-17

pub struct Post {
    state: Option<Box<dyn State>>,
    content: String,
}

impl Post {
    // --snip--
    pub fn new() -> Post {
        Post {
            state: Some(Box::new(Draft {})),
            content: String::new(),
        }
    }

    pub fn add_text(&mut self, text: &str) {
        self.content.push_str(text);
    }

    pub fn content(&self) -> &str {
        self.state.as_ref().unwrap().content(self)
    }
    // --snip--

    pub fn request_review(&mut self) {
        if let Some(s) = self.state.take() {
            self.state = Some(s.request_review())
        }
    }

    pub fn approve(&mut self) {
        if let Some(s) = self.state.take() {
            self.state = Some(s.approve())
        }
    }
}

trait State {
    fn request_review(self: Box<Self>) -> Box<dyn State>;
    fn approve(self: Box<Self>) -> Box<dyn State>;
}

struct Draft {}

impl State for Draft {
    fn request_review(self: Box<Self>) -> Box<dyn State> {
        Box::new(PendingReview {})
    }

    fn approve(self: Box<Self>) -> Box<dyn State> {
        self
    }
}

struct PendingReview {}

impl State for PendingReview {
    fn request_review(self: Box<Self>) -> Box<dyn State> {
        self
    }

    fn approve(self: Box<Self>) -> Box<dyn State> {
        Box::new(Published {})
    }
}

struct Published {}

impl State for Published {
    fn request_review(self: Box<Self>) -> Box<dyn State> {
        self
    }

    fn approve(self: Box<Self>) -> Box<dyn State> {
        self
    }
}

เนื่องจากเป้าหมายคือการเก็บกฎเกณฑ์ทั้งหมดนี้ไว้ใน struct ที่อิมพลีเมนต์ State เราจึงเรียกเมธอด content บนค่าที่อยู่ใน state พร้อมกับส่งอินสแตนซ์ของโพสต์ (นั่นคือ self) ไปเป็นอาร์กิวเมนต์ จากนั้นเราจึงส่งคืนค่าที่ได้จากการเรียกใช้เมธอด content บนค่านั้นกลับไป

เราเรียกเมธอด as_ref บน Option เพราะเราต้องการเพียงเรเฟอเรนซ์ไปยังค่าข้างใน Option ไม่ใช่ความเป็นเจ้าของค่านั้น เนื่องจาก state มีชนิดข้อมูลเป็น Option<Box<dyn State>> เมื่อเราเรียก as_ref เราจึงได้ Option<&Box<dyn State>> กลับมา หากเราไม่เรียก as_ref เราจะเจอกับข้อผิดพลาดของคอมไพเลอร์ เพราะเราไม่สามารถย้าย (move) state ออกมาจาก &self ที่ถูกยืมมาในพารามิเตอร์ของฟังก์ชันได้

จากนั้นเราจึงเรียกเมธอด unwrap ซึ่งเรารู้ดีว่าจะไม่มีทางเกิดการแพนิก (panic) อย่างแน่นอน เพราะเมธอดต่าง ๆ บน Post รับประกันว่า state จะมีค่าเป็น Some เสมอเมื่อเมธอดเหล่านั้นทำงานเสร็จสิ้น นี่คือหนึ่งในกรณีที่เราได้พูดคุยกันในหัวข้อ “เมื่อคุณมีข้อมูลมากกว่าคอมไพเลอร์” ในบทที่ 9 ซึ่งเรารู้แน่ชัดว่าค่า None ไม่มีทางเกิดขึ้นได้ แม้ว่าคอมไพเลอร์จะไม่สามารถล่วงรู้ในจุดนี้ก็ตาม

ณ จุดนี้ เมื่อเราเรียก content บน &Box<dyn State> การแปลงชนิดข้อมูลอัตโนมัติด้วยการดีเรฟ (deref coercion) จะมีผลกับทั้ง & และ Box ส่งผลให้ท้ายที่สุดแล้ว เมธอด content จะถูกเรียกบนชนิดข้อมูลที่อิมพลีเมนต์เทรต State จริง ๆ นั่นหมายความว่า เราต้องเพิ่ม content เข้าไปในนิยามของเทรต State ด้วย และนั่นคือจุดที่เราจะใส่ตรรกะว่าควรคืนเนื้อหาอะไรออกมาตามสถานะที่เป็นอยู่ ดังแสดงในลิสติ้ง 18-18

pub struct Post {
    state: Option<Box<dyn State>>,
    content: String,
}

impl Post {
    pub fn new() -> Post {
        Post {
            state: Some(Box::new(Draft {})),
            content: String::new(),
        }
    }

    pub fn add_text(&mut self, text: &str) {
        self.content.push_str(text);
    }

    pub fn content(&self) -> &str {
        self.state.as_ref().unwrap().content(self)
    }

    pub fn request_review(&mut self) {
        if let Some(s) = self.state.take() {
            self.state = Some(s.request_review())
        }
    }

    pub fn approve(&mut self) {
        if let Some(s) = self.state.take() {
            self.state = Some(s.approve())
        }
    }
}

trait State {
    // --snip--
    fn request_review(self: Box<Self>) -> Box<dyn State>;
    fn approve(self: Box<Self>) -> Box<dyn State>;

    fn content<'a>(&self, post: &'a Post) -> &'a str {
        ""
    }
}

// --snip--

struct Draft {}

impl State for Draft {
    fn request_review(self: Box<Self>) -> Box<dyn State> {
        Box::new(PendingReview {})
    }

    fn approve(self: Box<Self>) -> Box<dyn State> {
        self
    }
}

struct PendingReview {}

impl State for PendingReview {
    fn request_review(self: Box<Self>) -> Box<dyn State> {
        self
    }

    fn approve(self: Box<Self>) -> Box<dyn State> {
        Box::new(Published {})
    }
}

struct Published {}

impl State for Published {
    // --snip--
    fn request_review(self: Box<Self>) -> Box<dyn State> {
        self
    }

    fn approve(self: Box<Self>) -> Box<dyn State> {
        self
    }

    fn content<'a>(&self, post: &'a Post) -> &'a str {
        &post.content
    }
}

เราเพิ่มการอิมพลีเมนต์ดีฟอลต์สำหรับเมธอด content ให้คืนค่าเป็นสตริงสไลซ์ว่างเปล่า ซึ่งหมายความว่าเราไม่จำเป็นต้องเขียนการอิมพลีเมนต์ content บน struct Draft และ PendingReview ซ้ำอีก โดย struct Published จะเป็นตัวเขียนทับ (override) เมธอด content และคืนค่าใน post.content ออกมา แม้ว่าวิธีนี้จะสะดวก แต่การให้เมธอด content บน State เป็นตัวกำหนดเนื้อหาของ Post ก็ทำให้เส้นแบ่งความรับผิดชอบระหว่าง State กับ Post ดูเลือนลางลงไปบ้าง

โปรดสังเกตว่าเราจำเป็นต้องระบุตัวกำกับอายุการใช้งาน (lifetime annotation) บนเมธอดนี้ด้วย ดังที่เราได้อธิบายไว้ในบทที่ 10 เพราะเรากำลังรับเรเฟอเรนซ์ของ post เข้ามาเป็นอาร์กิวเมนต์ และส่งคืนเรเฟอเรนซ์ไปยังส่วนหนึ่งของ post นั้นกลับออกไป อายุการใช้งานของเรเฟอเรนซ์ที่คืนกลับจึงผูกพันอยู่กับอายุการใช้งานของอาร์กิวเมนต์ post

และแล้วก็เสร็จเรียบร้อย—ตอนนี้โค้ดทั้งหมดในลิสติ้ง 18-11 สามารถทำงานได้ครบถ้วนแล้ว! เราได้อิมพลีเมนต์แพตเทิร์นสถานะตามกฎเกณฑ์ของเวิร์กโฟลว์โพสต์บล็อก โดยตรรกะที่เกี่ยวข้องกับกฎเกณฑ์ต่าง ๆ จะรวมศูนย์อยู่ในออบเจกต์สถานะ แทนที่จะกระจัดกระจายอยู่ทั่ว struct Post

ทำไมไม่ใช้ Enum?

คุณอาจสงสัยว่าทำไมเราไม่ใช้ enum ที่มีสถานะต่าง ๆ ที่เป็นไปได้ของโพสต์เป็นวาเรียนต์ นั่นก็เป็นหนึ่งในทางออกที่เป็นไปได้อย่างแน่นอน ลองเขียนดูแล้วเปรียบเทียบผลลัพธ์สุดท้ายว่าคุณชอบแบบใดมากกว่า! ข้อเสียประการหนึ่งของการใช้ enum คือ ทุกจุดที่มีการตรวจสอบค่าของ enum จะต้องมีนิพจน์ match หรือโครงสร้างที่คล้ายกันเพื่อจัดการกับทุกวาเรียนต์ที่เป็นไปได้ ซึ่งอาจทำให้เกิดโค้ดซ้ำซ้อนมากกว่าแนวทางที่ใช้เทรตออบเจกต์นี้

การประเมินแพตเทิร์นสถานะ

เราได้แสดงให้เห็นแล้วว่า Rust สามารถอิมพลีเมนต์แพตเทิร์นสถานะเชิงวัตถุเพื่อห่อหุ้ม (encapsulate) พฤติกรรมต่าง ๆ ที่โพสต์ควรมีในแต่ละสถานะได้ โดยที่เมธอดบน Post ไม่จำเป็นต้องรู้เรื่องพฤติกรรมเหล่านั้นเลย ด้วยวิธีการจัดระเบียบโค้ดเช่นนี้ เราจึงเปิดดูเพียงจุดเดียวก็เข้าใจได้ทันทีว่าโพสต์ที่เผยแพร่แล้วมีพฤติกรรมอย่างไร นั่นคือดูที่การอิมพลีเมนต์เทรต State บน struct Published

หากเราเลือกอิมพลีเมนต์ด้วยวิธีอื่นที่ไม่ใช้แพตเทิร์นสถานะ เราอาจต้องใช้นิพจน์ match ในเมธอดต่าง ๆ บน Post หรือแม้กระทั่งในโค้ด main เพื่อคอยตรวจสอบสถานะของโพสต์แล้วปรับเปลี่ยนพฤติกรรมในแต่ละจุด ซึ่งนั่นจะทำให้เราต้องไล่ดูโค้ดหลายที่มากเพื่อที่จะเข้าใจผลกระทบทั้งหมดของการที่โพสต์อยู่ในสถานะเผยแพร่แล้ว

การใช้แพตเทิร์นสถานะทำให้เมธอดของ Post และจุดที่เราเรียกใช้ Post ไม่จำเป็นต้องมีนิพจน์ match เลย และเมื่อต้องการเพิ่มสถานะใหม่ เราก็เพียงแค่เพิ่ม struct ใหม่ขึ้นมา แล้วอิมพลีเมนต์เมธอดของเทรตบน struct นั้นในที่เดียวจบ

การอิมพลีเมนต์โดยใช้แพตเทิร์นสถานะจึงง่ายต่อการต่อขยายเพื่อเพิ่มฟังก์ชันการทำงาน เพื่อสัมผัสถึงความสะดวกในการบำรุงรักษาโค้ดที่ใช้แพตเทิร์นสถานะ ลองทำตามคำแนะนำเหล่านี้ดู:

  • เพิ่มเมธอด reject ที่เปลี่ยนสถานะของโพสต์จาก PendingReview กลับไปเป็น Draft
  • กำหนดให้ต้องเรียก approve สองครั้งก่อนที่สถานะจะเปลี่ยนเป็น Published ได้
  • อนุญาตให้ผู้ใช้เพิ่มข้อความได้เฉพาะเมื่อโพสต์อยู่ในสถานะ Draft เท่านั้น คำใบ้: ให้ออบเจกต์สถานะเป็นผู้รับผิดชอบว่ามีอะไรเปลี่ยนแปลงเกี่ยวกับเนื้อหาได้บ้าง แต่ไม่ต้องรับผิดชอบการแก้ไข Post โดยตรง

ข้อเสียประการหนึ่งของแพตเทิร์นสถานะคือ เนื่องจากแต่ละสถานะเป็นตัวกำหนดการเปลี่ยนผ่านไปยังสถานะถัดไป สถานะบางตัวจึงเกิดการผูกมัดซึ่งกันและกัน (coupled) หากเราต้องการแทรกสถานะใหม่เข้าไปคั่นระหว่าง PendingReview กับ Published เช่น Scheduled เราจะต้องเข้าไปแก้โค้ดใน PendingReview ให้เปลี่ยนผ่านไปยัง Scheduled แทน ซึ่งคงจะเหนื่อยน้อยลงหาก PendingReview ไม่จำเป็นต้องถูกแก้ไขเมื่อมีการเพิ่มสถานะใหม่ แต่นั่นก็หมายความว่าเราต้องเปลี่ยนไปใช้แบบแผนการออกแบบอื่น

ข้อเสียอีกประการหนึ่งคือเราเกิดโค้ดซ้ำซ้อนขึ้นบางส่วน เพื่อกำจัดความซ้ำซ้อนบางส่วน เราอาจลองสร้างการอิมพลีเมนต์ดีฟอลต์สำหรับเมธอด request_review และ approve บนเทรต State ที่คืน self อย่างไรก็ตาม วิธีนี้ใช้ไม่ได้: เมื่อใช้ State เป็นเทรตออบเจกต์ เทรตไม่รู้ว่า self ที่เป็นรูปธรรมจะเป็นอะไรอย่างแน่ชัด ชนิดที่คืนกลับจึงไม่เป็นที่รู้ตอนคอมไพล์ (นี่เป็นหนึ่งในกฎความเข้ากันได้ของ dyn ที่กล่าวถึงก่อนหน้านี้)

ความซ้ำซ้อนอีกจุดหนึ่งคือ โค้ดการทำงานที่คล้ายคลึงกันมากของเมธอด request_review และ approve บน Post โดยทั้งสองเมธอดต่างเรียกใช้ Option::take กับฟิลด์ state ของ Post และหาก state มีค่าเป็น Some ก็จะส่งต่องานไปยังการอิมพลีเมนต์เมธอดเดียวกันของค่าที่ถูกห่อไว้ แล้วนำผลลัพธ์ที่ได้มาตั้งเป็นค่าใหม่ของฟิลด์ state หากเรามีเมธอดบน Post จำนวนมากที่ใช้รูปแบบนี้ซ้ำ ๆ เราอาจพิจารณานิยามมาโคร (macro) ขึ้นมาเพื่อลดความซ้ำซ้อนในการเขียนโค้ด (ดูหัวข้อ “มาโคร” ในบทที่ 20)

การอิมพลีเมนต์แพตเทิร์นสถานะตามนิยามดั้งเดิมของภาษาเชิงวัตถุอย่างเคร่งครัด ทำให้เรายังไม่ได้ใช้ประโยชน์จากจุดแข็งของ Rust ได้อย่างเต็มที่ มาลองดูการปรับเปลี่ยนบางอย่างที่เราสามารถทำได้กับเครต blog ซึ่งจะช่วยเปลี่ยนสถานะและการเปลี่ยนสถานะที่ไม่ถูกต้อง ให้กลายเป็นข้อผิดพลาดตั้งแต่ตอนคอมไพล์กันดีกว่า

การเข้ารหัสสถานะและพฤติกรรมเป็นชนิดข้อมูล

เราจะแสดงวิธีคิดใหม่กับแพตเทิร์นสถานะเพื่อให้ได้ข้อแลกเปลี่ยนอีกแบบหนึ่ง แทนที่จะห่อหุ้มสถานะและการเปลี่ยนผ่านไว้อย่างมิดชิดจนโค้ดภายนอกไม่รู้เรื่องเลย เราจะเข้ารหัสสถานะต่าง ๆ ลงไปในชนิดข้อมูลที่แตกต่างกัน ด้วยวิธีนี้ ระบบตรวจสอบชนิดข้อมูลของ Rust จะป้องกันความพยายามในการนำโพสต์ฉบับร่างไปใช้ในจุดที่อนุญาตเฉพาะโพสต์ที่เผยแพร่แล้ว โดยแจ้งเตือนเป็นข้อผิดพลาดจากคอมไพเลอร์ทันที

ลองมาดูส่วนแรกของฟังก์ชัน main ในลิสติ้ง 18-11 กัน:

use blog::Post;

fn main() {
    let mut post = Post::new();

    post.add_text("I ate a salad for lunch today");
    assert_eq!("", post.content());

    post.request_review();
    assert_eq!("", post.content());

    post.approve();
    assert_eq!("I ate a salad for lunch today", post.content());
}

เรายังคงอนุญาตให้สร้างโพสต์ใหม่ในสถานะฉบับร่างด้วย Post::new และอนุญาตให้เพิ่มข้อความลงในเนื้อหาของโพสต์ได้เหมือนเดิม แต่แทนที่จะมีเมธอด content บนโพสต์ฉบับร่างที่คืนค่าสตริงว่าง เราจะทำให้โพสต์ฉบับร่างไม่มีเมธอด content เลย ด้วยวิธีนั้น หากเราพยายามดึงเนื้อหาจากโพสต์ฉบับร่าง เราจะได้รับข้อผิดพลาดจากคอมไพเลอร์ว่าไม่มีเมธอดดังกล่าวอยู่ ผลลัพธ์คือ เราจะไม่มีทางเผลอแสดงเนื้อหาของโพสต์ฉบับร่างในระบบจริง (production) โดยไม่ตั้งใจได้อย่างแน่นอน เพราะโค้ดนั้นจะไม่สามารถคอมไพล์ผ่านได้ตั้งแต่แรก ลิสติ้ง 18-19 แสดงนิยามของ struct Post และ struct DraftPost พร้อมกับเมธอดของแต่ละตัว

pub struct Post {
    content: String,
}

pub struct DraftPost {
    content: String,
}

impl Post {
    pub fn new() -> DraftPost {
        DraftPost {
            content: String::new(),
        }
    }

    pub fn content(&self) -> &str {
        &self.content
    }
}

impl DraftPost {
    pub fn add_text(&mut self, text: &str) {
        self.content.push_str(text);
    }
}

ทั้ง struct Post และ DraftPost ต่างมีฟิลด์ไพรเวต content สำหรับเก็บข้อความของโพสต์บล็อก แต่ทั้งสอง struct จะไม่มีฟิลด์ state อีกต่อไป เพราะเราได้ย้ายการเข้ารหัสสถานะไปไว้ที่ตัวชนิดข้อมูลของ struct แทน โดย struct Post จะเป็นตัวแทนของโพสต์ที่เผยแพร่แล้ว และมีเมธอด content ที่คืนค่า content ออกมา

เรายังคงมีฟังก์ชัน Post::new อยู่ แต่แทนที่จะคืนอินสแตนซ์ของ Post มันกลับคืนอินสแตนซ์ของ DraftPost ออกมาแทน และเนื่องจาก content เป็นแบบไพรเวต อีกทั้งยังไม่มีฟังก์ชันใดที่คืน Post ได้เลย ในตอนนี้จึงเป็นไปไม่ได้ที่จะสร้างอินสแตนซ์ของ Post ขึ้นมาตรง ๆ

struct DraftPost จะมีเมธอด add_text ทำให้เรายังคงเพิ่มข้อความลงใน content ได้เหมือนเดิม แต่สังเกตว่า DraftPost ไม่ได้นิยามเมธอด content เอาไว้! โปรแกรมจึงสามารถรับประกันได้ว่า โพสต์ทั้งหมดจะต้องเริ่มต้นจากการเป็นโพสต์ฉบับร่าง และโพสต์ฉบับร่างจะไม่มีเนื้อหาเปิดให้แสดงผล ความพยายามใด ๆ ที่จะหลบเลี่ยงข้อจำกัดนี้จะถูกปฏิเสธด้วยข้อผิดพลาดจากคอมไพเลอร์ทันที

ถ้าเช่นนั้น เราจะได้โพสต์ที่เผยแพร่แล้วมาได้อย่างไร? เราต้องการบังคับใช้กฎว่า โพสต์ฉบับร่างจะต้องผ่านการตรวจสอบและได้รับการอนุมัติก่อนจึงจะสามารถเผยแพร่ได้ และโพสต์ในสถานะรอตรวจสอบก็ยังไม่ควรแสดงเนื้อหาใด ๆ ออกมา เราจะสร้างข้อจำกัดเหล่านี้ขึ้นมาโดยการเพิ่ม struct อีกตัวชื่อ PendingReviewPost พร้อมกับนิยามเมธอด request_review บน DraftPost ให้คืน PendingReviewPost และนิยามเมธอด approve บน PendingReviewPost ให้คืน Post ดังแสดงในลิสติ้ง 18-20

pub struct Post {
    content: String,
}

pub struct DraftPost {
    content: String,
}

impl Post {
    pub fn new() -> DraftPost {
        DraftPost {
            content: String::new(),
        }
    }

    pub fn content(&self) -> &str {
        &self.content
    }
}

impl DraftPost {
    // --snip--
    pub fn add_text(&mut self, text: &str) {
        self.content.push_str(text);
    }

    pub fn request_review(self) -> PendingReviewPost {
        PendingReviewPost {
            content: self.content,
        }
    }
}

pub struct PendingReviewPost {
    content: String,
}

impl PendingReviewPost {
    pub fn approve(self) -> Post {
        Post {
            content: self.content,
        }
    }
}

เมธอด request_review และ approve จะรับความเป็นเจ้าของของ self จึงเป็นการบริโภคอินสแตนซ์ของ DraftPost และ PendingReviewPost แล้วแปลงร่างให้กลายเป็น PendingReviewPost และ Post ที่เผยแพร่แล้วตามลำดับ ด้วยวิธีนี้ เราจะไม่มีอินสแตนซ์ของ DraftPost หลงเหลืออยู่อีกหลังจากที่เราเรียก request_review ไปแล้ว เป็นต้น และเนื่องจาก struct PendingReviewPost ไม่ได้นิยามเมธอด content ไว้ การพยายามอ่านเนื้อหาของมันจึงทำให้เกิดข้อผิดพลาดจากคอมไพเลอร์เช่นเดียวกับ DraftPost และเพราะหนทางเดียวที่จะได้อินสแตนซ์ของ Post ที่เผยแพร่แล้ว (ซึ่งมีเมธอด content ให้เรียก) คือการเรียกเมธอด approve บน PendingReviewPost และหนทางเดียวที่จะได้ PendingReviewPost คือการเรียก request_review บน DraftPost เราจึงได้เข้ารหัสเวิร์กโฟลว์ของโพสต์บล็อกทั้งหมดลงในระบบชนิดข้อมูลได้อย่างสมบูรณ์

อย่างไรก็ตาม เรายังต้องปรับแก้โค้ดใน main เล็กน้อย เนื่องจากเมธอด request_review และ approve จะส่งคืนอินสแตนซ์ใหม่กลับมาแทนที่จะเป็นการดัดแปลง struct เดิมที่ถูกเรียกใช้ เราจึงต้องใช้การบังเงาตัวแปร (variable shadowing) ด้วยคำสั่ง let post = เพิ่มเติมเพื่อเก็บอินสแตนซ์ใหม่ที่คืนกลับมา นอกจากนี้ เรายังไม่สามารถใส่แอสเซอร์ชัน (assertion) ตรวจสอบเนื้อหาของโพสต์ฉบับร่างและโพสต์ที่รอการตรวจสอบว่าเป็นสตริงว่างได้อีกต่อไป และไม่จำเป็นต้องใส่ด้วย เพราะเราไม่สามารถแม้แต่จะคอมไพล์โค้ดที่พยายามอ่านเนื้อหาของโพสต์ในสถานะเหล่านั้นได้อยู่แล้ว โค้ดที่อัปเดตใน main แสดงไว้ในลิสติ้ง 18-21

use blog::Post;

fn main() {
    let mut post = Post::new();

    post.add_text("I ate a salad for lunch today");

    let post = post.request_review();

    let post = post.approve();

    assert_eq!("I ate a salad for lunch today", post.content());
}

การที่เราต้องปรับแก้ฟังก์ชัน main เพื่อกำหนดค่าตัวแปร post ใหม่นี้ หมายความว่าการอิมพลีเมนต์นี้ไม่ได้ปฏิบัติตามแพตเทิร์นสถานะเชิงวัตถุแบบเป๊ะ ๆ อีกต่อไป: เนื่องจากการแปลงร่างระหว่างสถานะต่าง ๆ ไม่ได้ถูกห่อหุ้มไว้ภายใน Post อย่างเบ็ดเสร็จอีกแล้ว แต่สิ่งที่เราได้รับกลับมาคือ สถานะที่ไม่ถูกต้องจะไม่มีทางเกิดขึ้นได้อย่างเด็ดขาด ต้องขอบคุณระบบชนิดข้อมูลและการตรวจสอบชนิดข้อมูลในตอนคอมไพล์! สิ่งนี้ช่วยรับประกันว่าบั๊กบางประเภท เช่น การเผลอแสดงเนื้อหาของโพสต์ที่ยังไม่เผยแพร่ จะถูกตรวจพบตั้งแต่เนิ่น ๆ ก่อนที่จะหลุดไปถึงโปรดักชัน

ลองนำโจทย์แบบฝึกหัดที่แนะนำไว้ในตอนต้นของหัวข้อนี้ มาทดลองทำกับเครต blog ในเวอร์ชันหลังลิสติ้ง 18-21 ดู เพื่อสัมผัสว่าคุณรู้สึกอย่างไรกับการออกแบบโค้ดในรูปแบบนี้ และโปรดสังเกตว่าโจทย์บางข้ออาจได้รับการแก้ไขเสร็จสิ้นไปแล้วในตัวการออกแบบนี้เอง

เราได้เห็นแล้วว่า แม้ว่า Rust จะมีความสามารถในการอิมพลีเมนต์แบบแผนการออกแบบเชิงวัตถุได้ แต่แพตเทิร์นอื่น ๆ เช่น การเข้ารหัสสถานะลงในระบบชนิดข้อมูล ก็เป็นทางเลือกที่มีประสิทธิภาพใน Rust เช่นกัน แพตเทิร์นแต่ละแบบย่อมมีข้อแลกเปลี่ยนที่แตกต่างกัน แม้ว่าคุณอาจคุ้นเคยกับแพตเทิร์นเชิงวัตถุเป็นอย่างดี แต่การคิดทบทวนโจทย์ใหม่เพื่อดึงประโยชน์จากฟีเจอร์อันทรงพลังของ Rust ก็สามารถมอบคุณประโยชน์ที่ยอดเยี่ยมได้ เช่น การป้องกันบั๊กตั้งแต่ตอนคอมไพล์ โดยแบบแผนเชิงวัตถุอาจไม่ได้เป็นคำตอบที่ดีที่สุดเสมอไปใน Rust เนื่องจากฟีเจอร์เฉพาะตัวอย่างระบบความเป็นเจ้าของ (ownership) ที่ภาษาเชิงวัตถุทั่วไปไม่มี

สรุป

ไม่ว่าหลังจากอ่านบทนี้จบแล้ว คุณจะมองว่า Rust เป็นภาษาเชิงวัตถุหรือไม่ก็ตาม แต่ตอนนี้คุณได้ทราบแล้วว่า คุณสามารถใช้เทรตออบเจกต์เพื่อดึงฟีเจอร์บางประการของเชิงวัตถุมาใช้ใน Rust ได้ การดิสแพตช์แบบไดนามิก (dynamic dispatch) ช่วยเพิ่มความยืดหยุ่นให้กับโค้ดของคุณโดยแลกกับต้นทุนด้านประสิทธิภาพตอนรันไทม์เพียงเล็กน้อย คุณสามารถนำความยืดหยุ่นนี้ไปใช้อิมพลีเมนต์แพตเทิร์นเชิงวัตถุที่ช่วยให้โค้ดของคุณดูแลรักษาง่ายขึ้น ยิ่งไปกว่านั้น Rust ยังมีฟีเจอร์อื่น ๆ เช่น ระบบความเป็นเจ้าของ (ownership) ซึ่งภาษาเชิงวัตถุทั่วไปไม่มี แม้แบบแผนเชิงวัตถุอาจไม่ได้เป็นหนทางที่ดีที่สุดเสมอไปในการดึงจุดแข็งของ Rust ออกมาใช้ แต่มันก็เป็นทางเลือกหนึ่งที่มีพร้อมให้คุณหยิบมาใช้งานเสมอ

ในบทต่อไป เราจะไปดูเรื่อง “แพตเทิร์น” (patterns) ซึ่งเป็นอีกหนึ่งฟีเจอร์สำคัญของ Rust ที่ช่วยเปิดประตูสู่ความยืดหยุ่นอย่างมากมาย แม้เราจะเคยเห็นผ่านตากันมาบ้างแล้วตลอดทั้งเล่ม แต่เรายังไม่เคยเห็นศักยภาพเต็มรูปแบบของมันเลย ไปลุยกันต่อเลย!