रस्ट मैक्रोज़: उनका उपयोग कैसे आपके कोड को बेहतर बना सकता है

कोड जनरेशन एक ऐसी सुविधा है जो आपको अधिकांश आधुनिक प्रोग्रामिंग भाषाओं में मिलेगी। यह बॉयलरप्लेट कोड और कोड दोहराव को कम करने, डोमेन-विशिष्ट भाषाओं (डीएसएल) को परिभाषित करने और नए सिंटैक्स को लागू करने में आपकी सहायता कर सकता है।

जंग एक शक्तिशाली मैक्रो सिस्टम प्रदान करता है जो आपको अधिक परिष्कृत प्रोग्रामिंग के लिए संकलन समय पर कोड उत्पन्न करने की अनुमति देता है।

रस्ट मैक्रोज़ का परिचय

मैक्रोज़ एक प्रकार का मेटाप्रोग्रामिंग है जिसका उपयोग आप कोड लिखने वाले कोड लिखने के लिए कर सकते हैं। जंग में, एक मैक्रो कोड का एक टुकड़ा है जो संकलन समय पर अन्य कोड उत्पन्न करता है।

रस्ट मैक्रोज़ एक शक्तिशाली विशेषता है जो आपको कोड लिखने की अनुमति देता है जो दोहराए जाने वाले कार्यों को स्वचालित करने के लिए संकलन समय पर अन्य कोड उत्पन्न करता है। रस्ट के मैक्रोज़ कोड दोहराव को कम करने और कोड रखरखाव और पठनीयता बढ़ाने में मदद करते हैं।

आप सरल कोड स्निपेट्स से लेकर लाइब्रेरी और फ्रेमवर्क तक कुछ भी उत्पन्न करने के लिए मैक्रोज़ का उपयोग कर सकते हैं। मैक्रोज़ से अलग हैं

जंग कार्य करता है क्योंकि वे रनटाइम पर डेटा के बजाय कोड पर काम करते हैं।

रस्ट में मैक्रोज़ को परिभाषित करना

आप मैक्रोज़ को इसके साथ परिभाषित करेंगे मैक्रो_नियम! मैक्रो। मैक्रो_नियम! मैक्रो इनपुट के रूप में एक पैटर्न और एक टेम्पलेट लेता है। जंग इनपुट कोड के खिलाफ पैटर्न से मेल खाता है और आउटपुट कोड उत्पन्न करने के लिए टेम्पलेट का उपयोग करता है।

यहां बताया गया है कि आप मैक्रोज़ को रस्ट में कैसे परिभाषित कर सकते हैं:

मैक्रो_नियम! हैलो कहें {
 () => {
प्रिंटल!("हैलो वर्ल्ड!");
 };
}
fnमुख्य() {
 हैलो कहें!();
}

कोड एक परिभाषित करता है हैलो कहें मैक्रो जो "हैलो, वर्ल्ड!" प्रिंट करने के लिए कोड उत्पन्न करता है। कोड से मेल खाता है () एक खाली इनपुट के खिलाफ सिंटैक्स और प्रिंटल! मैक्रो आउटपुट कोड उत्पन्न करता है।

यहाँ मैक्रो चलाने का परिणाम है मुख्य समारोह:

मैक्रोज़ उत्पन्न कोड के लिए इनपुट तर्क ले सकते हैं। यहां एक मैक्रो है जो एक तर्क लेता है और एक संदेश प्रिंट करने के लिए कोड उत्पन्न करता है:

मैक्रो_नियम! कहना_संदेश {
 ($संदेश: expr) => {
प्रिंटल!("{}", $ संदेश);
 };
}

say_message मैक्रो लेता है $ संदेश तर्क और तर्क का उपयोग करके प्रिंट करने के लिए कोड उत्पन्न करता है प्रिंटल! मैक्रो। एक्सप्र सिंटैक्स किसी भी जंग अभिव्यक्ति के खिलाफ तर्क से मेल खाता है।

रस्ट मैक्रोज़ के प्रकार

जंग तीन प्रकार के मैक्रोज़ प्रदान करता है। प्रत्येक मैक्रो प्रकार विशिष्ट उद्देश्यों को पूरा करता है, और उनके सिंटैक्स और सीमाएं होती हैं।

प्रक्रियात्मक मैक्रोज़

प्रक्रियात्मक मैक्रोज़ को सबसे शक्तिशाली और बहुमुखी प्रकार माना जाता है। प्रक्रियात्मक मैक्रोज़ आपको कस्टम सिंटैक्स को परिभाषित करने की अनुमति देता है जो एक साथ रस्ट कोड उत्पन्न करता है। आप कस्टम व्युत्पन्न मैक्रोज़, कस्टम विशेषता-जैसे मैक्रोज़ और कस्टम फ़ंक्शन-जैसे मैक्रोज़ बनाने के लिए प्रक्रियात्मक मैक्रोज़ का उपयोग कर सकते हैं।

