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

ชนิดข้อมูลเจเนอริก

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

ในนิยามฟังก์ชัน

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

ต่อเนื่องจากฟังก์ชัน largest ของเรา ในลิสติ้ง 10-4 แสดงฟังก์ชันสองตัวที่ต่างก็ทำหน้าที่ค้นหาค่าที่มากที่สุดในสไลซ์เหมือนกัน ซึ่งหลังจากนี้เราจะรวมฟังก์ชันทั้งสองเข้าด้วยกันเป็นฟังก์ชันเดียวที่ใช้เจเนอริก

fn largest_i32(list: &[i32]) -> &i32 {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn largest_char(list: &[char]) -> &char {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest_i32(&number_list);
    println!("The largest number is {result}");
    assert_eq!(*result, 100);

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest_char(&char_list);
    println!("The largest char is {result}");
    assert_eq!(*result, 'y');
}

ฟังก์ชัน largest_i32 คือฟังก์ชันที่เราแยกออกมาในลิสติ้ง 10-3 ซึ่งค้นหาค่า i32 ที่มากที่สุดในสไลซ์ ส่วนฟังก์ชัน largest_char ใช้ค้นหาค่า char ที่มากที่สุดในสไลซ์ เนื้อหาของฟังก์ชันทั้งสองชุดนี้เหมือนกันทุกประการ ดังนั้นเรามาขจัดความซ้ำซ้อนโดยการใส่พารามิเตอร์ประเภทข้อมูล (type parameter) แบบเจเนอริกลงในฟังก์ชันเพียงฟังก์ชันเดียวกัน

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

เวลาที่เราใช้พารามิเตอร์ในเนื้อหาของฟังก์ชัน เราต้องประกาศชื่อพารามิเตอร์นั้นไว้ในลายเซ็นฟังก์ชันก่อนเพื่อให้คอมไพเลอร์เข้าใจว่าชื่อนั้นหมายถึงอะไร เช่นเดียวกัน เมื่อเราใช้ชื่อพารามิเตอร์ประเภทข้อมูลในลายเซ็นฟังก์ชัน เราก็ต้องประกาศชื่อพารามิเตอร์ประเภทข้อมูลนั้นไว้ก่อนที่จะนำไปใช้ ในการนิยามฟังก์ชัน largest ให้เป็นเจเนอริก เราจะใส่การประกาศชื่อประเภทไว้ภายในวงเล็บสามเหลี่ยม <> ระหว่างชื่อฟังก์ชันกับรายการพารามิเตอร์ ดังนี้:

fn largest<T>(list: &[T]) -> &T {

เราอ่านนิยามนี้ได้ว่า: “ฟังก์ชัน largest เป็นเจเนอริกเหนือประเภท T ใดๆ” ฟังก์ชันนี้รับพารามิเตอร์หนึ่งตัวชื่อ list ซึ่งเป็นสไลซ์ของค่าประเภท T และฟังก์ชัน largest จะส่งคืนเรเฟอเรนซ์ที่ชี้ไปยังค่าประเภท T เดียวกันนั้นออกมา

ลิสติ้ง 10-5 แสดงนิยามของฟังก์ชัน largest ที่รวมทั้งสองฟังก์ชันเข้าด้วยกันโดยใช้ประเภทข้อมูลเจเนอริกในลายเซ็นของมัน พร้อมทั้งแสดงวิธีการเรียกใช้ฟังก์ชันด้วยสไลซ์ของค่า i32 หรือค่า char ทว่าโปรดสังเกตว่า โค้ดนี้จะยังคอมไพล์ไม่ผ่าน!

fn largest<T>(list: &[T]) -> &T {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest(&number_list);
    println!("The largest number is {result}");

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest(&char_list);
    println!("The largest char is {result}");
}

หากเราคอมไพล์โค้ดนี้ในตอนนี้ เราจะพบกับข้อผิดพลาดดังนี้:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0369]: binary operation `>` cannot be applied to type `&T`
 --> src/main.rs:5:17
  |
5 |         if item > largest {
  |            ---- ^ ------- &T
  |            |
  |            &T
  |
help: consider restricting type parameter `T` with trait `PartialOrd`
  |
1 | fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> &T {
  |             ++++++++++++++++++++++

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

ข้อความแนะนำ (help note) ได้กล่าวถึง std::cmp::PartialOrd ซึ่งเป็น เทรต (trait) โดยเราจะมาเจาะลึกเรื่องเทรตกันในหัวข้อถัดไป แต่สำหรับตอนนี้ ให้เข้าใจก่อนว่าข้อผิดพลาดนี้ชี้แจงว่า เนื้อหาของฟังก์ชัน largest จะไม่สามารถทำงานได้กับทุกประเภทข้อมูลที่ T จะเป็นไปได้ เพราะในเนื้อหาฟังก์ชันเราต้องการเปรียบเทียบค่าประเภท T เราจึงใช้งานได้เฉพาะกับประเภทข้อมูลที่สามารถนำค่ามาเปรียบเทียบเรียงลำดับกันได้เท่านั้น และเพื่อเปิดใช้งานความสามารถในการเปรียบเทียบ ไลบรารีมาตรฐานจึงมีเทรต std::cmp::PartialOrd ที่คุณสามารถอิมพลีเมนต์ให้กับประเภทข้อมูลได้ (ดูรายละเอียดเพิ่มเติมเกี่ยวกับเทรตนี้ได้ในภาคผนวก C) หากเราปฏิบัติตามคำแนะนำของคอมไพเลอร์โดยจำกัดประเภทข้อมูลของ T ให้รับเฉพาะประเภทที่อิมพลีเมนต์ PartialOrd ตัวอย่างนี้ก็จะสามารถคอมไพล์ผ่านได้ทันที เพราะไลบรารีมาตรฐานได้อิมพลีเมนต์ PartialOrd ให้กับทั้ง i32 และ char ไว้เรียบร้อยแล้ว

ในนิยาม struct

เรายังสามารถนิยาม struct ให้ใช้พารามิเตอร์ประเภทข้อมูลแบบเจเนอริกในฟิลด์ต่างๆ ได้ โดยใช้ไวยากรณ์ <> ลิสติ้ง 10-6 นิยาม struct Point<T> เพื่อเก็บค่าพิกัด x และ y ของประเภทข้อมูลใดๆ ก็ได้

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let integer = Point { x: 5, y: 10 };
    let float = Point { x: 1.0, y: 4.0 };
}

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

สังเกตว่า เนื่องด้วยเราใช้พารามิเตอร์เจเนอริกเพียงตัวเดียวในการนิยาม Point<T> นิยามนี้จึงระบุว่า struct Point<T> เป็นเจเนอริกเหนือประเภท T และฟิลด์ x กับ y จะต้องเป็นประเภทเดียวกัน ทั้งคู่ ไม่ว่าประเภทนั้นจะเป็นอะไรก็ตาม หากเราสร้างอินสแตนซ์ของ Point<T> ที่มีค่าคนละประเภทกัน ดังในลิสติ้ง 10-7 โค้ดของเราจะไม่สามารถคอมไพล์ผ่านได้

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let wont_work = Point { x: 5, y: 4.0 };
}

ในตัวอย่างนี้ เมื่อเรากำหนดจำนวนเต็ม 5 ให้กับ x คอมไพเลอร์จะเข้าใจทันทีว่าประเภทเจเนอริก T ของอินสแตนซ์ Point<T> ตัวนี้คือจำนวนเต็ม ดังนั้นเมื่อเราระบุค่า 4.0 (ซึ่งเป็นเลขทศนิยม) ให้กับ y ที่ถูกนิยามไว้ว่าต้องเป็นประเภทเดียวกับ x เราจึงได้รับข้อผิดพลาดเรื่องประเภทข้อมูลไม่ตรงกันดังนี้:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0308]: mismatched types
 --> src/main.rs:7:38
  |
