ชนิดข้อมูลเจเนอริก
เราใช้เจเนอริก (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 มีประสิทธิภาพสูงสุดในตอนรันไทม์