आप स्ट्रक्चर्स और एनम लक्षणों को स्वचालित रूप से लागू करने के लिए कस्टम व्युत्पन्न मैक्रोज़ का उपयोग करेंगे। Serde जैसे लोकप्रिय पैकेज रस्ट डेटा संरचनाओं के लिए क्रमांकन और डीरियलाइज़ेशन कोड उत्पन्न करने के लिए एक कस्टम व्युत्पन्न मैक्रो का उपयोग करते हैं।

कस्टम विशेषता-जैसे मैक्रोज़ कस्टम एनोटेशन को रस्ट कोड में जोड़ने के लिए आसान हैं। रॉकेट वेब फ्रेमवर्क मार्गों को संक्षिप्त और पठनीय रूप से परिभाषित करने के लिए एक कस्टम विशेषता-जैसे मैक्रो का उपयोग करता है।

आप नए रस्ट एक्सप्रेशंस या स्टेटमेंट्स को परिभाषित करने के लिए कस्टम फंक्शन-जैसे मैक्रोज़ का उपयोग कर सकते हैं। Lazy_static टोकरा परिभाषित करने के लिए एक कस्टम फ़ंक्शन-जैसी मैक्रो का उपयोग करता है आलसी-प्रारंभिक स्थैतिक चर।

यहां बताया गया है कि आप एक प्रक्रियात्मक मैक्रो को कैसे परिभाषित कर सकते हैं जो कस्टम व्युत्पन्न मैक्रो को परिभाषित करता है:

उपयोग proc_macro:: टोकनस्ट्रीम;
उपयोग बोली:: बोली;
उपयोग सिंक:: {DeriveInput, parse_macro_input};

उपयोग निर्देश रस्ट प्रक्रियात्मक मैक्रो लिखने के लिए आवश्यक क्रेट और प्रकार आयात करते हैं।

#[proc_macro_derive (MyTrait)]
पबfnmy_derive_macro(इनपुट: टोकनस्ट्रीम) -> टोकनस्ट्रीम {
होने देना ast = parse_macro_input! (इनपुट जैसा व्युत्पन्न इनपुट);
होने देना नाम = &ast.ident;
होने देना जीन = उद्धरण! {
प्रत्यय मायट्रेट के लिए #नाम {
// कार्यान्वयन यहाँ
 }
 };
 जीन.में ()
}

कार्यक्रम एक प्रक्रियात्मक मैक्रो को परिभाषित करता है जो संरचना या एनम के लिए एक विशेषता के कार्यान्वयन को उत्पन्न करता है। कार्यक्रम मैक्रो को नाम से आमंत्रित करता है मायट्रेट संरचना या एनम की व्युत्पन्न विशेषता में। मैक्रो एक लेता है टोकनस्ट्रीम इनपुट के रूप में ऑब्जेक्ट जिसमें कोड को सार सिंटैक्स ट्री (एएसटी) में पार्स किया गया है पार्स_मैक्रो_इनपुट! मैक्रो।

नाम चर व्युत्पन्न संरचना या एनम पहचानकर्ता है, the उद्धरण! मैक्रो के कार्यान्वयन का प्रतिनिधित्व करने वाला एक नया एएसटी उत्पन्न करता है मायट्रेट उस प्रकार के लिए जो अंततः एक के रूप में वापस आ गया है टोकनस्ट्रीम साथ में तरीका।

मैक्रो का उपयोग करने के लिए, आपको मैक्रो को उस मॉड्यूल से आयात करना होगा जिसमें आपने इसे घोषित किया था:

// यह मानते हुए कि आपने मैक्रो को my_macro_module मॉड्यूल में घोषित किया है
उपयोग my_macro_module:: my_derive_macro;

मैक्रो का उपयोग करने वाली संरचना या एनम घोषित करने पर, आप जोड़ देंगे #[व्युत्पन्न (माईट्रेट)] घोषणा के शीर्ष पर विशेषता।

#[व्युत्पन्न (माईट्रेट)]
structMyStruct {
// फ़ील्ड यहाँ
}

विशेषता के साथ संरचना घोषणा के कार्यान्वयन तक फैली हुई है मायट्रेट संरचना के लिए विशेषता:

प्रत्यय मायट्रेट के लिए माईस्ट्रक्चर {
// कार्यान्वयन यहाँ
}

कार्यान्वयन आपको विधियों का उपयोग करने की अनुमति देता है मायट्रेट विशेषता पर MyStruct उदाहरण।

विशेषता मैक्रोज़

विशेषता मैक्रोज़ मैक्रोज़ हैं जिन्हें आप रस्ट आइटम जैसे स्ट्रक्चर्स, एनम, फ़ंक्शंस और मॉड्यूल पर लागू कर सकते हैं। विशेषता मैक्रोज़ तर्कों की एक सूची के बाद एक विशेषता का रूप लेते हैं। मैक्रो रस्ट कोड जनरेट करने के तर्क को पार्स करता है।

