Learn Rust Coding · Leçon

Macros déclaratives (`macro_rules!`)

Apprenez à écrire des macros déclaratives pour abstraire les motifs de code répétitifs et générer du code au moment de la compilation.

Macros déclaratives (`macro_rules!`) est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 1 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 3 leçons au total.

Que sont les macros Rust ?

Les macros permettent d'écrire du code qui écrit du code ! Elles ressemblent aux fonctions, mais opèrent sur des arbres syntaxiques (la structure de votre code) plutôt que sur des valeurs.

Elles contribuent à abstraire le code répétitif.
Elles permettent de créer des langages spécifiques à un domaine (DSL) dans Rust.
Elles s'exécutent au moment de la compilation et se développent en code Rust ordinaire avant la compilation.

Syntaxe des macros déclaratives

Les macros déclaratives de Rust utilisent le mot-clé macro_rules!. Elles définissent un ensemble de règles qui correspondent à des motifs précis du code Rust.

Considérez cela comme une correspondance de motifs appliquée à des fragments de code. Lorsque le compilateur rencontre un appel de macro, il tente de faire correspondre l'entrée à l'une des règles que vous avez définies.

Votre première `macro_rules!`

Créons une macro très simple qui affiche un message de bienvenue. Remarquez le mot-clé macro_rules! et la syntaxe () => {}, qui définit une règle sans motif d'entrée.

Essayez d'exécuter cet exemple :

macro_rules! greet {
    () => {
        println!("Hello from a macro!");
    };
}

fn main() {
    greet!(); // Call our macro!
}

Capturer une entrée avec des désignateurs

Les macros peuvent recevoir une entrée à l'aide de « désignateurs ». Ceux-ci indiquent à la macro quel type de syntaxe Rust elle doit s'attendre à capturer.

$expr : une expression (par exemple, 1 + 2, "hello")
$ident : un identifiant (par exemple, le nom d'une variable ou d'une fonction)
$ty : un type (par exemple, i32, String)
$block : un bloc de code (par exemple, { ... })
...et bien d'autres !

Les macros avec arguments

Voici une macro qui prend une expression ($e:expr) et en affiche la valeur. Le :expr est le désignateur.

Le $e capturé devient alors disponible dans le corps de la macro. La macro stringify! convertit l'expression en sa représentation sous forme de chaîne.

macro_rules! debug_print {
    ($e:expr) => {
        println!("Debug: {} = {:?}", stringify!($e), $e);
    };
}

fn main() {
    let x = 10;
    debug_print!(x + 5);
    debug_print!("Rust macros are fun");
}

Gérer plusieurs entrées

Que faire si vous voulez qu'une macro accepte plusieurs arguments du même type ? Vous pouvez utiliser des opérateurs de répétition : $()*.

$() : le contenu inclus constitue le motif à répéter.
* : zéro répétition ou davantage.
+ : une répétition ou davantage.
Vous pouvez également préciser un séparateur, comme $(...),* pour des éléments séparés par des virgules.

Une macro avec des arguments répétitifs

Créons une macro qui prend plusieurs expressions séparées par des virgules et affiche chacune d'elles individuellement. C'est très utile pour créer des structures ressemblant à des listes.

macro_rules! print_all {
    ( $( $x:expr ),* ) => {
        $( // This $(...)* repeats the `println!` call
            println!("Item: {:?}", $x);
        )*
    };
}

fn main() {
    print_all!(1, "hello", true, 3.14);
    print_all!("Just one item");
}

Comprendre l'hygiène des macros

Les macros de Rust sont « hygiéniques ». Cela signifie que les variables définies à l'intérieur d'une macro n'entrent pas accidentellement en conflit avec les variables situées à l'extérieur, même si elles portent le même nom.

Le compilateur renomme les éléments en interne lors du développement afin d'empêcher les effets secondaires involontaires, ce qui rend les macros plus sûres et plus prévisibles.

Déboguer les macros

Il arrive que les macros ne se développent pas comme prévu. Rust fournit un moyen d'afficher le code développé :

Exécutez cargo expand (l'installation de l'outil cargo-expand est nécessaire).
Utilisez directement rustc --pretty expanded sur votre fichier source.

Cette commande affiche le code Rust brut généré par votre macro, ce qui est extrêmement utile pour déboguer et comprendre le comportement de macros complexes !

Quiz sur la correspondance de motifs des macros

Considérez la définition de macro suivante :

macro_rules! make_tuple {
    ( $x:expr, $y:expr ) => {
        ($x, $y)
    };
}

Laquelle des lignes suivantes compilerait correctement et utiliserait la macro make_tuple! ?

Récapitulatif : macros déclaratives

Dans cette leçon, vous avez découvert les macros déclaratives utilisant macro_rules! :

Elles génèrent du code au moment de la compilation et abstraient les motifs répétitifs.
Elles utilisent la correspondance de motifs pour capturer l'entrée selon sa syntaxe.
Les désignateurs tels que $expr et $ident précisent le type de syntaxe attendu.
Les opérateurs de répétition tels que $()* gèrent plusieurs arguments avec des séparateurs flexibles.
Les macros sont hygiéniques et empêchent les conflits de noms accidentels.

Les macros sont un outil puissant pour réduire le code répétitif et créer des interfaces de programmation flexibles et ergonomiques en Rust !

Questions Fréquemment Posées

La leçon « Macros déclaratives (`macro_rules!`) » est-elle gratuite ?

Oui — le texte complet de « Macros déclaratives (`macro_rules!`) » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Macros déclaratives (`macro_rules!`) » ?

Apprenez à écrire des macros déclaratives pour abstraire les motifs de code répétitifs et générer du code au moment de la compilation. Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?

Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 3.

Combien de temps prend la leçon « Macros déclaratives (`macro_rules!`) » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?

Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Learn Rust Coding