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

ชนิดข้อมูลขั้นสูง

ระบบชนิดข้อมูลของ Rust ยังมีฟีเจอร์บางประการที่เราเคยกล่าวถึงมาบ้างแล้ว แต่ยังไม่ได้อธิบายในรายละเอียด เราจะเริ่มต้นด้วยการศึกษาเกี่ยวกับรูปแบบนิวไทป์ (newtypes) ในภาพรวม พร้อมทั้งพิจารณาว่าเหตุใดรูปแบบนี้จึงมีประโยชน์ในฐานะชนิดข้อมูล จากนั้นเราจะไปต่อกันที่นามแฝงชนิดข้อมูล (type aliases) ซึ่งเป็นฟีเจอร์ที่คล้ายกับนิวไทป์แต่มีความหมายเชิงความหมาย (semantics) แตกต่างกันเล็กน้อย นอกจากนี้เรายังจะกล่าวถึงชนิดข้อมูล ! (never type) และชนิดข้อมูลที่กำหนดขนาดแบบไดนามิก (dynamically sized types) อีกด้วย

ความปลอดภัยของชนิดข้อมูลและแอบสแตรกชันด้วยแพตเทิร์นนิวไทป์

หัวข้อนี้ตั้งอยู่บนสมมติฐานว่าคุณได้อ่านหัวข้อ“การอิมพลีเมนต์เทรตภายนอกด้วยแพตเทิร์นนิวไทป์” ในตอนต้นมาแล้ว รูปแบบนิวไทป์ (newtype pattern) ยังมีประโยชน์ต่องานอื่น ๆ นอกเหนือจากที่เราได้กล่าวไปแล้ว ซึ่งรวมถึงการบังคับความถูกต้องในระดับสแตติก (statically enforcing) เพื่อป้องกันไม่ให้เกิดความสับสนในการใช้งานค่าต่าง ๆ และการใช้ระบุหน่วยวัดของค่าข้อมูล คุณได้เห็นตัวอย่างการนำนิวไทป์มาใช้ระบุหน่วยวัดในลิสติ้ง 20-16 ไปแล้ว: ย้อนนึกถึง struct Millimeters และ Meters ที่นำค่า u32 มาห่อหุ้มไว้ในนิวไทป์ หากเราเขียนฟังก์ชันที่รับพารามิเตอร์ชนิด Millimeters คอมไพเลอร์จะไม่อนุญาตให้โปรแกรมคอมไพล์ผ่าน หากเผลอเรียกใช้ฟังก์ชันนั้นด้วยค่าชนิด Meters หรือค่า u32 ธรรมดา

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

นิวไทป์ยังสามารถช่วยซ่อนการทำงานภายในได้เป็นอย่างดี ตัวอย่างเช่น เราสามารถสร้างชนิดข้อมูล People ขึ้นมาเพื่อห่อหุ้ม HashMap<i32, String> ที่จัดเก็บ ID ของบุคคลคู่กับชื่อของบุคคลนั้น โค้ดที่เรียกใช้ People จะโต้ตอบเฉพาะกับ API สาธารณะที่เราเตรียมไว้ให้เท่านั้น เช่น เมธอดสำหรับเพิ่มชื่อสตริงลงในคอลเลกชัน People โดยโค้ดภายนอกไม่จำเป็นต้องรับรู้เลยว่าภายในเรากำหนด ID ชนิด i32 ให้กับชื่อต่าง ๆ อย่างไร รูปแบบนิวไทป์จึงเป็นวิธีที่เบาและเรียบง่ายในการสร้างการห่อหุ้ม (encapsulation) เพื่อซ่อนรายละเอียดการอิมพลีเมนต์ ดังที่เราได้พูดคุยกันในหัวข้อ“การห่อหุ้มที่ซ่อนรายละเอียดการอิมพลีเมนต์” ในบทที่ 18

ชื่อพ้องของชนิดข้อมูลและชื่อแทนชนิดข้อมูล

Rust เปิดความสามารถให้คุณประกาศ นามแฝงชนิดข้อมูล (type alias) เพื่อตั้งชื่ออื่นให้กับชนิดข้อมูลเดิมที่มีอยู่แล้ว โดยใช้คำสงวน type ตัวอย่างเช่น เราสามารถสร้างนามแฝง Kilometers ให้กับ i32 ได้ดังนี้:

fn main() {
    type Kilometers = i32;

    let x: i32 = 5;
    let y: Kilometers = 5;

    println!("x + y = {}", x + y);
}