7 |     let wont_work = Point { x: 5, y: 4.0 };
  |                                      ^^^ expected integer, found floating-point number

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

หากต้องการนิยาม struct Point ให้ x และ y เป็นเจเนอริกที่สามารถมีประเภทข้อมูลต่างกันได้ เราสามารถใช้พารามิเตอร์ประเภทข้อมูลแบบเจเนอริกหลายตัวพร้อมกันได้ ตัวอย่างเช่น ในลิสติ้ง 10-8 เราได้ปรับนิยามของ Point ให้เป็นเจเนอริกเหนือประเภท T และ U โดยที่ x มีประเภทเป็น T และ y มีประเภทเป็น U

struct Point<T, U> {
    x: T,
    y: U,
}

fn main() {
    let both_integer = Point { x: 5, y: 10 };
    let both_float = Point { x: 1.0, y: 4.0 };
    let integer_and_float = Point { x: 5, y: 4.0 };
}

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

ในนิยาม enum

เช่นเดียวกับ struct เราสามารถนิยาม enum ให้เก็บประเภทข้อมูลแบบเจเนอริกไว้ภายในวาเรียนต์ต่างๆ ได้ มาย้อนดู enum Option<T> ของไลบรารีมาตรฐานที่เราเคยใช้กันในบทที่ 6 อีกครั้ง:

