เจเนอริก เทรต และไลฟ์ไทม์
ภาษาโปรแกรมทุกภาษามักมีเครื่องมือสำหรับจัดการกับความซ้ำซ้อนของแนวคิดหรือโค้ดอย่างมีประสิทธิภาพ ในภาษา Rust เครื่องมือสำคัญอย่างหนึ่งก็คือ เจเนอริก (generics) ซึ่งเป็นตัวแทนเชิงนามธรรม (abstract stand-ins) ของประเภทข้อมูลรูปธรรมหรือคุณสมบัติอื่นๆ เราสามารถเขียนกำหนดพฤติกรรมของเจเนอริกหรือความสัมพันธ์ของมันกับเจเนอริกอื่นๆ ได้ โดยไม่ต้องรู้ล่วงหน้าว่าจะมีประเภทข้อมูลใดมาแทนที่ตำแหน่งนั้นในตอนคอมไพล์และรันโค้ดจริง
ฟังก์ชันสามารถรับพารามิเตอร์ที่เป็นประเภทข้อมูลแบบเจเนอริก แทนที่จะเป็นประเภทข้อมูลรูปธรรมอย่าง i32 หรือ String ได้ เช่นเดียวกับที่ฟังก์ชันรับพารามิเตอร์ที่ไม่ทราบค่าล่วงหน้าเพื่อรันโค้ดชุดเดียวกันบนค่ารูปธรรมที่หลากหลาย ที่จริงแล้ว เราได้ใช้งานเจเนอริกกันมาแล้วในบทที่ 6 กับ Option<T>, ในบทที่ 8 กับ Vec<T> และ HashMap<K, V> รวมถึงในบทที่ 9 กับ Result<T, E> และในบทนี้ คุณจะได้สำรวจวิธีการนิยามประเภทข้อมูล, ฟังก์ชัน และเมธอดของคุณเองด้วยเจเนอริก!
ขั้นแรก เราจะมาทบทวนวิธีการแยกฟังก์ชัน (extract a function) ออกมาเพื่อลดความซ้ำซ้อนของโค้ด จากนั้นเราจะนำเทคนิคเดียวกันนี้มาประยุกต์เพื่อสร้างฟังก์ชันเจเนอริกขึ้นจากสองฟังก์ชันที่มีจุดแตกต่างกันเพียงแค่ประเภทของพารามิเตอร์เท่านั้น นอกจากนี้ เรายังจะอธิบายวิธีการนำประเภทเจเนอริกไปใช้ในการนิยาม struct และ enum อีกด้วย
ถัดมา คุณจะได้เรียนรู้วิธีการใช้เทรต (traits) เพื่อนิยามพฤติกรรมในรูปแบบเจเนอริก ซึ่งคุณสามารถนำเทรตมารวมเข้ากับประเภทเจเนอริก เพื่อกำหนดข้อจำกัด (constraint) ให้ประเภทเจเนอริกนั้นยอมรับเฉพาะประเภทข้อมูลที่มีพฤติกรรมตามที่ระบุไว้เท่านั้น แทนที่จะยอมรับประเภทใดก็ได้แบบไร้ขอบเขต
และสุดท้าย เราจะพูดถึงเรื่อง ไลฟ์ไทม์ (lifetimes): ซึ่งเป็นรูปแบบหนึ่งของเจเนอริกที่ช่วยส่งต่อข้อมูลให้แก่คอมไพเลอร์เกี่ยวกับความสัมพันธ์ของเรเฟอเรนซ์ต่างๆ โดยไลฟ์ไทม์จะช่วยให้เราสามารถบอกข้อมูลเกี่ยวกับค่าที่ถูกยืมให้คอมไพเลอร์ทราบอย่างเพียงพอ เพื่อให้คอมไพเลอร์สามารถรับประกันได้ว่าเรเฟอเรนซ์เหล่านั้นจะยังคงถูกต้องและใช้งานได้ในหลากหลายสถานการณ์มากยิ่งขึ้นโดยไม่เกิดข้อผิดพลาด
ขจัดความซ้ำซ้อนโดยการแยกฟังก์ชันออกมา
เจเนอริกช่วยให้เราสามารถแทนที่ประเภทข้อมูลที่เฉพาะเจาะจงด้วยตัวยึดตำแหน่ง (placeholder) ที่เป็นตัวแทนของหลากหลายประเภท เพื่อขจัดความซ้ำซ้อนของโค้ด แต่ก่อนที่เราจะดำดิ่งสู่ไวยากรณ์ของเจเนอริก มาเริ่มต้นดูวิธีการขจัดความซ้ำซ้อนในแบบที่ไม่เกี่ยวข้องกับประเภทเจเนอริกกันก่อน โดยการแยกฟังก์ชันที่แทนที่ค่าเฉพาะเจาะจงด้วยตัวยึดตำแหน่งที่เป็นตัวแทนของหลายๆ ค่าออกมา จากนั้นเราจึงจะนำเทคนิคแบบเดียวกันนี้มาประยุกต์ใช้เพื่อแยกฟังก์ชันเจเนอริก! การทำความเข้าใจวิธีสังเกตโค้ดซ้ำซ้อนที่สามารถแยกเป็นฟังก์ชันได้ จะช่วยให้คุณเริ่มมองเห็นโค้ดซ้ำซ้อนที่สามารถนำเจเนอริกมาประยุกต์ใช้ได้เช่นกัน
เราจะเริ่มด้วยโปรแกรมสั้นๆ ในลิสติ้ง 10-1 ที่ค้นหาตัวเลขที่มากที่สุดในรายการ
fn main() {
let number_list = vec![34, 50, 25, 100, 65];
let mut largest = &number_list[0];
for number in &number_list {
if number > largest {
largest = number;
}
}
println!("The largest number is {largest}");
assert_eq!(*largest, 100);
}
เราเก็บรายการจำนวนเต็มไว้ในตัวแปร number_list แล้วกำหนดให้เรเฟอเรนซ์ที่ชี้ไปยังตัวเลขตัวแรกในรายการไปเก็บไว้ในตัวแปรชื่อ largest จากนั้นเราวนลูปผ่านตัวเลขทุกตัวในรายการ หากตัวเลขปัจจุบันมีค่ามากกว่าตัวเลขที่เก็บไว้ใน largest เราจะแทนที่เรเฟอเรนซ์ในตัวแปรนั้นด้วยตัวเลขใหม่ แต่หากตัวเลขปัจจุบันมีค่าน้อยกว่าหรือเท่ากับตัวเลขที่มากที่สุดที่พบจนถึงตอนนี้ ตัวแปรดังกล่าวก็จะไม่เปลี่ยนแปลง และโค้ดจะข้ามไปพิจารณาตัวเลขตัวถัดไปในรายการ เมื่อพิจารณาตัวเลขครบทุกตัวในรายการแล้ว largest ก็จะชี้ไปยังตัวเลขที่มีค่ามากที่สุด ซึ่งในกรณีนี้คือ 100
คราวนี้ หากเราได้รับโจทย์ให้ค้นหาตัวเลขที่มากที่สุดในรายการตัวเลขสองชุดที่แตกต่างกัน เราก็อาจเลือกทำสำเนาโค้ดจากลิสติ้ง 10-1 ซ้ำ และใช้ตรรกะเดิมในสองจุดที่ต่างกันของโปรแกรม ดังแสดงในลิสติ้ง 10-2
fn main() {
let number_list = vec![34, 50, 25, 100, 65];
let mut largest = &number_list[0];
for number in &number_list {
if number > largest {
largest = number;
}
}
println!("The largest number is {largest}");
let number_list = vec![102, 34, 6000, 89, 54, 2, 43, 8];
let mut largest = &number_list[0];
for number in &number_list {
if number > largest {
largest = number;
}
}
println!("The largest number is {largest}");
}
แม้ว่าโค้ดนี้จะทำงานได้ แต่การเขียนโค้ดซ้ำซ้อนเช่นนี้นอกจากจะน่าเบื่อแล้ว ยังเสี่ยงต่อการเกิดข้อผิดพลาดได้ง่าย และเรายังต้องคอยจำว่าต้องตามไปแก้ไขโค้ดในหลายๆ จุดเมื่อต้องการปรับปรุงตรรกะในอนาคต
เพื่อขจัดความซ้ำซ้อนนี้ เราสามารถสร้างนามธรรมขึ้นมา โดยการนิยามฟังก์ชันที่สามารถทำงานกับสไลซ์ของจำนวนเต็มใดๆ ที่ส่งเข้ามาเป็นพารามิเตอร์ วิธีนี้จะช่วยให้โค้ดของเราดูสะอาดตาขึ้น และเปิดโอกาสให้เราถ่ายทอดแนวคิดเรื่องการหาตัวเลขที่มากที่สุดในรายการออกมาในเชิงนามธรรมได้อย่างชัดเจน
ในลิสติ้ง 10-3 เราได้แยกโค้ดที่ใช้ค้นหาตัวเลขที่มากที่สุดออกมาเป็นฟังก์ชันชื่อ largest จากนั้นเราเรียกใช้ฟังก์ชันนี้เพื่อหาตัวเลขที่มากที่สุดจากรายการทั้งสองชุดในลิสติ้ง 10-2 นอกจากนี้เรายังสามารถนำฟังก์ชันนี้ไปใช้กับรายการของค่า i32 อื่นๆ ในอนาคตได้อย่างง่ายดาย
fn largest(list: &[i32]) -> &i32 {
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}");
assert_eq!(*result, 100);
let number_list = vec![102, 34, 6000, 89, 54, 2, 43, 8];
let result = largest(&number_list);
println!("The largest number is {result}");
assert_eq!(*result, 6000);
}
ฟังก์ชัน largest มีพารามิเตอร์ชื่อ list ซึ่งทำหน้าที่เป็นตัวแทนของสไลซ์ของค่า i32 รูปธรรมใดๆ ที่เราส่งเข้ามา ส่งผลให้เมื่อเราเรียกใช้ฟังก์ชัน โค้ดจะทำงานบนค่าเฉพาะเจาะจงที่เราส่งเข้าไป
สรุปขั้นตอนที่เราใช้ในการปรับแก้โค้ดจากลิสติ้ง 10-2 มาเป็นลิสติ้ง 10-3 ได้ดังนี้:
- ระบุจุดที่มีโค้ดซ้ำซ้อน
- แยกโค้ดที่ซ้ำซ้อนนั้นออกมาใส่ไว้ในเนื้อหาของฟังก์ชัน พร้อมทั้งระบุพารามิเตอร์นำเข้าและค่าส่งกลับในลายเซ็นของฟังก์ชันให้ชัดเจน
- ปรับปรุงโค้ดเดิมทั้งสองจุดให้เปลี่ยนมาเรียกใช้ฟังก์ชันดังกล่าวแทน
ในขั้นตอนต่อไป เราจะนำกระบวนการเดียวกันนี้ไปปรับใช้ร่วมกับเจเนอริกเพื่อลดความซ้ำซ้อนของโค้ด ในทำนองเดียวกับที่เนื้อหาของฟังก์ชันสามารถทำงานกับ list ที่เป็นนามธรรมแทนค่าเฉพาะเจาะจงได้ เจเนอริกก็เปิดโอกาสให้โค้ดสามารถทำงานกับประเภทข้อมูลที่เป็นนามธรรมได้เช่นกัน
ตัวอย่างเช่น สมมติว่าเรามีสองฟังก์ชัน: ฟังก์ชันหนึ่งใช้ค้นหาค่าที่มากที่สุดในสไลซ์ของ i32 และอีกฟังก์ชันหนึ่งใช้ค้นหาค่าที่มากที่สุดในสไลซ์ของ char เราจะกำจัดความซ้ำซ้อนนั้นได้อย่างไร? มาค้นหาคำตอบกัน!