Utiliser la macro sur les fichiers de module dans React

1. Macros Rust
2. Macros sur des caisses dans Rust
3. Macros dans la même caisse dans Rust

Dans cet article, nous allons apprendre à utiliser les macros sur les fichiers de module dans Rust.

Macros Rust

Rust fournit un excellent support macro. Par exemple, la métaprogrammation, qui est activée via des macros, implique l’écriture de code qui écrit un autre code.

Les Macros offrent des capacités comparables aux fonctions mais sans le coût d’exécution associé. Comme les Macros sont étendues au moment de la compilation, des coûts de temps de construction sont associés.

Les macros Rust diffèrent considérablement des macros C. Par exemple, les macros Rust sont appliquées à l’arborescence de jetons, tandis que les macros C remplacent le texte.

Syntaxe :

*MacroRulesDefinition* :
  `macro_rules` `!` [IDENTIFIER] *MacroRulesDef*

MacroRules :
   MacroRule ( ; MacroRule )* ;?

MacroRule :
   MacroMatcher => MacroTranscriber

Macros sur des caisses dans Rust

Un crate comprend une hiérarchie de portées de module. Tout objet dans une caisse a un chemin de module canonique indiquant son emplacement dans l’arborescence des modules.

Au niveau supérieur de cette arborescence, il y a un module anonyme. Un fichier source Rust spécifie un module dont le nom et l’emplacement dans l’arborescence des modules du crate courant sont définis en externe : soit par un élément Module explicite dans un fichier source référencé.

Cela pourrait aussi être le nom des caisses elles-mêmes. Chaque fichier source est un module.

Cependant, chaque module n’a pas besoin de son fichier source : les définitions de module peuvent être superposées dans un seul fichier source.

Caisse util :

#[macro_export]
macro_rules! foo {
    () => ()
}

Caisse utilisateur :

use util::foo;

foo!();

Notez que les macros résident toujours au niveau supérieur d’un casier lorsque vous utilisez cette stratégie. Même si foo est contenu dans un mod bar, le crate user doit toujours écrire use util::foo; et non use util::bar::foo;.

Vous pouvez exporter une macro depuis un module de votre crate en utilisant pub use.

Macros dans la même caisse dans Rust

foo::bar!();

mod foo {
    macro_rules! bar {
        () => ()
    }

    pub(crate) use bar;
}

foo::bar!();

La macro peut être importée et utilisée comme n’importe quel autre objet avec utilisation pub. Et contrairement à l’ancienne méthode, cela ne dépend pas de l’ordre du code source, vous pouvez donc utiliser la macro avant qu’elle ne soit écrite.

Chaque macro a un nom et une ou plusieurs règles. Chaque règle se compose de deux parties : un matcher, qui décrit la syntaxe à laquelle il correspond, et un transcripteur, qui décrit la syntaxe qui sera substituée à un appel correspondant avec succès.

Les délimiteurs doivent englober à la fois le matcher et le transcripteur. Les expressions, les déclarations, les traits, les impls, les éléments étrangers, les types et les modèles peuvent être étendus via des macros.