Usar macro en archivos de módulos en React
En este artículo, aprenderemos sobre el uso de macros en archivos de módulos en Rust.
Macros de Rust
Rust proporciona un excelente soporte para macros. Por ejemplo, la metaprogramación, que se habilita a través de macros, implica escribir código que escribe otro código.
Las macros ofrecen una capacidad comparable a las funciones pero sin el costo de tiempo de ejecución asociado. Como las macros se extienden en tiempo de compilación, los costos de tiempo de compilación están asociados.
Las macros de Rust difieren significativamente de las macros de C. Por ejemplo, las macros de Rust se aplican al árbol de fichas, mientras que las macros de C sustituyen al texto.
Sintaxis:
*MacroRulesDefinition* :
`macro_rules` `!` [IDENTIFIER] *MacroRulesDef*
MacroRules :
MacroRule ( ; MacroRule )* ;?
MacroRule :
MacroMatcher => MacroTranscriber
Macros en cajas en Rust
Una crate incluye una jerarquía de alcances de módulos. Cualquier objeto dentro de una caja tiene una ruta de módulo canónica que indica su ubicación dentro del árbol de módulos.
En el nivel superior de este árbol, hay un módulo anónimo. Un archivo fuente de Rust especifica un módulo cuyo nombre y ubicación en el árbol de módulos de la caja actual se definen externamente: ya sea por un elemento Módulo explícito en un archivo fuente al que se hace referencia.
También podría ser el nombre de las propias cajas. Cada archivo fuente es un módulo.
Sin embargo, no todos los módulos necesitan su archivo fuente: las definiciones de los módulos se pueden superponer en un solo archivo fuente.
Caja util:
#[macro_export]
macro_rules! foo {
() => ()
}
Caja usuario:
use util::foo;
foo!();
Tenga en cuenta que las macros siempre residen en el nivel superior de un crate cuando se utiliza esta estrategia. Incluso si foo está contenido dentro de un mod bar, el crate user debe escribir use util::foo; y no use util::bar::foo;.
Puede exportar una macro desde un módulo de su caja utilizando pub use.
Macros dentro de la misma caja en Rust
foo::bar!();
mod foo {
macro_rules! bar {
() => ()
}
pub(crate) use bar;
}
foo::bar!();
La macro se puede importar y usar como cualquier otro objeto con uso pub. Y a diferencia de la forma anterior, esto no depende del orden del código fuente, por lo que puede usar la macro antes de que se haya escrito.
Cada macro tiene un nombre y una o más reglas. Cada regla consta de dos partes: un comparador, que describe la sintaxis con la que coincide, y un transcriptor, que describe la sintaxis que se sustituirá por una invocación coincidente con éxito.
Los delimitadores deben abarcar tanto al comparador como al transcriptor. Las expresiones, las declaraciones, los rasgos, los impls, los elementos extraños, los tipos y los patrones se pueden expandir a través de macros.