ตอนนี้นามแฝง Kilometers จึงเป็น คำพ้อง (synonym) ของ i32 ซึ่งต่างจากชนิดข้อมูล Millimeters และ Meters ที่เราสร้างขึ้นในลิสติ้ง 20-16 เพราะ Kilometers ไม่ใช่ชนิดข้อมูลใหม่ที่แยกออกมา ค่าที่มีชนิด Kilometers จะได้รับการปฏิบัติตามมาตรฐานเดียวกับค่าที่มีชนิด i32 ทุกประการ:

fn main() {
    type Kilometers = i32;

    let x: i32 = 5;
    let y: Kilometers = 5;

    println!("x + y = {}", x + y);
}

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

กรณีการใช้งานหลักของนามแฝงชนิดข้อมูลคือการลดความซ้ำซ้อน ตัวอย่างเช่น เราอาจมีชนิดข้อมูลที่ยาวและซับซ้อนเช่นนี้:

Box<dyn Fn() + Send + 'static>

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

fn main() {
    let f: Box<dyn Fn() + Send + 'static> = Box::new(|| println!("hi"));

    fn takes_long_type(f: Box<dyn Fn() + Send + 'static>) {
        // --snip--
    }

    fn returns_long_type() -> Box<dyn Fn() + Send + 'static> {
        // --snip--
        Box::new(|| ())
    }
}

นามแฝงชนิดข้อมูลช่วยให้โค้ดนี้จัดการได้ง่ายขึ้นมากด้วยการลดความซ้ำซ้อน ในลิสติ้ง 20-26 เราได้แนะนำนามแฝงชื่อ Thunk สำหรับชนิดข้อมูลที่ยาวนี้ และสามารถแทนที่การใช้งานชนิดข้อมูลนั้นทั้งหมดด้วยนามแฝงที่สั้นกระชับอย่าง Thunk

fn main() {
    type Thunk = Box<dyn Fn() + Send + 'static>;

    let f: Thunk = Box::new(|| println!("hi"));

    fn takes_long_type(f: Thunk) {
        // --snip--
    }

    fn returns_long_type() -> Thunk {
        // --snip--
        Box::new(|| ())
    }
}

โค้ดนี้อ่านและเขียนได้ง่ายขึ้นอย่างเห็นได้ชัด! การเลือกชื่อที่มีความหมายสำหรับนามแฝงชนิดข้อมูลยังช่วยสื่อเจตนารมณ์ของคุณได้ชัดเจนขึ้นอีกด้วย (thunk เป็นศัพท์ทางคอมพิวเตอร์ที่หมายถึงโค้ดที่จะถูกประเมินผลในภายหลัง จึงเป็นชื่อที่เหมาะสมอย่างยิ่งสำหรับโคลเชอร์ (closure) ที่ถูกบันทึกเก็บไว้)

นอกจากนี้นามแฝงชนิดข้อมูลยังนิยมนำมาใช้กับชนิด Result<T, E> เพื่อลดความซ้ำซ้อนเช่นกัน ลองพิจารณามอดูล std::io ในไลบรารีมาตรฐาน การทำงานเกี่ยวกับ I/O มักจะคืนค่าเป็น Result<T, E> เพื่อจัดการกับสถานการณ์ที่การทำงานล้มเหลว โดยไลบรารีนี้มี struct std::io::Error ที่เป็นตัวแทนของข้อผิดพลาด I/O ทั้งหมดที่เป็นไปได้ ฟังก์ชันจำนวนมากใน std::io จึงคืนค่าเป็น Result<T, E> โดยที่ E คือ std::io::Error เสมอ เช่นฟังก์ชันเหล่านี้ในเทรต Write:

use std::fmt;
use std::io::Error;

pub trait Write {
    fn write(&mut self, buf: &[u8]) -> Result<usize, Error>;
    fn flush(&mut self) -> Result<(), Error>;

    fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>;
    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<(), Error>;
}

การเขียน Result<..., Error> ซ้ำ ๆ เกิดขึ้นบ่อยครั้ง ด้วยเหตุนี้ std::io จึงได้ประกาศนามแฝงชนิดข้อมูลนี้ไว้:

use std::fmt;

type Result<T> = std::result::Result<T, std::io::Error>;

pub trait Write {
    fn write(&mut self, buf: &[u8]) -> Result<usize>;
    fn flush(&mut self) -> Result<()>;

