מאקרו חלודה: כיצד השימוש בהם יכול לשפר את הקוד שלך

יצירת קוד היא תכונה שתמצא ברוב שפות התכנות המודרניות. זה יכול לעזור לך להפחית את קוד ה-boilerplate ושכפול הקוד, להגדיר שפות ספציפיות לתחום (DSL) וליישם תחביר חדש.

Rust מספקת מערכת מאקרו רבת עוצמה המאפשרת ליצור קוד בזמן קומפילציה לתכנות מתוחכם יותר.

מבוא למאקרו חלודה

מאקרו הם סוג של מטא-תכנות שאתה יכול למנף לכתיבת קוד שכותב קוד. ב-Rust, מאקרו הוא קטע קוד שמייצר קוד אחר בזמן ההידור.

פקודות מאקרו חלודה הן תכונה רבת עוצמה המאפשרת לך לכתוב קוד שיוצר קוד אחר בזמן הידור לאוטומציה של משימות שחוזרות על עצמן. פקודות המאקרו של Rust עוזרות להפחית את כפילות הקוד ולהגדיל את יכולת התחזוקה והקריאה של הקוד.

אתה יכול להשתמש בפקודות מאקרו כדי ליצור כל דבר, החל מקטעי קוד פשוטים ועד ספריות ומסגרות. מאקרו שונים מ פונקציות חלודה כי הם פועלים על קוד ולא על נתונים בזמן ריצה.

הגדרת מאקרו בחלודה

אתה תגדיר פקודות מאקרו עם ה כללי_מאקרו! מאקרו. ה כללי_מאקרו! מאקרו לוקח דפוס ותבנית כקלט. חלודה מתאימה את התבנית לקוד הקלט ומשתמשת בתבנית כדי ליצור את קוד הפלט.

כך תוכל להגדיר מאקרו בחלודה:

כללי_מאקרו! תגיד שלום {
 () => {
println!("שלום עולם!");
 };
}
fnרָאשִׁי() {
 תגיד שלום!();
}

הקוד מגדיר את א תגיד שלום מאקרו שיוצר קוד להדפסת "שלום, עולם!". הקוד תואם את () תחביר כנגד קלט ריק וה- println! מאקרו יוצר את קוד הפלט.

הנה התוצאה של הפעלת המאקרו ב- רָאשִׁי פוּנקצִיָה:

מאקרו יכול לקחת ארגומנטים קלט עבור הקוד שנוצר. הנה מאקרו שלוקח ארגומנט בודד ויוצר קוד להדפסת הודעה:

כללי_מאקרו! say_message {
 ($message: expr) => {
println!("{}", $message);
 };
}

ה say_message מאקרו לוקח את $הודעה ארגומנט ויוצר קוד להדפסת הארגומנט באמצעות ה- println! מאקרו. ה expr תחביר תואם את הארגומנט נגד כל ביטוי Rust.

סוגי מאקרו חלודה

חלודה מספקת שלושה סוגים של פקודות מאקרו. כל אחד מסוגי המאקרו משרת מטרות ספציפיות, ויש להם את התחביר והמגבלות שלהם.

מאקרו פרוצדורלי

פקודות מאקרו פרוצדורליות נחשבות לסוג החזק והרב-תכליתי ביותר. פקודות מאקרו פרוצדורליות מאפשרות לך להגדיר תחביר מותאם אישית שיוצר קוד Rust בו-זמנית. אתה יכול להשתמש בפקודות מאקרו פרוצדורליות כדי ליצור פקודות מאקרו נגזרות מותאמות אישית, פקודות מאקרו דמויות תכונות מותאמות אישית ופקודות מאקרו דמויות פונקציות מותאמות אישית.

אתה תשתמש בפקודות מאקרו מותאמות אישית כדי ליישם מבנים ותכונות ספירה באופן אוטומטי. חבילות פופולריות כמו Serde משתמשות במאקרו נגזרת מותאם אישית כדי ליצור קוד הסדרת וסיריאליזציה עבור מבני נתונים של Rust.

פקודות מאקרו דמויות תכונה מותאמות אישית שימושיות להוספת הערות מותאמות אישית לקוד Rust. מסגרת האינטרנט של Rocket משתמשת במאקרו דמוי תכונה מותאם אישית כדי להגדיר מסלולים בצורה תמציתית וקריאה.

ניתן להשתמש בפקודות מאקרו דמויות פונקציות מותאמות אישית כדי להגדיר ביטויים או הצהרות Rust חדשים. ארגז Lazy_static משתמש במאקרו דמוי פונקציה מותאם אישית כדי להגדיר את עצלן-אתחול משתנים סטטיים.

כך תוכל להגדיר מאקרו פרוצדורלי המגדיר מאקרו נגזר מותאם אישית:

להשתמש proc_macro:: TokenStream;
להשתמש quote:: quote;
להשתמש syn::{DeriveInput, parse_macro_input};

ה להשתמש הנחיות מייבאות ארגזים וסוגים הכרחיים לכתיבת מאקרו פרוצדורלי Rust.

#[proc_macro_derive (MyTrait)]
פָּאבּfnמאקרו_מגיע_שלי(קלט: TokenStream) -> TokenStream {
לתת ast = parse_macro_input!(input כפי ש DeriveInput);
לתת name = &ast.ident;
לתת gen = ציטוט! {
impl MyTrait ל #שם {
// יישום כאן
 }
 };
 gen.into()
}

התוכנית מגדירה מאקרו פרוצדורלי שיוצר יישום של תכונה עבור מבנה או enum. התוכנית מפעילה את המאקרו עם השם MyTrait בתכונת הנגזרת של המבנה או ה-enum. המאקרו לוקח א TokenStream אובייקט כקלט המכיל את הקוד שמנותח לתוך עץ תחביר מופשט (AST) עם ה- parse_macro_input! מאקרו.