#![allow(unused)]
fn main() {
enum Option<T> {
    Some(T),
    None,
}
}

ถึงตอนนี้ นิยามนี้น่าจะดูเข้าใจง่ายและชัดเจนขึ้นมากสำหรับคุณแล้ว ดังที่คุณเห็น enum Option<T> เป็นเจเนอริกเหนือประเภท T และมีสองวาเรียนต์ ได้แก่: Some ซึ่งบรรจุค่าหนึ่งค่าประเภท T และวาเรียนต์ None ซึ่งไม่บรรจุค่าใดๆ เลย การใช้ enum Option<T> ช่วยให้เราสามารถถ่ายทอดแนวคิดเชิงนามธรรมของค่าที่อาจมีหรือไม่มีก็ได้ และด้วยความที่ Option<T> เป็นเจเนอริก เราจึงสามารถนำนามธรรมนี้ไปประยุกต์ใช้ได้กับทุกประเภทข้อมูล ไม่ว่าค่านั้นจะเป็นประเภทใดก็ตาม

นอกจากนี้ enum ยังสามารถใช้ประเภทเจเนอริกหลายตัวพร้อมกันได้ด้วย ตัวอย่างเช่น นิยามของ enum Result ที่เราเพิ่งใช้งานกันในบทที่ 9:

#![allow(unused)]
fn main() {
enum Result<T, E> {
    Ok(T),
    Err(E),
}
}

enum Result เป็นเจเนอริกเหนือสองประเภทข้อมูลคือ T และ E โดยมีสองวาเรียนต์ ได้แก่ Ok ซึ่งบรรจุค่าประเภท T และ Err ซึ่งบรรจุค่าประเภท E นิยามนี้ช่วยให้เราสามารถนำ enum Result ไปใช้งานได้อย่างสะดวกสบายในทุกที่ที่มีการดำเนินการซึ่งอาจสำเร็จ (ส่งคืนค่าประเภท T) หรืออาจล้มเหลว (ส่งคืนข้อผิดพลาดประเภท E) ซึ่งที่จริงนี่คือสิ่งที่เราใช้ในการเปิดไฟล์ในลิสติ้ง 9-3 โดย T ถูกแทนที่ด้วยประเภท std::fs::File เมื่อเปิดไฟล์สำเร็จ และ E ถูกแทนที่ด้วยประเภท std::io::Error เมื่อเกิดปัญหาในการเปิดไฟล์

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

ในนิยามเมธอด

