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

การใช้เทรตออบเจกต์เพื่อนามธรรมพฤติกรรมร่วม

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

อย่างไรก็ตาม บางครั้งเราต้องการให้ผู้ใช้ไลบรารีสามารถต่อขยายชุดของชนิดข้อมูลที่นำมาใช้ในสถานการณ์นั้น ๆ ได้ เพื่อแสดงให้เห็นว่าทำได้อย่างไร เราจะสร้างตัวอย่างเครื่องมือส่วนติดต่อผู้ใช้แบบกราฟิก (graphical user interface หรือ GUI) ที่วนลูปผ่านรายการของไอเทม แล้วเรียกใช้เมธอด draw กับแต่ละตัวเพื่อวาดมันลงบนหน้าจอ ซึ่งเป็นเทคนิคที่พบได้ทั่วไปสำหรับเครื่องมือ GUI เราจะสร้างเครตไลบรารีชื่อ gui ที่บรรจุโครงสร้างของไลบรารี GUI ไว้ เครตนี้อาจมีชนิดข้อมูลบางตัวเตรียมไว้ให้ใช้งาน เช่น Button หรือ TextField นอกจากนี้ ผู้ใช้ gui ยังต้องการสร้างชนิดข้อมูลของตนเองที่สามารถวาดลงจอได้ด้วย เช่น โปรแกรมเมอร์คนหนึ่งอาจเพิ่ม Image ขณะที่อีกคนอาจเพิ่ม SelectBox

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

หากทำสิ่งนี้ในภาษาที่มีการสืบทอด เราอาจนิยามคลาสชื่อ Component ที่มีเมธอดชื่อ draw ขึ้นมา จากนั้นคลาสอื่น ๆ เช่น Button, Image และ SelectBox ก็จะสืบทอดมาจาก Component ทำให้ได้รับเมธอด draw ติดตัวมาด้วย แต่ละคลาสสามารถเขียนทับ (override) เมธอด draw เพื่อกำหนดพฤติกรรมเฉพาะของตนเองได้ โดยตัวเฟรมเวิร์กสามารถปฏิบัติต่อทุกชนิดข้อมูลราวกับว่าเป็นอินสแตนซ์ของ Component และเรียก draw บนพวกมันได้เลย แต่เนื่องจาก Rust ไม่มีการสืบทอด เราจึงต้องใช้วิธีอื่นในการจัดโครงสร้างไลบรารี gui เพื่อเปิดทางให้ผู้ใช้นำชนิดข้อมูลใหม่เข้ามาทำงานร่วมกับไลบรารีได้

การนิยามเทรตสำหรับพฤติกรรมร่วม

เพื่ออิมพลีเมนต์พฤติกรรมที่เราต้องการให้ gui มี เราจะนิยามเทรตชื่อ Draw ที่มีเมธอดหนึ่งตัวชื่อ draw จากนั้นเรานิยามเวกเตอร์ที่รับเทรตออบเจกต์ได้ เทรตออบเจกต์ (trait object) ชี้ไปยังทั้งอินสแตนซ์ (instance) ของชนิดข้อมูลที่อิมพลีเมนต์เทรตที่เราระบุ และตารางที่ใช้ค้นหาเมธอดของเทรตบนชนิดข้อมูลนั้นตอนรันไทม์ เราสร้างเทรตออบเจกต์โดยระบุพอยน์เตอร์บางชนิด เช่น เรเฟอเรนซ์ (reference) หรือสมาร์ตพอยน์เตอร์ (smart pointer) Box<T> จากนั้นตามด้วยคำสงวน dyn แล้วระบุเทรตที่เกี่ยวข้อง (เราจะพูดถึงเหตุผลที่เทรตออบเจกต์ต้องใช้พอยน์เตอร์ใน“ชนิดข้อมูลขนาดไม่คงที่และเทรต Sized” ในบทที่ 20) เราใช้เทรตออบเจกต์แทนชนิดเจเนอริก (generic) หรือชนิดที่เป็นรูปธรรมได้ ทุกที่ที่เราใช้เทรตออบเจกต์ ระบบชนิดข้อมูลของ Rust จะรับประกันตอนคอมไพล์ว่าค่าใดก็ตามที่ใช้ในบริบทนั้นจะอิมพลีเมนต์เทรตของเทรตออบเจกต์นั้น ดังนั้น เราจึงไม่จำเป็นต้องรู้ชนิดข้อมูลที่เป็นไปได้ทั้งหมดตอนคอมไพล์

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

