La métaprogrammation Rust avec des macros

Introduction

Dans ce laboratoire, nous allons explorer le puissant système de macros fourni par Rust, qui permet la métaprogrammation en étendant les macros en arbres syntaxiques abstraits. Le macro macro_rules! est utilisé pour créer des macros, et elles sont distinguées des fonctions par leur terminaison bang !. Les macros sont utiles pour éviter la répétition de code, créer des langages spécifiques au domaine et définir des interfaces variadiques pour les fonctions qui peuvent prendre un nombre variable d'arguments.

Note : Si le laboratoire ne spécifie pas de nom de fichier, vous pouvez utiliser n'importe quel nom de fichier que vous voulez. Par exemple, vous pouvez utiliser main.rs, le compiler et l'exécuter avec rustc main.rs &&./main.

macro_rules!

Rust fournit un puissant système de macros qui permet la métaprogrammation. Comme vous l'avez vu dans les chapitres précédents, les macros ressemblent à des fonctions, sauf que leur nom se termine par un bang !, mais au lieu de générer un appel de fonction, les macros sont étendues en code source qui est compilé avec le reste du programme. Cependant, contrairement aux macros en C et dans d'autres langages, les macros Rust sont étendues en arbres syntaxiques abstraits, plutôt qu'un prétraitement de chaînes, donc vous n'avez pas de bogues d'ordre de priorité inattendus.

Les macros sont créées à l'aide du macro macro_rules!.

// Ceci est une macro simple nommée `say_hello`.
macro_rules! say_hello {
    // `()` indique que la macro ne prend aucun argument.
    () => {
        // La macro sera étendue dans le contenu de ce bloc.
        println!("Hello!")
    };
}

fn main() {
    // Cette appel sera étendu en `println!("Hello")`
    say_hello!()
}

Alors pourquoi les macros sont-elles utiles?

1. Ne pas répéter soi-même. Il y a de nombreux cas où vous pouvez avoir besoin d'une fonctionnalité similaire à plusieurs endroits, mais avec différents types. Souvent, écrire une macro est un moyen utile d'éviter de répéter le code. (Plus de détails plus tard)

2. Langages spécifiques au domaine. Les macros vous permettent de définir une syntaxe spéciale à des fins spécifiques. (Plus de détails plus tard)

3. Interfaces variadiques. Parfois, vous voulez définir une interface qui prend un nombre variable d'arguments. Un exemple est println! qui peut prendre un nombre quelconque d'arguments, selon la chaîne de formatage. (Plus de détails plus tard)

Résumé

Félicitations! Vous avez terminé le laboratoire Macro_rules! Vous pouvez pratiquer d'autres laboratoires sur LabEx pour améliorer vos compétences.