เราสามารถอิมพลีเมนต์เมธอดบน struct และ enum (ดังที่เราเคยทำในบทที่ 5) และนำประเภทเจเนอริกมาใช้ในนิยามของเมธอดเหล่านั้นได้ด้วยเช่นกัน ลิสติ้ง 10-9 แสดง struct Point<T> ที่เรานิยามไว้ในลิสติ้ง 10-6 พร้อมกับเมธอดชื่อ x ที่อิมพลีเมนต์ขึ้นสำหรับมัน

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };

    println!("p.x = {}", p.x());
}

ในตัวอย่างนี้ เราได้นิยามเมธอดชื่อ x บน Point<T> ซึ่งจะส่งคืนเรเฟอเรนซ์ที่ชี้ไปยังข้อมูลในฟิลด์ x

สังเกตว่าเราจำเป็นต้องประกาศ T ไว้หลัง impl เพื่อให้เราสามารถใช้ T ในการระบุว่าเรากำลังอิมพลีเมนต์เมธอดให้กับประเภท Point<T> การประกาศ T เป็นประเภทเจเนอริกหลัง impl ช่วยให้ Rust แยกแยะได้ว่าประเภทในวงเล็บสามเหลี่ยมของ Point นั้นเป็นประเภทเจเนอริก ไม่ใช่ประเภทรูปธรรม ที่จริงเราสามารถเลือกใช้ชื่อพารามิเตอร์เจเนอริกอื่นแทนชื่อเดียวกับที่ประกาศใน struct ก็ได้ แต่ตามธรรมเนียมปฏิบัตินิยมใช้ชื่อเดียวกัน เมธอดที่เขียนอยู่ภายในบล็อก impl ที่ประกาศประเภทเจเนอริกเช่นนี้จะพร้อมใช้งานบนทุกๆ อินสแตนซ์ของประเภทนั้นเสมอ ไม่ว่าประเภทรูปธรรมใดจะถูกนำมาแทนที่เจเนอริกในภายหลังก็ตาม

นอกจากนี้ เรายังสามารถระบุข้อจำกัดให้กับประเภทเจเนอริกในการนิยามเมธอดได้อีกด้วย ตัวอย่างเช่น เราสามารถเลือกอิมพลีเมนต์เมธอดเฉพาะบนอินสแตนซ์ของ Point<f32> เท่านั้น แทนที่จะอิมพลีเมนต์บนอินสแตนซ์ Point<T> ที่เป็นประเภทเจเนอริกใดๆ ในลิสติ้ง 10-10 เราเลือกใช้ประเภทรูปธรรม f32 โดยตรง ซึ่งหมายความว่าเราไม่จำเป็นต้องประกาศประเภทใดๆ หลัง impl เลย

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

impl Point<f32> {
    fn distance_from_origin(&self) -> f32 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };

    println!("p.x = {}", p.x());
}

โค้ดนี้หมายความว่า เฉพาะประเภท Point<f32> เท่านั้นที่จะมีเมธอด distance_from_origin ส่วนอินสแตนซ์อื่นๆ ของ Point<T> ที่ค่า T ไม่ใช่ f32 จะไม่มีเมธอดนี้ โดยเมธอดนี้ทำหน้าที่คำนวณระยะห่างระหว่างจุดของเรากับจุดพิกัด (0.0, 0.0) ซึ่งต้องอาศัยการคำนวณทางคณิตศาสตร์ที่มีให้ใช้เฉพาะกับประเภทตัวเลขทศนิยม (floating-point) เท่านั้น

