Sistemul de Macro-uri în Rust: Macro-uri Declarative (macro_rules!) și Procedurale (proc_macro) în Rust

Ghid complet pentru metaprogramare în Rust: diferența dintre macro-urile declarative (macro_rules!) și macro-urile procedurale (Custom Derive, Attribute, Function-like) cu syn, quote și proc-macro2.

Sintaxă
macro_rules! my_vec { ... } | #[proc_macro_derive(MyTrait)] | #[proc_macro_attribute]

Spre deosebire de preprocesorul textual brut din C/C++ (care este predispus la bug-uri subtile de substituție și nu înțelege structura gramaticală), macro-urile din Rust operează direct pe fluxuri de token-uri (TokenStream) și arbori de sintaxă abstractă (AST), beneficiind de igienă lexicală completă (Hygienic Macros).

1. Macro-uri Declarative (macro_rules!)

Macro-urile declarative utilizează un mecanism puternic de pattern matching direct pe secvențe de cod Rust, folosind specificatori de tip (expr, ident, ty, pat, block):

Implementarea unui Macro Declarativ pentru Inițializarea de Dictionare (HashMap)
#[macro_export]
macro_rules! hashmap {
    // Cazul de bază: dicționar gol
    () => {
        std::collections::HashMap::new()
    };
    
    // Potrivire pentru una sau mai multe perechi cheie => valoare:
    // $($key:expr => $val:expr),* permite separarea prin virgulă
    // $(,)? permite o virgulă opțională la final (trailing comma)
    ( $($key:expr => $val:expr),* $(,)? ) => {
        {
            let mut _map = std::collections::HashMap::new();
            $(
                _map.insert($key, $val);
            )*
            _map
        }
    };
}

fn main() {
    // Utilizare elegantă și curată:
    let scoruri = hashmap! {
        "Alice" => 100,
        "Bob" => 85,
        "Dexter" => 99,
    };
    println!("Scor Dexter: {:?}", scoruri.get("Dexter"));
}

2. Macro-uri Procedurale (proc_macro)

Macro-urile procedurale sunt practic plugin-uri de compilare scrise în Rust care primesc un TokenStream la intrare, îl manipulează prin analiză sintactică și emit un nou TokenStream generat la ieșire:

Tip Macro Procedural Sintaxă de Utilizare Scenariu Predominant
Custom Derive #[derive(Serializable)] Generarea automată a implementărilor de trait-uri (cum face serde).
Attribute Macro #[tokio::main] sau #[get("/api")] Transformarea completă a unei funcții, structuri sau modul.
Function-like Macro sql!("SELECT * FROM users") Validarea la compilare a sintaxei SQL, HTML sau formatelor externe.
Comunitate & Schimb de cunoștințe

Întrebări & Exemple de Cod: Sistemul de Macro-uri în Rust: Macro-uri Declarative (macro_rules!) și Procedurale (proc_macro)

Ai o nelămurire despre utilizarea comenzii Sistemul de Macro-uri în Rust: Macro-uri Declarative (macro_rules!) și Procedurale (proc_macro) sau ai descoperit un truc / fragment de cod util? Distribuie-l cu ceilalți programatori!

💬

Fii primul care pune o întrebare sau distribuie un fragment de cod / prompt!

Nu au fost adăugate încă întrebări sau exemple de cod pentru această pagină. Dacă ai întâlnit o problemă sau ai un snippet util, adaugă-l mai jos pentru a-i ajuta pe ceilalți.

Comunitate Adaugă o întrebare sau distribuie un cod

Moderare & Siguranță:

Pentru a menține calitatea și securitatea informațiilor, fiecare întrebare sau fragment de cod/prompt este analizat (manual sau prin moderare asistată de AI) înainte de publicare.