आप अपने कोड में कस्टम व्यवहार और एनोटेशन जोड़ने के लिए विशेषता मैक्रोज़ का उपयोग करेंगे।

यहाँ एक विशेषता मैक्रो है जो एक रस्ट संरचना में एक कस्टम विशेषता जोड़ता है:

// मैक्रो परिभाषा के लिए मॉड्यूल आयात करना
उपयोग proc_macro:: टोकनस्ट्रीम;
उपयोग बोली:: बोली;
उपयोग syn::{parse_macro_input, DeriveInput, AttributeArgs};
#[proc_macro_attribute]
पबfnmy_attribute_macro(Attr: TokenStream, आइटम: TokenStream) -> TokenStream {
होने देना तर्क = parse_macro_input! (attr जैसा एट्रीब्यूटआर्ग);
होने देना इनपुट = parse_macro_input! (आइटम जैसा व्युत्पन्न इनपुट);
होने देना नाम = &input.ident;
होने देना जीन = उद्धरण! {
 #इनपुट
प्रत्यय #नाम {
// कस्टम व्यवहार यहाँ
 }
 };
 जीन.में ()
}

मैक्रो तर्कों की एक सूची लेता है और एक संरचना परिभाषा और परिभाषित कस्टम व्यवहार के साथ एक संशोधित संरचना उत्पन्न करता है।

मैक्रो इनपुट के रूप में दो तर्क लेता है: मैक्रो पर लागू की गई विशेषता ( पार्स_मैक्रो_इनपुट! मैक्रो) और आइटम (के साथ पार्स किया गया पार्स_मैक्रो_इनपुट! मैक्रो)। मैक्रो उपयोग करता है उद्धरण! मूल इनपुट आइटम और एक अतिरिक्त सहित कोड उत्पन्न करने के लिए मैक्रो प्रत्यय ब्लॉक जो कस्टम व्यवहार को परिभाषित करता है।

अंत में, फ़ंक्शन उत्पन्न कोड को एक के रूप में लौटाता है टोकनस्ट्रीम साथ में() तरीका।

मैक्रो नियम

मैक्रो नियम सबसे सरल और लचीले प्रकार के मैक्रोज़ हैं। मैक्रो नियम आपको कस्टम सिंटैक्स को परिभाषित करने की अनुमति देते हैं जो संकलन समय पर रस्ट कोड तक फैलता है। मैक्रो नियम कस्टम मैक्रोज़ को परिभाषित करते हैं जो किसी भी जंग अभिव्यक्ति या कथन से मेल खाते हैं।

आप सार निम्न-स्तरीय विवरण के लिए बॉयलरप्लेट कोड उत्पन्न करने के लिए मैक्रो नियमों का उपयोग करेंगे।

यहां बताया गया है कि आप अपने रस्ट प्रोग्राम में मैक्रो नियमों को कैसे परिभाषित और उपयोग कर सकते हैं:

मैक्रो_नियम! मेक_वेक्टर {
 ( $( $x: expr ),* ) => {
 {
होने देनामुठ वी = वी.ई.सी::नया();
 $(
 v.push($x);
 )*
 वि
 }
 };
}
fnमुख्य() {
होने देना वी = मेक_वेक्टर! [1, 2, 3];
प्रिंटल!("{:?}", वी); // प्रिंट "[1, 2, 3]"
}

कार्यक्रम एक परिभाषित करता है मेक_वेक्टर! एक मैक्रो जो अल्पविराम से अलग किए गए भावों की सूची से एक नया वेक्टर बनाता है मुख्य समारोह।

मैक्रो के अंदर, पैटर्न की परिभाषा मैक्रो को दिए गए तर्कों से मेल खाती है। $( $x: expr ),* सिंटैक्स के रूप में पहचाने गए किसी भी अल्पविराम से अलग किए गए भाव से मेल खाता है $x.

$( ) विस्तार कोड में सिंटैक्स बाद में मैक्रो को दिए गए तर्कों की सूची में प्रत्येक अभिव्यक्ति पर पुनरावृत्त होता है समापन कोष्ठक, यह दर्शाता है कि पुनरावृत्ति तब तक जारी रहनी चाहिए जब तक मैक्रो सभी को संसाधित नहीं करता भाव।

अपने रस्ट प्रोजेक्ट्स को कुशलता से व्यवस्थित करें

रस्ट मैक्रोज़ आपको पुन: प्रयोज्य कोड पैटर्न और सार को परिभाषित करने की अनुमति देकर कोड संगठन में सुधार करते हैं। मैक्रोज़ आपको विभिन्न परियोजना भागों में दोहराव के बिना अधिक संक्षिप्त, अभिव्यंजक कोड लिखने में मदद कर सकते हैं।

इसके अलावा, आप बेहतर कोड संगठन, पुन: प्रयोज्यता और अन्य क्रेट और मॉड्यूल के साथ इंटरऑपरेशन के लिए रस्ट प्रोग्राम को क्रेट और मॉड्यूल में व्यवस्थित कर सकते हैं।