พารามิเตอร์ประเภทข้อมูลแบบเจเนอริกในนิยามของ struct ไม่จำเป็นต้องเหมือนกับพารามิเตอร์เจเนอริกที่ใช้ในลายเซ็นเมธอดของ struct นั้นเสมอไป ในลิสติ้ง 10-11 เราใช้ประเภทเจเนอริก X1 และ Y1 สำหรับ struct Point และใช้ X2 กับ Y2 สำหรับลายเซ็นของเมธอด mixup เพื่อให้เห็นภาพตัวอย่างได้อย่างชัดเจน โดยเมธอดนี้จะสร้างอินสแตนซ์ Point ตัวใหม่ขึ้นมาจากการนำค่า x ของ self (ซึ่งเป็นประเภท X1) มารวมกับค่า y ของ Point ที่ส่งเข้ามาเป็นพารามิเตอร์ (ซึ่งเป็นประเภท Y2)

struct Point<X1, Y1> {
    x: X1,
    y: Y1,
}

impl<X1, Y1> Point<X1, Y1> {
    fn mixup<X2, Y2>(self, other: Point<X2, Y2>) -> Point<X1, Y2> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
}

fn main() {
    let p1 = Point { x: 5, y: 10.4 };
    let p2 = Point { x: "Hello", y: 'c' };

    let p3 = p1.mixup(p2);

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

ในฟังก์ชัน main เราได้สร้าง Point ที่มีค่า x เป็น i32 (ค่า 5) และมีค่า y เป็น f64 (ค่า 10.4) ส่วนตัวแปร p2 เป็น struct Point ที่มีค่า x เป็นสตริงสไลซ์ (ค่า "Hello") และมีค่า y เป็น char (ค่า 'c') การเรียกเมธอด mixup บน p1 โดยส่ง p2 เข้าไปเป็นอาร์กิวเมนต์ จะทำให้เราได้ p3 ซึ่งมีค่า x เป็น i32 (เพราะ x มาจาก p1) และมีค่า y เป็น char (เพราะ y มาจาก p2) การเรียกใช้แมโคร println! จึงพิมพ์ผลลัพธ์ออกมาเป็น p3.x = 5, p3.y = c

จุดประสงค์ของตัวอย่างนี้คือ เพื่อแสดงให้เห็นถึงสถานการณ์ที่พารามิเตอร์เจเนอริกบางตัวถูกประกาศไว้ร่วมกับ impl ในขณะที่พารามิเตอร์เจเนอริกบางตัวถูกประกาศไว้เฉพาะในนิยามของเมธอด ในที่นี้พารามิเตอร์เจเนอริก X1 และ Y1 ถูกประกาศไว้หลัง impl เพราะพวกมันผูกอยู่กับนิยามของ struct ส่วนพารามิเตอร์เจเนอริก X2 และ Y2 ถูกประกาศไว้หลัง fn mixup เพราะพวกมันเกี่ยวข้องกับการทำงานของเมธอดนั้นเท่านั้น

ประสิทธิภาพของโค้ดที่ใช้เจเนอริก

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

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

มาดูตัวอย่างการทำงานของกระบวนการนี้ผ่าน enum Option<T> ของไลบรารีมาตรฐานกัน:

#![allow(unused)]
fn main() {
let integer = Some(5);
let float = Some(5.0);
}

เมื่อ Rust ทำการคอมไพล์โค้ดนี้ มันจะเริ่มกระบวนการโมโนมอร์ไฟเซชัน โดยคอมไพเลอร์จะอ่านค่าที่ถูกส่งเข้าไปในอินสแตนซ์ของ Option<T> แล้วระบุได้ว่ามี Option<T> อยู่สองประเภท: ประเภทแรกคือ i32 และอีกประเภทหนึ่งคือ f64 จากนั้นคอมไพเลอร์จะแตกนิยามเจเนอริกของ Option<T> ออกเป็นสองนิยามที่เจาะจงสำหรับ i32 และ f64 แล้วนำนิยามเฉพาะเจาะจงเหล่านี้ไปแทนที่นิยามเจเนอริกเดิม

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

enum Option_i32 {
    Some(i32),
    None,
}

enum Option_f64 {
    Some(f64),
    None,
}

fn main() {
    let integer = Option_i32::Some(5);
    let float = Option_f64::Some(5.0);
}

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