มาโคร
เราได้ใช้งานมาโคร (macros) อย่างเช่น println! มาตลอดทั้งเล่มนี้ แต่เรายังไม่ได้เจาะลึกอย่างเต็มที่ว่า แท้จริงแล้วมาโครคืออะไรและมีหลักการทำงานอย่างไร คำว่า มาโคร ในภาษา Rust ครอบคลุมฟีเจอร์ 2 กลุ่มใหญ่ ได้แก่ มาโครแบบประกาศ (declarative macros) ที่สร้างด้วย macro_rules! และ มาโครเชิงกระบวนการ (procedural macros) ซึ่งแบ่งออกเป็น 3 รูปแบบ:
- มาโคร
#[derive]แบบกำหนดเอง (custom derive macros) ซึ่งใช้สร้างโค้ดเพิ่มเติมโดยอัตโนมัติเมื่อระบุแอตทริบิวต์deriveบน struct และ enum - มาโครคล้ายแอตทริบิวต์ (attribute-like macros) ซึ่งเปิดให้เรานิยามแอตทริบิวต์แบบกำหนดเองขึ้นมาใช้งานกับไอเท็มใด ๆ ก็ได้
- มาโครคล้ายฟังก์ชัน (function-like macros) ซึ่งมีหน้าตาคล้ายกับการเรียกใช้ฟังก์ชัน แต่ทำงานโดยตรงกับลำดับของโทเค็น (tokens) ที่ส่งเข้ามาเป็นอาร์กิวเมนต์
เราจะศึกษามาโครแต่ละประเภทไปตามลำดับ แต่ก่อนอื่น มาทำความเข้าใจกันก่อนว่า ทำไมเราถึงยังต้องการมาโครทั้งที่เรามีฟังก์ชันให้ใช้งานอยู่แล้ว
ความแตกต่างระหว่างมาโครกับฟังก์ชัน
โดยเนื้อแท้แล้ว มาโครคือวิธีการเขียนโค้ดเพื่อสร้างโค้ดอื่นขึ้นมา ซึ่งเป็นที่รู้จักกันในชื่อ เมตาโปรแกรมมิ่ง (metaprogramming) ในภาคผนวก C เราได้พูดถึงแอตทริบิวต์ derive ที่ช่วยสร้างโค้ดอิมพลีเมนต์เทรตต่าง ๆ ให้กับคุณโดยอัตโนมัติ นอกจากนี้เรายังได้ใช้มาโครอย่าง println! และ vec! มาตลอดทั้งเล่ม มาโครทั้งหมดเหล่านี้จะทำหน้าที่ คลี่ขยายโค้ด (expand) เพื่อสร้างโค้ดออกมามากกว่าโค้ดที่คุณเขียนด้วยมือจริง ๆ
เมตาโปรแกรมมิ่งมีประโยชน์อย่างมากในการลดปริมาณโค้ดที่คุณต้องเขียนและดูแลรักษา ซึ่งนั่นก็เป็นหน้าที่หนึ่งของฟังก์ชันเช่นกัน อย่างไรก็ตาม มาโครมีพลังพิเศษบางประการที่ฟังก์ชันธรรมดาไม่สามารถทำได้
ซิกเนเจอร์ของฟังก์ชันจำเป็นต้องประกาศจำนวนและชนิดของพารามิเตอร์ไว้อย่างตายตัว ในทางกลับกัน มาโครสามารถรับอาร์กิวเมนต์ที่มีจำนวนไม่แน่นอนได้ (variadic): เราสามารถเรียก println!("hello") ด้วยอาร์กิวเมนต์เดียว หรือเรียก println!("hello {}", name) ด้วยสองอาร์กิวเมนต์ก็ได้ นอกจากนี้ มาโครยังถูกคลี่ขยายก่อนที่คอมไพเลอร์จะตีความหมายของโค้ด ดังนั้น มาโครจึงสามารถสร้างโค้ดเพื่ออิมพลีเมนต์เทรตให้กับชนิดข้อมูลที่กำหนดได้ ซึ่งฟังก์ชันไม่สามารถทำเช่นนั้นได้เนื่องจากฟังก์ชันจะถูกเรียกใช้งานในตอนรันไทม์ ขณะที่การอิมพลีเมนต์เทรตจำเป็นต้องทำตั้งแต่ตอนคอมไพล์
ข้อเสียของการสร้างมาโครแทนฟังก์ชัน คือนิยามของมาโครจะมีความซับซ้อนกว่าฟังก์ชันมาก เพราะคุณกำลังเขียนโค้ด Rust เพื่อสร้างโค้ด Rust อีกทอดหนึ่ง และเนื่องจากความซับซ้อนเชิงอ้อมนี้ จึงทำให้นิยามของมาโครอ่าน ทำความเข้าใจ และดูแลรักษาได้ยากกว่าฟังก์ชันทั่วไป
ความแตกต่างที่สำคัญอีกประการระหว่างมาโครกับฟังก์ชัน คือคุณจะต้องนิยามมาโครหรือนำมาโครเข้ามาสู่ขอบเขต (scope) ก่อน ที่จะเรียกใช้งานในไฟล์นั้น ซึ่งต่างจากฟังก์ชันที่คุณสามารถนิยามไว้ที่ใดก็ได้และเรียกใช้งานจากจุดใดก็ได้ในสโคป
มาโครแบบประกาศสำหรับเมตาโปรแกรมมิ่งทั่วไป
รูปแบบของมาโครที่มีการใช้งานอย่างแพร่หลายที่สุดใน Rust คือ มาโครแบบประกาศ (declarative macros) ซึ่งบางครั้งมักเรียกว่า “มาโครตามตัวอย่าง (macros by example)” หรือ “มาโคร macro_rules!” หรือเรียกสั้น ๆ ว่า “มาโคร” โดยหัวใจสำคัญคือ มาโครแบบประกาศช่วยให้คุณสามารถเขียนโครงสร้างที่มีลักษณะคล้ายกับนิพจน์ match ของ Rust ได้ ดังที่เราได้พูดคุยกันในบทที่ 6 ว่านิพจน์ match เป็นโครงสร้างควบคุมที่รับนิพจน์เข้ามา แล้วนำค่าผลลัพธ์ไปเปรียบเทียบกับรูปแบบ (patterns) ต่าง ๆ จากนั้นจึงรันโค้ดของกิ่งกรณีที่ตรงกับรูปแบบนั้น มาโครก็ทำหน้าที่เปรียบเทียบค่ากับรูปแบบที่เชื่อมโยงกับโค้ดเช่นเดียวกัน: เพียงแต่ในบริบทนี้ ค่าที่ส่งเข้ามาคือซอร์สโค้ดของ Rust ตัวจริงที่ส่งให้กับมาโคร; รูปแบบจะถูกนำมาเปรียบเทียบกับโครงสร้างของซอร์สโค้ดนั้น; และโค้ดที่ผูกไว้กับแต่ละรูปแบบจะถูกนำมาแทนที่โค้ดต้นฉบับเมื่อรูปแบบตรงกัน ซึ่งกระบวนการทั้งหมดนี้เกิดขึ้นในระหว่างการคอมไพล์
ในการนิยามมาโคร คุณจะใช้โครงสร้าง macro_rules! มาศึกษาการใช้งาน macro_rules! ผ่านการดูนิยามของมาโคร vec! กัน ในบทที่ 8 เราได้เรียนรู้วิธีใช้มาโคร vec! เพื่อสร้างเวกเตอร์ใหม่ที่บรรจุค่าต่าง ๆ ตัวอย่างเช่น มาโครต่อไปนี้สร้างเวกเตอร์ใหม่ที่เก็บเลขจำนวนเต็ม 3 ตัว:
#![allow(unused)]
fn main() {
let v: Vec<u32> = vec![1, 2, 3];
}
นอกจากนี้เรายังสามารถใช้ vec! สร้างเวกเตอร์ของเลขจำนวนเต็ม 2 ตัว หรือเวกเตอร์ของสตริงสไลซ์ 5 ตัวก็ได้ เราไม่สามารถเขียนฟังก์ชันธรรมดาให้ทำงานยืดหยุ่นเช่นนี้ได้ เพราะเราไม่สามารถทราบจำนวนหรือชนิดของค่าข้อมูลล่วงหน้าได้เลย
ลิสติ้ง 20-35 แสดงนิยามแบบย่อของมาโคร vec! เพื่อให้เข้าใจง่ายขึ้น
#[macro_export]
macro_rules! vec {
( $( $x:expr ),* ) => {
{
let mut temp_vec = Vec::new();
$(
temp_vec.push($x);
)*
temp_vec
}
};
}
หมายเหตุ: นิยามจริงของมาโคร
vec!ในไลบรารีมาตรฐานจะมีโค้ดสำหรับจัดสรรหน่วยความจำล่วงหน้าให้เพียงพอกับขนาดข้อมูล โค้ดส่วนนั้นเป็นการเพิ่มประสิทธิภาพ (optimization) ซึ่งเราตัดทอนออกไปในตัวอย่างนี้เพื่อให้โค้ดกระชับและเข้าใจง่าย
แอตทริบิวต์ #[macro_export] บ่งบอกว่ามาโครนี้ควรเปิดให้พร้อมใช้งานได้ทุกเมื่อที่มีการนำเครต (crate) ที่นิยามมาโครนี้เข้ามาสู่ขอบเขตการทำงาน หากไม่มีแอตทริบิวต์นี้ มาโครจะไม่สามารถถูกนำเข้ามาใช้งานในสโคปอื่นได้
จากนั้นเราเริ่มต้นนิยามมาโครด้วยคำสั่ง macro_rules! ตามด้วยชื่อมาโครที่เราต้องการนิยามโดย_ไม่ต้องมี_เครื่องหมายอัศเจรีย์ (ในที่นี้คือชื่อ vec) แล้วตามด้วยวงเล็บปีกกาที่ครอบบอดี้ของนิยามมาโครเอาไว้
โครงสร้างภายในบอดี้ของ vec! มีลักษณะคล้ายกับนิพจน์ match โดยในที่นี้มีหนึ่งกิ่งกรณีที่มีรูปแบบเป็น ( $( $x:expr ),* ) ตามด้วยเครื่องหมาย => และบล็อกโค้ดที่เชื่อมโยงกับรูปแบบนี้ หากโค้ดที่ส่งเข้ามาตรงกับรูปแบบ บล็อกโค้ดที่เกี่ยวข้องก็จะถูกปล่อยออกมาแทนที่ และเนื่องจากในมาโครนี้มีเพียงรูปแบบเดียว จึงมีวิธีจับคู่ที่ถูกต้องเพียงวิธีเดียวเท่านั้น รูปแบบอื่นใดนอกเหนือจากนี้จะทำให้เกิดข้อผิดพลาดในการคอมไพล์ สำหรับมาโครที่ซับซ้อนกว่านี้ก็สามารถมีได้หลายกิ่งกรณี
ไวยากรณ์ของรูปแบบที่ใช้ในนิยามมาโครจะแตกต่างไปจากไวยากรณ์ของแพตเทิร์นที่เราเรียนรู้ในบทที่ 19 เนื่องจากรูปแบบของมาโครจะจับคู่กับโครงสร้างโค้ดของ Rust ไม่ใช่จับคู่กับค่าข้อมูล มาดูกันว่าแต่ละชิ้นส่วนของรูปแบบในลิสติ้ง 20-35 มีความหมายอย่างไร (สำหรับไวยากรณ์รูปแบบของมาโครฉบับสมบูรณ์ สามารถศึกษาได้จาก คู่มืออ้างอิงของ Rust (Rust Reference))
อันดับแรก เราใช้วงเล็บกลมคู่หนึ่งครอบรูปแบบทั้งหมดเอาไว้ เราใช้เครื่องหมายดอลลาร์ ($) เพื่อประกาศตัวแปรในระบบมาโคร ซึ่งจะทำหน้าที่เก็บโค้ด Rust ที่จับคู่ตรงกับรูปแบบ โดยเครื่องหมายดอลลาร์ช่วยระบุชัดเจนว่านี่คือตัวแปรของระบบมาโคร ไม่ใช่ตัวแปร Rust ทั่วไป ถัดมาคือวงเล็บ $() ซึ่งทำหน้าที่จับยึด (capture) ค่าที่ตรงกับรูปแบบภายในวงเล็บเพื่อนำไปใช้ในโค้ดส่วนแทนที่ ภายใน $() มี $x:expr ซึ่งหมายถึงการจับคู่กับนิพจน์ (expression) ใด ๆ ของ Rust และตั้งชื่อให้กับนิพจน์นั้นว่า $x
เครื่องหมายจุลภาคที่ตามหลัง $() บ่งบอกว่าสามารถมีเครื่องหมายจุลภาคคั่นระหว่างแต่ละอินสแตนซ์ของโค้ดที่ตรงกับเงื่อนไขใน $() ได้ ส่วนเครื่องหมาย * ระบุว่ารูปแบบสามารถจับคู่กับสิ่งที่อยู่ข้างหน้าได้ตั้งแต่ 0 ครั้งขึ้นไป
เมื่อเราเรียกใช้มาโครนี้ด้วยคำสั่ง vec![1, 2, 3]; รูปแบบ $x จะจับคู่ 3 ครั้งกับนิพจน์ทั้งสามตัว ได้แก่ 1, 2 และ 3
คราวนี้มาดูรูปแบบในบอดี้ของโค้ดที่เชื่อมโยงกับกิ่งนี้: ส่วน temp_vec.push() ภายใน $()* จะถูกสร้างขึ้นซ้ำตามจำนวนครั้งที่จับคู่กับ $() ในรูปแบบ (ตั้งแต่ 0 ครั้งขึ้นไป ขึ้นอยู่กับจำนวนข้อมูลที่ส่งเข้ามา) โดย $x จะถูกแทนที่ด้วยนิพจน์แต่ละตัวที่จับคู่ได้ เมื่อเราเรียกมาโครนี้ด้วย vec![1, 2, 3]; โค้ดที่ถูกสร้างขึ้นเพื่อแทนที่การเรียกใช้มาโครดังกล่าวก็คือ:
{
let mut temp_vec = Vec::new();
temp_vec.push(1);
temp_vec.push(2);
temp_vec.push(3);
temp_vec
}
เราจึงได้มาโครที่สามารถรับอาร์กิวเมนต์จำนวนเท่าใดก็ได้และชนิดข้อมูลใดก็ได้ พร้อมทั้งสร้างโค้ดขึ้นมาสร้างเวกเตอร์ที่บรรจุสมาชิกเหล่านั้นได้อย่างสมบูรณ์
หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับวิธีการเขียนมาโคร สามารถศึกษาเพิ่มเติมได้จากเอกสารออนไลน์และแหล่งข้อมูลอื่น ๆ เช่น “The Little Book of Rust Macros” ซึ่งริเริ่มโดย Daniel Keep และดูแลต่อโดย Lukas Wirth
มาโครแบบโพรซีเยอร์สำหรับสร้างโค้ดจากแอตทริบิวต์
รูปแบบที่สองของมาโครคือ มาโครเชิงกระบวนการ (procedural macros) ซึ่งมีลักษณะการทำงานคล้ายกับฟังก์ชันมากกว่า โดยมาโครเชิงกระบวนการจะรับโค้ดเข้ามาเป็นอินพุต ทำการประมวลผลโค้ดนั้น แล้วสร้างโค้ดใหม่ออกมาเป็นเอาต์พุต แทนที่จะเป็นการจับคู่กับรูปแบบแล้วแทนที่โค้ดเหมือนอย่างที่มาโครแบบประกาศทำ มาโครเชิงกระบวนการทั้ง 3 ประเภท ได้แก่ derive แบบกำหนดเอง, คล้ายแอตทริบิวต์ และคล้ายฟังก์ชัน ซึ่งทั้งหมดทำงานในลักษณะที่คล้ายคลึงกัน
การสร้างมาโครเชิงกระบวนการจำเป็นต้องแยกนิยามไปไว้ในเครตต่างหากที่มีชนิดเครตเป็นพิเศษ ซึ่งเป็นผลมาจากข้อจำกัดทางเทคนิคที่ซับซ้อนของคอมไพเลอร์ที่หวังว่าจะสามารถยกเลิกข้อจำกัดนี้ได้ในอนาคต ในลิสติ้ง 20-36 เราแสดงวิธีนิยามมาโครเชิงกระบวนการ โดย some_attribute เป็นตัวแทนของแอตทริบิวต์ที่ระบุชนิดของมาโครเจาะจง
use proc_macro::TokenStream;
#[some_attribute]
pub fn some_name(input: TokenStream) -> TokenStream {
}
ฟังก์ชันที่นิยามมาโครเชิงกระบวนการจะรับ TokenStream เป็นอินพุต และสร้าง TokenStream เป็นเอาต์พุต ชนิดข้อมูล TokenStream ถูกนิยามไว้ในเครต proc_macro ที่มาพร้อมกับ Rust และทำหน้าที่เป็นตัวแทนของลำดับโทเค็นในภาษา นี่คือหัวใจสำคัญของมาโคร: ซอร์สโค้ดที่ส่งเข้ามาให้มาโครประมวลผลจะรวมกันเป็น TokenStream ขาเข้า และโค้ดที่มาโครสร้างขึ้นมาใหม่ก็คือ TokenStream ขาออก นอกจากนี้ตัวฟังก์ชันยังต้องมีแอตทริบิวต์กำกับไว้เพื่อระบุว่าเรากำลังสร้างมาโครเชิงกระบวนการชนิดใด โดยเราสามารถนิยามมาโครเชิงกระบวนการหลายชนิดไว้ในเครตเดียวกันได้
มาดูรายละเอียดของมาโครเชิงกระบวนการแต่ละประเภทกัน เราจะเริ่มจากมาโคร derive แบบกำหนดเอง จากนั้นจะอธิบายจุดแตกต่างเล็กน้อยของมาโครในรูปแบบอื่น ๆ
มาโคร derive แบบกำหนดเอง
มาลองสร้างเครตชื่อ hello_macro ที่นิยามเทรตชื่อ HelloMacro พร้อมฟังก์ชันเชื่อมโยงหนึ่งฟังก์ชันชื่อ hello_macro กัน แทนที่จะให้ผู้ใช้งานเครตของเราต้องมาเขียนโค้ดอิมพลีเมนต์เทรต HelloMacro ให้กับชนิดข้อมูลของตนทีละตัว เราจะสร้างมาโครเชิงกระบวนการขึ้นมา เพื่อให้ผู้ใช้งานสามารถกำกับชนิดข้อมูลด้วย #[derive(HelloMacro)] แล้วได้รับการอิมพลีเมนต์เริ่มต้นของฟังก์ชัน hello_macro ไปโดยอัตโนมัติ โดยการอิมพลีเมนต์เริ่มต้นนี้จะพิมพ์ข้อความ Hello, Macro! My name is TypeName! ออกมา ซึ่ง TypeName คือชื่อของชนิดข้อมูลที่นำเทรตนี้ไปใช้ กล่าวคือ เราจะเขียนเครตที่เปิดโอกาสให้นักพัฒนาท่านอื่นสามารถเขียนโค้ดได้ตามลิสติ้ง 20-37 เมื่อเรียกใช้เครตของเรา
use hello_macro::HelloMacro;
use hello_macro_derive::HelloMacro;
#[derive(HelloMacro)]
struct Pancakes;
fn main() {
Pancakes::hello_macro();
}
เมื่อทำเสร็จสิ้น โค้ดนี้จะพิมพ์ Hello, Macro! My name is Pancakes! ออกมา ขั้นตอนแรกคือการสร้างโปรเจกต์ไลบรารีเครตใหม่ด้วยคำสั่งดังนี้:
$ cargo new hello_macro --lib
ถัดไป ในลิสติ้ง 20-38 เราจะนิยามเทรต HelloMacro และฟังก์ชันเชื่อมโยงของมัน
pub trait HelloMacro {
fn hello_macro();
}
ตอนนี้เรามีเทรตและฟังก์ชันพร้อมแล้ว ในจุดนี้ ผู้ใช้เครตของเราสามารถอิมพลีเมนต์เทรตนี้ด้วยตนเองเพื่อให้ได้การทำงานที่ต้องการได้ ดังที่แสดงในลิสติ้ง 20-39
use hello_macro::HelloMacro;
struct Pancakes;
impl HelloMacro for Pancakes {
fn hello_macro() {
println!("Hello, Macro! My name is Pancakes!");
}
}
fn main() {
Pancakes::hello_macro();
}
อย่างไรก็ตาม ผู้ใช้จะต้องเขียนบล็อกการอิมพลีเมนต์นี้ซ้ำ ๆ สำหรับทุกชนิดข้อมูลที่ต้องการใช้งานร่วมกับ hello_macro ซึ่งเราต้องการช่วยให้ผู้ใช้ไม่ต้องมาเสียเวลาเขียนโค้ดซ้ำซากนี้
นอกจากนี้ เรายังไม่สามารถกำหนดการอิมพลีเมนต์เริ่มต้นให้กับฟังก์ชัน hello_macro เพื่อให้พิมพ์ชื่อของชนิดข้อมูลที่ถูกอิมพลีเมนต์ออกมาได้โดยตรง เนื่องจาก Rust ไม่มีระบบ reflection (การตรวจสอบโครงสร้างของโปรแกรมในขณะรันไทม์) จึงไม่สามารถค้นหาชื่อของชนิดข้อมูลในตอนรันไทม์ได้ เราจึงจำเป็นต้องใช้มาโครเข้ามาช่วยสร้างโค้ดตั้งแต่ในตอนคอมไพล์
ขั้นตอนถัดไปคือการนิยามมาโครเชิงกระบวนการ ณ เวลาที่เขียนหนังสือเล่มนี้ มาโครเชิงกระบวนการจำเป็นต้องแยกไปอยู่ในเครตของตัวเอง (ซึ่งในอนาคตข้อจำกัดนี้อาจถูกยกเลิกไป) ธรรมเนียมปฏิบัติในการตั้งชื่อเครตสำหรับมาโครคือ: หากเครตหลักชื่อ foo เครตมาโคร derive แบบกำหนดเองจะตั้งชื่อว่า foo_derive เรามาสร้างเครตใหม่ชื่อ hello_macro_derive ไว้ภายในโฟลเดอร์ของโปรเจกต์ hello_macro กัน:
$ cargo new hello_macro_derive --lib
เนื่องจากเครตทั้งสองมีความเกี่ยวข้องกันอย่างใกล้ชิด เราจึงสร้างโฟลเดอร์เครตมาโครไว้ภายในไดเรกทอรีของเครต hello_macro หากเราแก้ไขนิยามของเทรตใน hello_macro เราก็จะต้องแก้ไขโค้ดการอิมพลีเมนต์ของมาโครใน hello_macro_derive ตามไปด้วย โดยทั้งสองเครตจะต้องเผยแพร่แยกกันบน crates.io และนักพัฒนาที่ต้องการใช้งานจะต้องเพิ่มดีเพนเดนซีทั้งสองตัวเข้ามาในโปรเจกต์ หรืออีกทางเลือกหนึ่งคือเราอาจให้เครต hello_macro เรียกใช้ hello_macro_derive เป็นดีเพนเดนซี แล้วส่งออกต่อ (re-export) มาโครออกมาก็ได้ อย่างไรก็ตาม การแยกโครงสร้างแบบที่เราทำนี้ช่วยให้นักพัฒนาสามารถเลือกใช้งานเฉพาะ hello_macro ได้ แม้ว่าจะไม่ต้องการฟังก์ชันการทำงานของ derive ก็ตาม
เราจำเป็นต้องประกาศให้เครต hello_macro_derive มีชนิดเป็นเครตมาโครเชิงกระบวนการ นอกจากนี้เรายังต้องใช้ฟังก์ชันการทำงานจากเครต syn และ quote ดังที่คุณจะได้เห็นในอีกสักครู่ จึงต้องเพิ่มทั้งสองเครตเข้ามาเป็นดีเพนเดนซีด้วย โดยเพิ่มข้อความต่อไปนี้ลงในไฟล์ Cargo.toml ของเครต hello_macro_derive:
[lib]
proc-macro = true
[dependencies]
syn = "3.0"
quote = "1.0"
สำหรับการเริ่มต้นนิยามมาโคร ให้นำโค้ดในลิสติ้ง 20-40 ไปวางไว้ในไฟล์ src/lib.rs ของเครต hello_macro_derive โปรดทราบว่าโค้ดนี้จะยังคอมไพล์ไม่ผ่านจนกว่าเราจะเพิ่มนิยามของฟังก์ชัน impl_hello_macro เข้าไป
use proc_macro::TokenStream;
use quote::quote;
#[proc_macro_derive(HelloMacro)]
pub fn hello_macro_derive(input: TokenStream) -> TokenStream {
// Construct a representation of Rust code as a syntax tree
// that we can manipulate.
let ast = syn::parse(input).unwrap();
// Build the trait implementation.
impl_hello_macro(&ast)
}
โปรดสังเกตว่าเราได้แยกโค้ดออกเป็นสองส่วน ได้แก่ ฟังก์ชัน hello_macro_derive ซึ่งทำหน้าที่แยกวิเคราะห์ (parse) TokenStream และฟังก์ชัน impl_hello_macro ซึ่งทำหน้าที่แปลงทรีไวยากรณ์ (syntax tree) การแยกเช่นนี้ช่วยให้การเขียนมาโครเชิงกระบวนการเป็นระบบและสะดวกยิ่งขึ้น โค้ดในฟังก์ชันชั้นนอก (hello_macro_derive ในกรณีนี้) จะมีหน้าตาแทบจะเหมือนกันในเครตมาโครเชิงกระบวนการเกือบทุกตัวที่คุณพบเห็น ส่วนโค้ดที่คุณเขียนในบอดี้ของฟังก์ชันชั้นใน (impl_hello_macro ในกรณีนี้) จะแตกต่างกันไปตามวัตถุประสงค์เฉพาะของมาโครแต่ละตัว
เราได้แนะนำเครตใหม่ 3 ตัว ได้แก่: proc_macro, syn และ quote โดยเครต proc_macro จะมาพร้อมกับคอมไพเลอร์ Rust อยู่แล้ว เราจึงไม่จำเป็นต้องระบุไว้ในดีเพนเดนซีของ Cargo.toml ซึ่ง proc_macro คือ API ของคอมไพเลอร์ที่ช่วยให้เราสามารถอ่านและดัดแปลงโค้ด Rust ได้จากโค้ดของเราเอง
เครต syn ทำหน้าที่แยกวิเคราะห์โค้ด Rust จากข้อความสตริงให้อยู่ในรูปของโครงสร้างข้อมูลที่เราสามารถนำไปประมวลผลต่อได้ ส่วนเครต quote จะทำหน้าที่แปลงโครงสร้างข้อมูลของ syn กลับไปเป็นโค้ด Rust อีกครั้ง เครตทั้งสองนี้ช่วยให้การจัดการกับโค้ด Rust ทำได้ง่ายขึ้นอย่างมหาศาล เนื่องจากการเขียนตัวแยกวิเคราะห์ (parser) สำหรับภาษา Rust ด้วยตนเองตั้งแต่ต้นนั้นเป็นเรื่องที่ซับซ้อนอย่างยิ่ง
ฟังก์ชัน hello_macro_derive จะถูกเรียกใช้งานเมื่อผู้ใช้ระบุแอตทริบิวต์ #[derive(HelloMacro)] บนชนิดข้อมูลใดชนิดข้อมูลหนึ่ง สาเหตุที่ทำเช่นนี้ได้เนื่องจากเรากำกับฟังก์ชัน hello_macro_derive ไว้ด้วย #[proc_macro_derive(HelloMacro)] ซึ่งระบุชื่อ HelloMacro ให้ตรงกับชื่อเทรตของเรา ซึ่งนี่เป็นแนวทางปฏิบัติมาตรฐานที่มาโครเชิงกระบวนการส่วนใหญ่ยึดถือร่วมกัน
ฟังก์ชัน hello_macro_derive จะเริ่มต้นด้วยการแปลง input จาก TokenStream ให้กลายเป็นโครงสร้างข้อมูลที่เราสามารถตีความและประมวลผลได้ ซึ่งนี่คือหน้าที่ของ syn โดยฟังก์ชัน parse ใน syn จะรับ TokenStream แล้วคืนค่ากลับมาเป็น struct DeriveInput ที่เป็นตัวแทนของโค้ด Rust ที่ผ่านการแยกวิเคราะห์แล้ว ลิสติ้ง 20-41 แสดงส่วนสำคัญของ struct DeriveInput ที่ได้จากการแยกวิเคราะห์ข้อความ struct Pancakes;
DeriveInput {
// --snip--
ident: Ident {
ident: "Pancakes",
span: #0 bytes(95..103)
},
data: Struct(
DataStruct {
struct_token: Struct,
fields: Unit,
semi_token: Some(
Semi
)
}
)
}
ฟิลด์ต่าง ๆ ของ struct นี้แสดงให้เห็นว่า โค้ด Rust ที่เราแยกวิเคราะห์ออกมาเป็นยูนิต struct (unit struct) ที่มี ident (ย่อมาจาก identifier หมายถึงชื่อของไอเท็ม) เป็น "Pancakes" นอกจากนี้ยังมีฟิลด์อื่น ๆ ใน struct นี้อีกมากมายที่ใช้อธิบายโครงสร้างโค้ดแบบต่าง ๆ ของ Rust คุณสามารถดูรายละเอียดเพิ่มเติมได้ที่ เอกสารของ syn สำหรับ DeriveInput
ต่อไปเราจะนิยามฟังก์ชัน impl_hello_macro ซึ่งเป็นจุดที่เราจะสร้างโค้ด Rust ใหม่เพื่อใส่เพิ่มเติมเข้าไป แต่ก่อนจะไปถึงตรงนั้น โปรดสังเกตว่าผลลัพธ์ของมาโคร derive ก็คือ TokenStream เช่นกัน โดย TokenStream ที่ส่งคืนกลับไปจะถูกผนวกรวมเข้ากับโค้ดที่ผู้ใช้เขียนขึ้น ดังนั้นเมื่อผู้ใช้คอมไพล์เครตของตนเอง โค้ดดังกล่าวจะได้รับการต่อขยายด้วยฟังก์ชันการทำงานเพิ่มเติมที่เราสร้างขึ้นผ่าน TokenStream ใหม่นี้
คุณอาจสังเกตเห็นว่าเรามีการเรียกใช้ unwrap ซึ่งจะทำให้ฟังก์ชัน hello_macro_derive เกิดการแพนิกหากการเรียกใช้ syn::parse ล้มเหลว การให้มาโครเชิงกระบวนการเกิดอาการแพนิกเมื่อพบข้อผิดพลาดเป็นสิ่งจำเป็น เนื่องจากฟังก์ชัน proc_macro_derive ต้องคืนค่าเป็น TokenStream ไม่ใช่ Result เพื่อให้สอดคล้องกับข้อกำหนดของ API มาโคร ในตัวอย่างนี้เราเลือกใช้ unwrap เพื่อให้โค้ดเข้าใจง่าย แต่ในโค้ดที่ใช้งานจริงในโปรดักชัน คุณควรแสดงข้อความข้อผิดพลาดที่ชัดเจนและเฉพาะเจาะจงยิ่งขึ้นด้วย panic! หรือ expect
เมื่อเรามีโค้ดสำหรับแปลงโค้ด Rust จาก TokenStream ไปเป็นอินสแตนซ์ DeriveInput เรียบร้อยแล้ว ตอนนี้เรามาสร้างโค้ดเพื่ออิมพลีเมนต์เทรต HelloMacro ให้กับชนิดข้อมูลดังกล่าวกัน ดังที่แสดงในลิสติ้ง 20-42
use proc_macro::TokenStream;
use quote::quote;
#[proc_macro_derive(HelloMacro)]
pub fn hello_macro_derive(input: TokenStream) -> TokenStream {
// Construct a representation of Rust code as a syntax tree
// that we can manipulate
let ast = syn::parse(input).unwrap();
// Build the trait implementation
impl_hello_macro(&ast)
}
fn impl_hello_macro(ast: &syn::DeriveInput) -> TokenStream {
let name = &ast.ident;
let generated = quote! {
impl HelloMacro for #name {
fn hello_macro() {
println!("Hello, Macro! My name is {}!", stringify!(#name));
}
}
};
generated.into()
}
เราดึงอินสแตนซ์ของ struct Ident ที่เก็บชื่อตัวระบุของชนิดข้อมูลออกมาผ่าน ast.ident โดยจากโครงสร้างในลิสติ้ง 20-41 เมื่อเรารันฟังก์ชัน impl_hello_macro กับโค้ดในลิสติ้ง 20-37 ค่าในฟิลด์ ident จะมีค่าเป็น "Pancakes" ดังนั้นตัวแปร name ในลิสติ้ง 20-42 จึงเก็บอินสแตนซ์ของ Ident ซึ่งเมื่อแปลงเป็นข้อความจะได้สตริง "Pancakes" ซึ่งเป็นชื่อของ struct ในลิสติ้ง 20-37 นั่นเอง
มาโคร quote! ช่วยให้เราสามารถเขียนโค้ด Rust ที่ต้องการส่งคืนกลับไปได้โดยตรง แต่คอมไพเลอร์คาดหวังผลลัพธ์ที่มีชนิดเป็น TokenStream เราจึงต้องแปลงผลลัพธ์จาก quote! ไปเป็น TokenStream ด้วยการเรียกใช้เมธอด into ซึ่งจะนำตัวแทนระดับกลาง (intermediate representation) นี้ไปแปลงเป็นค่าชนิด TokenStream ที่คอมไพเลอร์ต้องการ
มาโคร quote! ยังมีกลไกการทำเทมเพลตที่สะดวกมาก: เราสามารถระบุเป็น #name แล้ว quote! จะแทนที่ตำแหน่งนั้นด้วยค่าที่เก็บอยู่ในตัวแปร name ให้โดยอัตโนมัติ นอกจากนี้ยังสามารถเขียนลูปเพื่อทำซ้ำในลักษณะเดียวกับมาโครทั่วไปได้ด้วย สามารถศึกษาบทนำและรายละเอียดทั้งหมดได้จาก เอกสารของเครต quote
เราต้องการให้มาโครเชิงกระบวนการสร้างโค้ดอิมพลีเมนต์เทรต HelloMacro ให้กับชนิดข้อมูลที่ผู้ใช้ระบุแอตทริบิวต์ไว้ ซึ่งเราดึงชื่อชนิดข้อมูลมาใช้ผ่าน #name โดยการอิมพลีเมนต์เทรตนี้มีฟังก์ชันเดียวคือ hello_macro ซึ่งบอดี้ของฟังก์ชันจะบรรจุการทำงานที่เราต้องการไว้ นั่นคือ การพิมพ์ข้อความ Hello, Macro! My name is ตามด้วยชื่อของชนิดข้อมูลนั้น ๆ
ส่วนมาโคร stringify! ที่เรียกใช้ตรงนี้เป็นมาโครที่มีมาให้อยู่แล้วใน Rust ซึ่งทำหน้าที่รับนิพจน์ใด ๆ ของ Rust (เช่น 1 + 2) แล้วแปลงนิพจน์นั้นให้เป็นสตริงลิเทอรัลในตอนคอมไพล์ เช่น "1 + 2" ซึ่งต่างจาก format! หรือ println! ที่จะประเมินผลลัพธ์ของนิพจน์ก่อนแล้วจึงแปลงเป็น String และเนื่องจากมีความเป็นไปได้ที่อินพุต #name อาจเป็นนิพจน์ที่ต้องการพิมพ์ออกมาตรง ๆ เราจึงเลือกใช้ stringify! ซึ่งนอกจากจะตรงกับวัตถุประสงค์แล้ว ยังช่วยประหยัดการจัดสรรหน่วยความจำในตอนรันไทม์ได้อีกหนึ่งครั้งด้วย
ถึงจุดนี้ คำสั่ง cargo build ควรจะคอมไพล์ผ่านได้อย่างเรียบร้อยทั้งในเครต hello_macro และ hello_macro_derive คราวนี้เรามาเชื่อมต่อเครตทั้งสองเข้ากับโค้ดในลิสติ้ง 20-37 เพื่อดูการทำงานจริงของมาโครเชิงกระบวนการกัน! สร้างโปรเจกต์ไบนารีใหม่ในโฟลเดอร์ projects ของคุณด้วยคำสั่ง cargo new pancakes เราจำเป็นต้องเพิ่ม hello_macro และ hello_macro_derive เป็นดีเพนเดนซีในไฟล์ Cargo.toml ของเครต pancakes หากคุณได้เผยแพร่เวอร์ชันของทั้งสองเครตนี้ไปยัง crates.io แล้ว ก็สามารถระบุเป็นดีเพนเดนซีปกติได้ แต่หากยังไม่ได้เผยแพร่ คุณสามารถระบุพาธตรงไปยังเครตผ่านคีย์ path ได้ดังนี้:
[dependencies]
hello_macro = { path = "../hello_macro" }
hello_macro_derive = { path = "../hello_macro/hello_macro_derive" }
ให้นำโค้ดจากลิสติ้ง 20-37 ไปใส่ในไฟล์ src/main.rs แล้วสั่งรันด้วย cargo run: โปรแกรมควรจะพิมพ์ Hello, Macro! My name is Pancakes! ออกมาอย่างถูกต้อง โดยโค้ดการอิมพลีเมนต์เทรต HelloMacro จะถูกสร้างและใส่เข้ามาโดยอัตโนมัติจากมาโครเชิงกระบวนการ โดยที่เครต pancakes ไม่จำเป็นต้องเขียนโค้ดอิมพลีเมนต์เองเลยแม้แต่น้อย เพราะแอตทริบิวต์ #[derive(HelloMacro)] ได้จัดการเพิ่มโค้ดอิมพลีเมนต์เทรตทั้งหมดให้แล้ว
ในหัวข้อถัดไป เราจะมาสำรวจกันว่ามาโครเชิงกระบวนการประเภทอื่น ๆ แตกต่างจากมาโคร derive แบบกำหนดเองอย่างไรบ้าง
มาโครคล้ายแอตทริบิวต์
มาโครคล้ายแอตทริบิวต์ (attribute-like macros) มีความคล้ายคลึงกับมาโคร derive แบบกำหนดเอง แต่แทนที่จะสร้างโค้ดเฉพาะสำหรับแอตทริบิวต์ derive มาโครประเภทนี้จะเปิดให้คุณสร้างแอตทริบิวต์ใหม่ขึ้นมาใช้งานได้เองอย่างอิสระ นอกจากนี้ยังมีความยืดหยุ่นสูงกว่า เนื่องจาก derive ใช้งานได้เฉพาะกับ struct และ enum เท่านั้น ขณะที่แอตทริบิวต์สามารถนำไปกำกับไว้บนไอเท็มอื่น ๆ ได้ด้วย เช่น ฟังก์ชัน นี่คือตัวอย่างการใช้งานมาโครคล้ายแอตทริบิวต์ สมมติว่าคุณมีแอตทริบิวต์ชื่อ route ที่ใช้กำกับฟังก์ชันเมื่อทำงานร่วมกับเว็บเฟรมเวิร์ก:
#[route(GET, "/")]
fn index() {
แอตทริบิวต์ #[route] นี้จะได้รับการนิยามโดยตัวเฟรมเวิร์กในฐานะมาโครเชิงกระบวนการ โดยซิกเนเจอร์ของฟังก์ชันที่นิยามมาโครจะมีลักษณะดังนี้:
#[proc_macro_attribute]
pub fn route(attr: TokenStream, item: TokenStream) -> TokenStream {
ในที่นี้ เรามีพารามิเตอร์ชนิด TokenStream สองตัว ตัวแรกคือข้อมูลเนื้อหาที่อยู่ภายในแอตทริบิวต์ ซึ่งก็คือส่วน GET, "/" ส่วนตัวที่สองคือบอดี้ของไอเท็มที่แอตทริบิวต์นี้แนบอยู่ด้วย ในกรณีนี้คือ fn index() {} รวมทั้งส่วนที่เหลือของบอดี้ฟังก์ชัน
นอกเหนือจากประเด็นนี้แล้ว มาโครคล้ายแอตทริบิวต์ก็ทำงานเหมือนกับมาโคร derive แบบกำหนดเองทุกประการ: คุณสร้างเครตที่มีชนิดเป็น proc-macro แล้วเขียนฟังก์ชันเพื่อสร้างโค้ดที่คุณต้องการส่งกลับออกมา!
มาโครคล้ายฟังก์ชัน
มาโครคล้ายฟังก์ชัน (function-like macros) ทำหน้าที่นิยามมาโครที่มีรูปแบบการเรียกใช้งานคล้ายกับฟังก์ชัน เช่นเดียวกับมาโคร macro_rules! มาโครประเภทนี้มีความยืดหยุ่นมากกว่าฟังก์ชันปกติ ตัวอย่างเช่น สามารถรับอาร์กิวเมนต์ได้ไม่จำกัดจำนวน อย่างไรก็ตาม มาโคร macro_rules! สามารถนิยามได้เฉพาะผ่านไวยากรณ์คล้าย match ตามที่เราได้พูดคุยกันในหัวข้อ“มาโครแบบประกาศสำหรับเมตาโปรแกรมมิ่งทั่วไป” ในตอนต้นเท่านั้น แต่สำหรับมาโครคล้ายฟังก์ชัน จะรับพารามิเตอร์เป็น TokenStream และในนิยามของมาโครจะสามารถประมวลผล TokenStream นั้นด้วยโค้ด Rust ปกติได้เช่นเดียวกับมาโครเชิงกระบวนการอีกสองประเภท ตัวอย่างหนึ่งของมาโครคล้ายฟังก์ชันคือมาโคร sql! ที่อาจเรียกใช้งานในลักษณะนี้:
let sql = sql!(SELECT * FROM posts WHERE id=1);
มาโครนี้จะแยกวิเคราะห์คำสั่ง SQL ที่อยู่ข้างใน และตรวจสอบความถูกต้องทางไวยากรณ์ของคำสั่ง ซึ่งเป็นการประมวลผลที่ซับซ้อนเกินกว่าที่มาโคร macro_rules! จะสามารถทำได้ โดยมาโคร sql! จะถูกนิยามไว้ดังนี้:
#[proc_macro]
pub fn sql(input: TokenStream) -> TokenStream {
นิยามนี้มีลักษณะคล้ายกับซิกเนเจอร์ของมาโคร derive แบบกำหนดเอง: ฟังก์ชันจะรับโทเค็นทั้งหมดที่อยู่ภายในวงเล็บเข้ามา แล้วส่งคืนโค้ดที่เราต้องการสร้างกลับออกไป
สรุป
เฮ้อ! ตอนนี้คุณมีฟีเจอร์ขั้นสูงของ Rust เพิ่มเข้ามาในกล่องเครื่องมือของคุณแล้ว แม้ว่าคุณอาจไม่ได้หยิบมาใช้งานในชีวิตประจำวันบ่อยนัก แต่คุณก็จะได้รู้ว่ามีฟีเจอร์เหล่านี้พร้อมให้เลือกใช้ในสถานการณ์ที่เฉพาะเจาะจงอย่างยิ่ง เราได้แนะนำหัวข้อที่ซับซ้อนหลายหัวข้อ เพื่อที่ว่าเมื่อคุณพบเจอสิ่งเหล่านี้ในข้อความแนะนำข้อผิดพลาดของคอมไพเลอร์ หรือในโค้ดของผู้อื่น คุณจะสามารถจดจำแนวคิดและเข้าใจไวยากรณ์เหล่านี้ได้อย่างรวดเร็ว ขอให้ใช้บทนี้เป็นคู่มืออ้างอิงเพื่อนำทางคุณไปสู่ทางออกที่ดีในยามจำเป็น
ในบทต่อไป เราจะนำทุกสิ่งที่เราได้เรียนรู้ร่วมกันมาตลอดทั้งเล่มมาลงมือปฏิบัติจริงในโปรเจกต์ส่งท้ายอีกหนึ่งโปรเจกต์!