    fn write_all(&mut self, buf: &[u8]) -> Result<()>;
    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<()>;
}

เนื่องจากการประกาศนี้อยู่ภายในมอดูล std::io เราจึงสามารถเรียกใช้นามแฝงแบบระบุชื่อเต็มได้เป็น std::io::Result<T> ซึ่งก็คือ Result<T, E> ที่เติม E เป็น std::io::Error ไว้แล้วนั่นเอง ส่งผลให้ซิกเนเจอร์ของฟังก์ชันในเทรต Write กลายมาเป็นดังนี้:

use std::fmt;

type Result<T> = std::result::Result<T, std::io::Error>;

pub trait Write {
    fn write(&mut self, buf: &[u8]) -> Result<usize>;
    fn flush(&mut self) -> Result<()>;

    fn write_all(&mut self, buf: &[u8]) -> Result<()>;
    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<()>;
}

นามแฝงชนิดข้อมูลช่วยเราใน 2 ด้าน: ทำให้เขียนโค้ดได้ง่ายขึ้น และ ทำให้อินเทอร์เฟซมีความสอดคล้องกันตลอดทั้งมอดูล std::io และเนื่องจากมันเป็นเพียงนามแฝง จึงทำงานเสมือนเป็น Result<T, E> ตัวเดิมทุกประการ ทำให้เราสามารถเรียกใช้เมธอดใด ๆ ที่มีใน Result<T, E> ได้ตามปกติ รวมถึงไวยากรณ์พิเศษอย่างตัวดำเนินการ ? ด้วย

ชนิดไม่คืนค่าที่ไม่คืนค่าเลย

Rust มีชนิดข้อมูลพิเศษที่มีชื่อว่า ! ซึ่งในเชิงทฤษฎีชนิดข้อมูล (type theory) จะเรียกว่า ชนิดข้อมูลว่าง (empty type) เนื่องจากชนิดข้อมูลนี้ไม่มีค่าใด ๆ เลย แต่เรานิยมเรียกว่า ชนิดไม่คืนค่า (never type) เพราะมันจะถูกนำมาวางแทนตำแหน่งของชนิดข้อมูลคืนค่า เมื่อฟังก์ชันนั้นจะไม่มีวันคืนค่ากลับมาเลย นี่คือตัวอย่าง:

fn bar() -> ! {
    // --snip--
    panic!();
}

โค้ดนี้อ่านความหมายได้ว่า “ฟังก์ชัน bar ไม่คืนค่าใด ๆ เลย” โดยฟังก์ชันที่ไม่เคยคืนค่ากลับมาจะเรียกว่า ฟังก์ชันลู่ออก (diverging functions) เราไม่สามารถสร้างค่าของชนิดข้อมูล ! ขึ้นมาได้ ดังนั้น bar จึงไม่มีทางส่งค่าคืนกลับมาได้อย่างแน่นอน

แต่ชนิดข้อมูลที่ไม่สามารถสร้างค่าได้เลยจะมีประโยชน์อย่างไร? ย้อนนึกถึงโค้ดจากลิสติ้ง 2-5 ซึ่งเป็นส่วนหนึ่งของเกมทายตัวเลข เราได้คัดลอกบางส่วนของโค้ดนั้นมาแสดงอีกครั้งในลิสติ้ง 20-27

use std::cmp::Ordering;
use std::io;