ลิสติ้ง 18-3 แสดงวิธีนิยามเทรตชื่อ Draw ที่มีเมธอดหนึ่งตัวชื่อ draw

pub trait Draw {
    fn draw(&self);
}

ไวยากรณ์นี้น่าจะดูคุ้นเคยจากที่เราได้พูดคุยเรื่องการนิยามเทรตในบทที่ 10 ถัดไปเป็นไวยากรณ์ใหม่บางส่วน: ในลิสติ้ง 18-4 เราได้นิยาม struct ชื่อ Screen ที่เก็บเวกเตอร์ชื่อ components ไว้ โดยเวกเตอร์นี้มีชนิดข้อมูลเป็น Box<dyn Draw> ซึ่งก็คือเทรตออบเจกต์ โดยทำหน้าที่เป็นตัวแทนของชนิดข้อมูลใดก็ตามภายใน Box ที่อิมพลีเมนต์เทรต Draw

pub trait Draw {
    fn draw(&self);
}

pub struct Screen {
    pub components: Vec<Box<dyn Draw>>,
}

ใน struct Screen เราจะนิยามเมธอดชื่อ run ซึ่งจะเรียกเมธอด draw บนแต่ละตัวใน components ดังแสดงในลิสติ้ง 18-5

pub trait Draw {
    fn draw(&self);
}

pub struct Screen {
    pub components: Vec<Box<dyn Draw>>,
}

impl Screen {
    pub fn run(&self) {
        for component in self.components.iter() {
            component.draw();
        }
    }
}

การทำงานของสิ่งนี้จะแตกต่างจากการนิยาม struct ที่ใช้พารามิเตอร์ชนิดข้อมูลเจเนอริก (generic type parameter) ร่วมกับข้อกำหนดเทรต (trait bound) เพราะพารามิเตอร์ชนิดข้อมูลเจเนอริกสามารถแทนที่ด้วยชนิดข้อมูลรูปธรรมได้เพียงชนิดเดียวในคราวหนึ่ง ในขณะที่เทรตออบเจกต์อนุญาตให้มีชนิดข้อมูลรูปธรรมได้หลายชนิดเข้ามาแทนที่เทรตออบเจกต์ ณ ตอนรันไทม์ ตัวอย่างเช่น เราอาจนิยาม struct Screen โดยใช้ชนิดข้อมูลเจเนอริกและข้อกำหนดเทรตได้ดังในลิสติ้ง 18-6

pub trait Draw {
    fn draw(&self);
}

pub struct Screen<T: Draw> {
    pub components: Vec<T>,
}

impl<T> Screen<T>
where
    T: Draw,
{
    pub fn run(&self) {
        for component in self.components.iter() {
            component.draw();
        }
    }
}

วิธีนี้จะจำกัดให้อินสแตนซ์ของ Screen หนึ่ง ๆ มีรายการคอมโพเนนต์ที่เป็นชนิด Button ทั้งหมด หรือไม่ก็เป็นชนิด TextField ทั้งหมด หากคุณต้องการใช้คอลเลกชันที่เป็นชนิดเดียวกันทั้งหมด (homogeneous collection) เสมอ การใช้เจเนอริกและข้อกำหนดเทรตย่อมเป็นตัวเลือกที่ดีกว่า เพราะนิยามจะถูกมอโนมอร์ไฟซ์ (monomorphize) ตั้งแต่ตอนคอมไพล์เพื่อเจาะจงไปที่ชนิดข้อมูลรูปธรรมนั้น ๆ

