Macros de Rust

Los macros de Rust (Macros) son una poderosa herramienta para generar código en tiempo de compilación, que te permite crear extensiones de sintaxis personalizadas al escribir código.

Un macro es una técnica de metaprogramación en el código que permite generar código en tiempo de compilación. Los macros pueden ayudar a simplificar el código, mejorar su legibilidad y mantenibilidad, y al mismo tiempo permitir a los desarrolladores realizar operaciones de generación de código en tiempo de compilación.

En Rust existen dos tipos de macros: macros declarativos (Declarative Macros) y macros procesales (Procedural Macros).

Este artículo se centra principalmente en los macros declarativos.

Definición de macros

En Rust, se utilizamacro_rules!la palabra clave para definir macros declarativos.

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

Los macros declarativos se definen conmacro_rules!la palabra clave, y se denominan"macro_rules"macros. La definición de este tipo de macros se basa en la coincidencia de patrones, que puede hacer coincidir la estructura del código y generar el código correspondiente según el patrón coincidente. Sin introducir nuevas estructuras sintácticas, estos macros se pueden utilizar para simplificar algunos patrones de código comunes.

A continuación se muestra un ejemplo de una definición de macro simple:

Ejemplo

// Definición del macro
macro_rules! greet {
    // Coincidencia de patrones
    ($name:expr) => {
        // Expansión del macro
        println!("Hello, {}!", $name);
    };
}

fn main() {
    // Llamada al macro
    greet!("World");
}

Explicación

  • Coincidencia de patrones:Un macro utiliza la coincidencia de patrones para hacer coincidir los fragmentos de código que se le pasan. El patrón es la parte izquierda de la regla del macro y se utiliza para capturar diferentes estructuras de código.
  • Reglas:Las reglas de macro son un conjunto de$patrones guiados por [la palabra clave] y el código de expansión correspondiente; las reglas están separadas por punto y coma.
  • Expansión del macro:Cuando se llama al macro, el patrón coincidente se reemplaza por el código de expansión correspondiente, que es la parte derecha de la regla del macro.

Ejemplo

A continuación se muestra un ejemplo más complejo que demuestra cómo utilizar macros para crear unvec!macro simple, con el fin de crear un Vec de manera más conveniente:

Ejemplo

// Definición del macro
macro_rules! vec {
    // Caso base, caso vacío
    () => {
        Vec::new()
    };
   
    // Caso recursivo, caso con elementos
    ($($element:expr),+ $(,)?) => {
        {
            let mut temp_vec = Vec::new();
            $(
                temp_vec.push($element);
            )+
            temp_vec
        }
    };
}

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

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

En este ejemplo,vec!el macro utiliza la coincidencia de patrones, así como$($element:expr),+ $(,)?)sintaxis como esta para capturar los elementos pasados al macro y crear un Vec con ellos.

Nota: $(,)?)se utiliza para manejar la coma final, de modo que funcione correctamente en diferentes situaciones de uso.


Macros procesales (Procedural Macros)

Los macros procesales son un tipo de macro más flexible y potente que permite manipular el árbol de sintaxis abstracta (AST) mediante procesos personalizados de generación de código en tiempo de compilación. Funcionalmente, los macros procesales se parecen más a funciones, pero su escritura y uso son más complejos.

Tipos de macros procesales:

  • Macros de derivación (Derive Macros): se utilizan para implementar automáticamente traits (por ejemplo,Copy、Debug).
  • Macros de atributos (Attribute Macros): se utilizan para adjuntar metadatos adicionales a las declaraciones, como#[derive(Debug)]。

La implementación de los macros procesales generalmente requiere el uso de las funciones proporcionadas por la biblioteca proc_macro, como TokenStream y TokenTree, para manipular el código fuente de manera más directa.

Otras extensiones