Macros Rust

Les macros Rust sont un outil puissant pour générer du code à la compilation, ce qui vous permet de créer des extensions de syntaxe personnalisées pendant que vous écrivez du code.

Une macro est une technique de métaprogrammation dans le code, permettant la génération de code à la compilation. Les macros aident à simplifier le code, à améliorer sa lisibilité et sa maintenabilité, et permettent aux développeurs d'effectuer certaines opérations de génération de code à la compilation.

Il existe deux types de macros en Rust : les macros déclaratives et les macros procédurales.

Cet article présente principalement les macros déclaratives.

Définition de macro

En Rust, utilisez le mot-clémacro_rules!pour définir des macros déclaratives.

macro_rules! my_macro {
    // 模式匹配和展开
    ($arg:expr) => {
        // 生成的代码
        // 使用 $arg 来代替匹配到的表达式
    };
}

Les macros déclaratives utilisent le mot-clémacro_rules!pour leur définition, et elles sont appelées macros"macro_rules". Ce type de définition de macro est basé sur la correspondance de motifs ; il peut faire correspondre la structure du code et générer le code correspondant en fonction du motif correspondant. Ces macros peuvent être utilisées pour simplifier des motifs de code courants sans introduire de nouvelles structures syntaxiques.

Voici un exemple de définition de macro simple :

Exemple

// Définition de macro
macro_rules! greet {
    // Correspondance de motifs
    ($name:expr) => {
        // Expansion de macro
        println!("Hello, {}!", $name);
    };
}

fn main() {
    // Appeler la macro
    greet!("World");
}

Explication

  • Filtrage par motif :Les macros utilisent le filtrage par motif pour faire correspondre les fragments de code passés à la macro. Le motif est le côté gauche d'une règle de macro, utilisé pour capturer différentes structures de code.
  • Règles :Les règles de macro sont un ensemble de$motifs guidés et de code d'expansion correspondant, avec les règles séparées par des points-virgules.
  • Expansion de macro :Lorsqu'une macro est appelée, le motif correspondant est remplacé par le code d'expansion correspondant, qui est le côté droit de la règle de macro.

Exemple

Voici un exemple plus complexe démontrant comment utiliser une macro pour créer une simple macrovec!afin de faciliter la création d'un Vec :

Exemple

// Définition de macro
macro_rules! vec {
    // Cas de base : vide
    () => {
        Vec::new()
    };
   
    // Cas récursif : avec des éléments
    ($($element:expr),+ $(,)?) => {
        {
            let mut temp_vec = Vec::new();
            $(
                temp_vec.push($element);
            )+
            temp_vec
        }
    };
}

fn main() {
    // Appeler la macro
    let my_vec = vec![1, 2, 3];
    println!("{:?}", my_vec); // Sortie : [1, 2, 3]

    let empty_vec = vec![];
    println!("{:?}", empty_vec); // Sortie : []
}

Dans cet exemple,vec!la macro utilise la correspondance de motifs et$($element:expr),+ $(,)?)une telle syntaxe pour capturer les éléments passés à la macro et créer un Vec à partir de ceux-ci.

Notez que $(,)?)sert à gérer les virgules finales, ce qui lui permet de fonctionner correctement dans divers scénarios d'utilisation.


Macros procédurales

Les macros procédurales sont un type de macro plus flexible et plus puissant qui permet de manipuler l'arbre syntaxique abstrait (AST) grâce à la génération de code personnalisée au moment de la compilation. Les macros procédurales sont plus proches des fonctions en termes de fonctionnalité, mais elles sont plus complexes à écrire et à utiliser.

Types de macros procédurales :

  • Macros de dérivation: utilisées pour implémenter automatiquement des traits (tels queCopy、Debug) macros.
  • Macros d'attributs: utilisées pour attacher des métadonnées supplémentaires aux déclarations, telles que#[derive(Debug)]。

L'implémentation des macros procédurales nécessite généralement d'utiliser les fonctionnalités fournies par la bibliothèque proc_macro, telles que TokenStream et TokenTree, pour manipuler le code source plus directement.

Autres extensions