ในทางกลับกัน ด้วยวิธีที่ใช้เทรตออบเจกต์ อินสแตนซ์ของ Screen ตัวหนึ่งจะสามารถเก็บ Vec<T> ที่บรรจุทั้ง Box<Button> และ Box<TextField> ผสมกันได้ ลองมาดูกันว่าสิ่งนี้ทำงานอย่างไร แล้วเราจะพูดถึงผลกระทบด้านประสิทธิภาพตอนรันไทม์กันต่อไป

การอิมพลีเมนต์เทรต

คราวนี้เราจะเพิ่มชนิดข้อมูลบางตัวที่อิมพลีเมนต์เทรต Draw โดยเราจะเตรียมชนิดข้อมูล Button ขึ้นมา แต่เนื่องจากการอิมพลีเมนต์ไลบรารี GUI จริง ๆ อยู่นอกเหนือขอบเขตของหนังสือเล่มนี้ ตัวเมธอด draw จึงไม่มีโค้ดการทำงานจริงที่ทำอะไรเป็นชิ้นเป็นอัน เพื่อให้เห็นภาพว่าการอิมพลีเมนต์อาจมีหน้าตาอย่างไร struct Button อาจมีฟิลด์สำหรับ width, height และ label ดังแสดงในลิสติ้ง 18-7

pub trait Draw {
    fn draw(&self);
}

pub struct Screen {
    pub components: Vec<Box<dyn Draw>>,
}

impl Screen {
    pub fn run(&self) {
        for component in self.components.iter() {
            component.draw();
        }
    }
}

pub struct Button {
    pub width: u32,
    pub height: u32,
    pub label: String,
}

impl Draw for Button {
    fn draw(&self) {
        // code to actually draw a button
    }
}

ฟิลด์ width, height และ label ใน Button จะแตกต่างจากฟิลด์ในคอมโพเนนต์อื่น ๆ ตัวอย่างเช่น ชนิดข้อมูล TextField อาจมีฟิลด์เหล่านี้เหมือนกันบวกกับฟิลด์ placeholder เพิ่มเข้ามา โดยชนิดข้อมูลแต่ละตัวที่เราต้องการวาดลงบนหน้าจอจะอิมพลีเมนต์เทรต Draw เหมือนกัน แต่จะใช้โค้ดในเมธอด draw แตกต่างกันไปตามวิธีการวาดของชนิดข้อมูลนั้น ๆ ดังที่ Button ทำไว้ที่นี่ (โดยไม่มีโค้ด GUI จริงตามที่ได้เกริ่นไว้) ตัวอย่างเช่น ชนิดข้อมูล Button อาจมีบล็อก impl เพิ่มเติมสำหรับเมธอดที่เกี่ยวข้องกับสิ่งที่จะเกิดขึ้นเมื่อผู้ใช้คลิกปุ่ม ซึ่งเมธอดประเภทนี้ย่อมไม่เกี่ยวข้องกับชนิดข้อมูลอย่าง TextField

หากผู้ใช้ไลบรารีของเราต้องการสร้าง struct SelectBox ที่มีฟิลด์ width, height และ options พวกเขาก็แค่อิมพลีเมนต์เทรต Draw ให้กับชนิดข้อมูล SelectBox ด้วยเช่นกัน ดังแสดงในลิสติ้ง 18-8

use gui::Draw;

struct SelectBox {
    width: u32,
    height: u32,
    options: Vec<String>,
}

impl Draw for SelectBox {
    fn draw(&self) {
        // code to actually draw a select box
    }
}

fn main() {}

ตอนนี้ผู้ใช้ไลบรารีของเราสามารถเขียนฟังก์ชัน main เพื่อสร้างอินสแตนซ์ของ Screen ได้แล้ว และในอินสแตนซ์ของ Screen นั้น พวกเขาสามารถเพิ่มทั้ง SelectBox และ Button เข้าไปได้โดยการครอบแต่ละตัวไว้ใน Box<T> เพื่อให้กลายเป็นเทรตออบเจกต์ จากนั้นก็สามารถเรียกเมธอด run บนอินสแตนซ์ของ Screen ซึ่งจะไปเรียก draw ให้กับแต่ละคอมโพเนนต์ ลิสติ้ง 18-9 แสดงการเขียนโค้ดในลักษณะนี้