ה שֵׁם המשתנה הוא המבנה הנגזר או מזהה ה-enum, ה- ציטוט! המאקרו יוצר AST חדש המייצג את היישום של MyTrait עבור הסוג שבסופו של דבר חזר בתור a TokenStream עם ה לְתוֹך שיטה.

כדי להשתמש במאקרו, תצטרך לייבא את המאקרו מהמודול שבו הצהרת עליו:

// בהנחה שהכרזת על המאקרו במודול my_macro_module
להשתמש my_macro_module:: my_derive_macro;

בהכרזה על המבנה או ה-enum המשתמשים במאקרו, תוסיף את ה #[נגזר (MyTrait)] לייחס לראש ההצהרה.

#[נגזר (MyTrait)]
מבנהMyStruct {
// שדות כאן
}

הצהרת המבנה עם התכונה מתרחבת ליישום של ה- MyTrait תכונה למבנה:

impl MyTrait ל MyStruct {
// יישום כאן
}

היישום מאפשר לך להשתמש בשיטות ב- MyTrait תכונה על MyStruct מקרים.

תכונה מאקרו

פקודות מאקרו של תכונה הן פקודות מאקרו שניתן להחיל על פריטי Rust כמו מבנים, רשימות, פונקציות ומודולים. פקודות מאקרו של תכונה לובשות צורה של תכונה ואחריה רשימה של ארגומנטים. המאקרו מנתח את הארגומנט ליצירת קוד Rust.

תשתמש בפקודות מאקרו של מאפיינים כדי להוסיף התנהגויות והערות מותאמות אישית לקוד שלך.

להלן מאקרו של תכונה שמוסיף תכונה מותאמת אישית למבנה Rust:

// ייבוא ​​מודולים עבור הגדרת המאקרו
להשתמש proc_macro:: TokenStream;
להשתמש quote:: quote;
להשתמש syn::{parse_macro_input, DeriveInput, AttributeArgs};
#[proc_macro_attribute]
פָּאבּfnמאקרו_התכונה_שלי(attr: TokenStream, פריט: TokenStream) -> TokenStream {
לתת args = parse_macro_input!(attr כפי ש AttributeArgs);
לתת input = parse_macro_input!(item כפי ש DeriveInput);
לתת name = &input.ident;
לתת gen = ציטוט! {
 #קֶלֶט
impl #שם {
// התנהגות מותאמת אישית כאן
 }
 };
 gen.into()
}

המאקרו לוקח רשימה של ארגומנטים ו הגדרת מבנה ויוצר מבנה שונה עם ההתנהגות המותאמת אישית המוגדרת.

המאקרו מקבל שני ארגומנטים כקלט: התכונה המוחלת על המאקרו (מנותח עם ה- parse_macro_input! מאקרו) והפריט (מנותח עם ה- parse_macro_input! מאקרו). המאקרו משתמש ב- ציטוט! מאקרו ליצירת הקוד, כולל פריט הקלט המקורי ועוד impl בלוק שמגדיר את ההתנהגות המותאמת אישית.

לבסוף, הפונקציה מחזירה את הקוד שנוצר בתור a TokenStream עם ה לְתוֹך() שיטה.

כללי מאקרו

כללי מאקרו הם הסוג הפשוט והגמיש ביותר של פקודות מאקרו. כללי מאקרו מאפשרים לך להגדיר תחביר מותאם אישית שמתרחב לקוד Rust בזמן ההידור. כללי מאקרו מגדירים פקודות מאקרו מותאמות אישית התואמות כל ביטוי או משפט חלודה.

אתה תשתמש בכללי מאקרו כדי ליצור קוד לוח כדי להפשט פרטים ברמה נמוכה.

כך תוכל להגדיר ולהשתמש בכללי מאקרו בתוכניות Rust שלך:

כללי_מאקרו! make_vector {
 ( $( $x: expr ),* ) => {
 {
לתתמוט v = Vec::חָדָשׁ();
 $(
 v.push($x);
 )*
 v
 }
 };
}
fnרָאשִׁי() {
לתת v = make_vector![1, 2, 3];
println!("{:?}",v); // מדפיס "[1, 2, 3]"
}

התוכנית מגדירה את א make_vector! מאקרו שיוצר וקטור חדש מתוך רשימה של ביטויים מופרדים בפסיקים ב- רָאשִׁי פוּנקצִיָה.

בתוך המאקרו, הגדרת הדפוס תואמת את הארגומנטים שהועברו למאקרו. ה $( $x: expr ),* תחביר מתאים לכל ביטויים מופרדים בפסיקים שזוהו כ $x.

ה $( ) תחביר בקוד ההרחבה חוזר על כל ביטוי ברשימת הארגומנטים המועברים למאקרו לאחר הסוגריים הסוגרים, המציינים שהאיטרציות צריכות להמשיך עד שהמאקרו יעבד את כל ביטויים.

ארגן את פרויקטי החלודה שלך ביעילות

פקודות מאקרו חלודה משפרות את ארגון הקוד על ידי כך שהן מאפשרות לך להגדיר תבניות והפשטות קוד לשימוש חוזר. מאקרו יכול לעזור לך לכתוב קוד תמציתי יותר, אקספרסיבי ללא כפילויות על פני חלקי הפרויקט השונים.

כמו כן, אתה יכול לארגן תוכניות Rust לתוך ארגזים ומודולים לארגון קוד טוב יותר, שימוש חוזר ואינטראקציה עם ארגזים ומודולים אחרים.