use rand::prelude::*;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::rng().random_range(1..=100);

    println!("The secret number is: {secret_number}");

    loop {
        println!("Please input your guess.");

        let mut guess = String::new();

        // --snip--

        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("You guessed: {guess}");

        // --snip--

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

ในตอนนั้น เราได้ข้ามรายละเอียดบางจุดของโค้ดนี้ไป ในหัวข้อ“โครงสร้างควบคุมโฟลว์ match” ในบทที่ 6 เราได้พูดคุยกันว่าทุกกิ่งกรณี (arm) ของนิพจน์ match จะต้องคืนค่าเป็นชนิดข้อมูลเดียวกัน ดังนั้น ตัวอย่างเช่น โค้ดต่อไปนี้จะไม่สามารถทำงานได้:

fn main() {
    let guess = "3";
    let guess = match guess.trim().parse() {
        Ok(_) => 5,
        Err(_) => "hello",
    };
}

ชนิดข้อมูลของ guess ในโค้ดนี้จะต้องเป็นทั้งจำนวนเต็ม และ สตริงในเวลาเดียวกัน ซึ่ง Rust กำหนดไว้ว่า guess จะต้องมีเพียงชนิดข้อมูลเดียวเท่านั้น แล้วคำสั่ง continue คืนค่าอะไรกลับมาล่ะ? เหตุใดเราจึงได้รับอนุญาตให้คืนค่า u32 จากกิ่งหนึ่ง และมีอีกกิ่งหนึ่งที่ลงท้ายด้วย continue ในลิสติ้ง 20-27 ได้?

อย่างที่คุณอาจเดาได้ ค่าของ continue คือชนิดข้อมูล ! กล่าวคือ เมื่อ Rust ประเมินชนิดข้อมูลของ guess คอมไพเลอร์จะดูที่กิ่งทั้งสองของ match โดยกิ่งแรกให้ค่าเป็น u32 และกิ่งหลังให้ค่าเป็น ! และเนื่องจาก ! ไม่มีวันมีค่าอยู่จริง Rust จึงตัดสินว่าชนิดข้อมูลของ guess คือ u32

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

ชนิดไม่คืนค่ายังมีประโยชน์ร่วมกับมาโคร panic! อีกด้วย ย้อนนึกถึงฟังก์ชัน unwrap ที่เราเรียกใช้บนค่า Option<T> เพื่อดึงค่าออกมาหรือสั่งแพนิกตามนิยามต่อไปนี้:

enum Option<T> {
    Some(T),
    None,
}

use crate::Option::*;

impl<T> Option<T> {
    pub fn unwrap(self) -> T {
        match self {
            Some(val) => val,
            None => panic!("called `Option::unwrap()` on a `None` value"),
        }
    }
}

ในโค้ดนี้ เกิดกระบวนการแบบเดียวกับ match ในลิสติ้ง 20-27: Rust ตรวจพบว่า val มีชนิดข้อมูล T และ panic! มีชนิดข้อมูล ! ดังนั้นผลลัพธ์ของนิพจน์ match โดยรวมจึงเป็น T โค้ดนี้ทำงานได้ถูกต้องเพราะ panic! ไม่ได้สร้างค่าส่งกลับมา แต่เป็นการยุติการทำงานของโปรแกรม ในกรณีที่เป็น None เราจะไม่คืนค่าใด ๆ จาก unwrap โค้ดนี้จึงถูกต้องสมบูรณ์

นิพจน์สุดท้ายที่มีชนิดข้อมูลเป็น ! คือลูปที่ไม่รู้จบ:

fn main() {
    print!("forever ");

    loop {
        print!("and ever ");
    }
}

ในกรณีนี้ ลูปไม่มีวันสิ้นสุดลง ค่าของนิพจน์จึงเป็น ! อย่างไรก็ตาม สิ่งนี้จะไม่เป็นจริงหากเราใส่คำสั่ง break เข้าไป เพราะลูปจะหยุดทำงานเมื่อทำงานไปถึงจุดที่มี break

ชนิดข้อมูลขนาดไดนามิกและเทรต Sized

Rust จำเป็นต้องทราบรายละเอียดบางอย่างเกี่ยวกับชนิดข้อมูล เช่น ต้องจัดสรรพื้นที่หน่วยความจำเท่าใดสำหรับค่าของชนิดข้อมูลหนึ่ง ๆ จุดนี้อาจทำให้ระบบชนิดข้อมูลของ Rust ดูชวนสับสนอยู่บ้างในตอนแรก นั่นคือแนวคิดเรื่อง ชนิดข้อมูลที่กำหนดขนาดแบบไดนามิก (dynamically sized types) ซึ่งบางครั้งเรียกว่า DSTs หรือ ชนิดข้อมูลที่ไม่มีขนาดแน่นอน (unsized types) ชนิดข้อมูลเหล่านี้ช่วยให้เราสามารถเขียนโค้ดเพื่อจัดการกับค่าข้อมูลที่เราจะทราบขนาดได้ในตอนรันไทม์เท่านั้น

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

fn main() {
    let s1: str = "Hello there!";
    let s2: str = "How's it going?";
}

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

แล้วเรามีวิธีแก้อย่างไร? ในกรณีนี้ คุณคงทราบคำตอบดีอยู่แล้ว: เราเปลี่ยนชนิดข้อมูลของ s1 และ s2 ให้เป็นสตริงสไลซ์ (&str) แทนที่จะเป็น str ย้อนนึกถึงหัวข้อ“สตริงสไลซ์” ในบทที่ 4 ซึ่งระบุว่าโครงสร้างข้อมูลของสไลซ์จะเก็บเพียงตำแหน่งเริ่มต้นและความยาวของสไลซ์เท่านั้น ดังนั้น แม้ว่า &T จะเป็นค่าเดี่ยว ๆ ที่เก็บแอดเดรสหน่วยความจำที่ T วางอยู่ แต่สตริงสไลซ์จะประกอบด้วยค่า สอง ค่า ได้แก่ แอดเดรสของ str และความยาวของมัน ด้วยเหตุนี้ เราจึงสามารถทราบขนาดของค่าสตริงสไลซ์ได้ในตอนคอมไพล์ ซึ่งก็คือมีขนาดเป็น 2 เท่าของความยาวของชนิด usize นั่นหมายความว่าเราทราบขนาดของสตริงสไลซ์เสมอ ไม่ว่าข้อความสตริงที่มันอ้างอิงถึงจะมีความยาวเท่าใดก็ตาม โดยทั่วไปแล้ว นี่คือวิธีการที่ Rust ใช้จัดการกับชนิดข้อมูลที่กำหนดขนาดแบบไดนามิก: มีการแนบข้อมูลเมทาดาทา (metadata) เพิ่มเติมเล็กน้อยเพื่อเก็บขนาดของข้อมูลแบบไดนามิกนั้น กฎเหล็กของชนิดข้อมูลที่กำหนดขนาดแบบไดนามิกคือ เราจะต้องวางค่าของชนิดข้อมูลดังกล่าวไว้เบื้องหลังพอยน์เตอร์เสมอ

เราสามารถใช้งาน str ร่วมกับพอยน์เตอร์ได้ทุกรูปแบบ เช่น Box<str> หรือ Rc<str> อันที่จริง คุณเคยพบเห็นรูปแบบนี้มาก่อนแล้วกับชนิดข้อมูลที่กำหนดขนาดแบบไดนามิกอีกประเภทหนึ่ง นั่นคือ เทรต (traits) ทุกเทรตถือเป็นชนิดข้อมูลที่กำหนดขนาดแบบไดนามิกที่เราสามารถอ้างอิงถึงได้โดยใช้ชื่อของเทรตนั้น ในหัวข้อ“การใช้เทรตออบเจกต์เพื่อนามธรรมพฤติกรรมร่วม” ในบทที่ 18 เราได้อธิบายว่าในการใช้งานเทรตในฐานะเทรตออบเจกต์ (trait object) เราจะต้องวางเทรตไว้เบื้องหลังพอยน์เตอร์เสมอ เช่น &dyn Trait หรือ Box<dyn Trait> (Rc<dyn Trait> ก็ใช้ได้เช่นกัน)

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

fn generic<T>(t: T) {
    // --snip--
}

แท้จริงแล้วจะได้รับการปฏิบัติต่อเสมือนว่าเราเขียนไว้เช่นนี้:

fn generic<T: Sized>(t: T) {
    // --snip--
}

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

fn generic<T: ?Sized>(t: &T) {
    // --snip--
}

ข้อกำหนดเทรตบน ?Sized มีความหมายว่า “T อาจทราบขนาด (Sized) หรือไม่ทราบขนาดก็ได้” และสัญลักษณ์นี้จะเข้าแทนที่ข้อกำหนดเริ่มต้นที่ว่าชนิดข้อมูลเจเนอริกต้องทราบขนาดในตอนคอมไพล์ ไวยากรณ์ ?Trait ที่มีความหมายในลักษณะนี้เปิดให้ใช้งานได้เฉพาะกับเทรต Sized เท่านั้น ไม่สามารถใช้กับเทรตอื่นใดได้

โปรดสังเกตด้วยว่าเราเปลี่ยนชนิดข้อมูลของพารามิเตอร์ t จาก T เป็น &T เนื่องจากชนิดข้อมูลอาจไม่ทราบขนาด (!Sized) เราจึงจำเป็นต้องเรียกใช้งานผ่านพอยน์เตอร์รูปแบบใดรูปแบบหนึ่ง ซึ่งในกรณีนี้เราเลือกใช้การอ้างอิง (reference)

ในหัวข้อถัดไป เราจะมาพูดคุยกันถึงเรื่องฟังก์ชันและโคลเชอร์ขั้นสูงกันต่อ!