use gui::Draw;

struct SelectBox {
    width: u32,
    height: u32,
    options: Vec<String>,
}

impl Draw for SelectBox {
    fn draw(&self) {
        // code to actually draw a select box
    }
}

use gui::{Button, Screen};

fn main() {
    let screen = Screen {
        components: vec![
            Box::new(SelectBox {
                width: 75,
                height: 10,
                options: vec![
                    String::from("Yes"),
                    String::from("Maybe"),
                    String::from("No"),
                ],
            }),
            Box::new(Button {
                width: 50,
                height: 10,
                label: String::from("OK"),
            }),
        ],
    };

    screen.run();
}

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

แนวคิดนี้—คือการสนใจเพียงแค่ว่าค่านั้น ๆ ตอบสนองต่อคำสั่งหรือเมธอดใดได้บ้าง แทนที่จะสนใจชนิดข้อมูลรูปธรรมที่แท้จริง—มีความคล้ายคลึงกับแนวคิด duck typing ในภาษาที่มีระบบชนิดข้อมูลแบบไดนามิก: กล่าวคือ “ถ้ามันเดินเหมือนเป็ดและร้องก้าบ ๆ เหมือนเป็ด มันก็คือเป็ด!” ในการอิมพลีเมนต์ run บน Screen ในลิสติ้ง 18-5 เมธอด run จึงไม่จำเป็นต้องรู้เลยว่าชนิดข้อมูลรูปธรรมที่แท้จริงของแต่ละคอมโพเนนต์คืออะไร และไม่จำเป็นต้องตรวจเช็กว่าคอมโพเนนต์ตัวนั้นเป็นอินสแตนซ์ของ Button หรือ SelectBox หรือไม่ มันเพียงแค่เรียกใช้เมธอด draw บนคอมโพเนนต์นั้นเท่านั้น ด้วยการระบุ Box<dyn Draw> เป็นชนิดข้อมูลของสมาชิกในเวกเตอร์ components เราจึงได้กำหนดไว้ว่า Screen ต้องการเพียงค่าใดก็ตามที่เราสามารถเรียกเมธอด draw ได้

ข้อดีของการใช้เทรตออบเจกต์และระบบชนิดข้อมูลของ Rust เพื่อเขียนโค้ดในลักษณะที่คล้ายกับ duck typing คือ เราไม่จำเป็นต้องคอยตรวจสอบว่าค่านั้น ๆ อิมพลีเมนต์เมธอดที่ต้องการหรือไม่ในตอนรันไทม์ และไม่ต้องกังวลว่าจะเกิด runtime error หากเผลอไปเรียกเมธอดที่ค่านั้นไม่ได้อิมพลีเมนต์ไว้ เพราะ Rust จะไม่ยอมคอมไพล์โค้ดของเราตั้งแต่แรก หากค่าเหล่านั้นไม่ได้อิมพลีเมนต์เทรตที่เทรตออบเจกต์กำหนดไว้

ตัวอย่างเช่น ลิสติ้ง 18-10 แสดงสิ่งที่จะเกิดขึ้นเมื่อเราพยายามสร้าง Screen โดยส่ง String เข้าไปเป็นคอมโพเนนต์ตัวหนึ่ง

use gui::Screen;

fn main() {
    let screen = Screen {
        components: vec![Box::new(String::from("Hi"))],
    };

    screen.run();
}

เราจะได้รับข้อผิดพลาดนี้เพราะ String ไม่ได้อิมพลีเมนต์เทรต Draw:

$ cargo run
   Compiling gui v0.1.0 (file:///projects/gui)
error[E0277]: the trait bound `String: Draw` is not satisfied
  --> src/main.rs:5:26
   |
 5 |         components: vec![Box::new(String::from("Hi"))],
   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Draw` is not implemented for `String`
   |
help: the trait `Draw` is implemented for `Button`
  --> src/lib.rs:23:1
   |
23 | impl Draw for Button {
   | ^^^^^^^^^^^^^^^^^^^^
   = note: required for the cast from `Box<String>` to `Box<dyn Draw>`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `gui` (bin "gui") due to 1 previous error

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

การดิสแพตช์แบบไดนามิก

ย้อนกลับไปในหัวข้อ “ประสิทธิภาพของโค้ดที่ใช้เจเนอริก” ในบทที่ 10 ที่เราได้อธิบายถึงกระบวนการมอโนมอร์ไฟเซชัน (monomorphization) ซึ่งคอมไพเลอร์จะทำให้กับโค้ดเจเนอริก: โดยคอมไพเลอร์จะสร้างการอิมพลีเมนต์ฟังก์ชันและเมธอดแบบไม่ใช้เจเนอริกขึ้นมาสำหรับแต่ละชนิดข้อมูลรูปธรรมที่เรานำมาแทนที่พารามิเตอร์ชนิดข้อมูลเจเนอริก โค้ดที่ได้จากกระบวนการนี้จะทำงานแบบ_การดิสแพตช์แบบสแตติก_ (static dispatch) ซึ่งหมายถึงคอมไพเลอร์รู้ตั้งแต่ตอนคอมไพล์แล้วว่าจะต้องเรียกใช้เมธอดตัวใด สิ่งนี้ตรงกันข้ามกับ_การดิสแพตช์แบบไดนามิก_ (dynamic dispatch) ซึ่งคอมไพเลอร์ไม่สามารถบอกได้ในตอนคอมไพล์ว่าเมธอดใดจะถูกเรียก โดยในกรณีนี้ คอมไพเลอร์จะสร้างโค้ดที่ไปค้นหาและตัดสินใจ ณ ตอนรันไทม์ว่าจะต้องเรียกใช้เมธอดใด

เมื่อเราใช้เทรตออบเจกต์ Rust จำเป็นต้องใช้การดิสแพตช์แบบไดนามิก เนื่องจากคอมไพเลอร์ไม่อาจล่วงรู้ชนิดข้อมูลทั้งหมดที่จะถูกนำมาใช้ร่วมกับโค้ดส่วนนั้น จึงไม่รู้ว่าควรเรียกเมธอดของชนิดข้อมูลใด แต่ ณ ตอนรันไทม์ Rust จะใช้พอยน์เตอร์ที่อยู่ภายในเทรตออบเจกต์เพื่อระบุเมธอดที่ต้องเรียกใช้ การค้นหาเมธอดนี้มีต้นทุนการประมวลผล (overhead) เพิ่มเติมตอนรันไทม์ซึ่งไม่เกิดขึ้นกับการดิสแพตช์แบบสแตติก นอกจากนี้ การดิสแพตช์แบบไดนามิกยังทำให้คอมไพเลอร์ไม่สามารถเลือกทำอินไลน์ (inline) โค้ดของเมธอดได้ ซึ่งส่งผลให้ไม่สามารถทำออปติไมเซชัน (optimization) บางอย่างได้ตามไปด้วย ทั้งนี้ Rust ยังมีกฎเกณฑ์ที่กำหนดว่าจุดใดบ้างที่สามารถหรือไม่สามารถใช้การดิสแพตช์แบบไดนามิกได้ ซึ่งเรียกว่า ความเข้ากันได้ของ dyn (dyn compatibility) กฎเหล่านั้นอยู่นอกเหนือขอบเขตของเนื้อหาในส่วนนี้ แต่คุณสามารถอ่านเพิ่มเติมได้ในเรเฟอเรนซ์ อย่างไรก็ดี เราได้รับความยืดหยุ่นเพิ่มขึ้นอย่างมากในโค้ดที่เราเขียนไว้ในลิสติ้ง 18-5 และลิสติ้ง 18-9 จึงถือเป็นข้อแลกเปลี่ยนที่คุณควรพิจารณาให้เหมาะสมกับการใช้งาน