Macros declarativas (`macro_rules!`)

¡Las macros permiten escribir código que escribe código! Son similares a las funciones, pero operan sobre árboles sintácticos (la estructura de su código) en lugar de valores.

• Ayudan a abstraer código repetitivo.
• Permiten crear lenguajes específicos de dominio (DSL) dentro de Rust.
• Se ejecutan en tiempo de compilación y se expanden a código Rust normal antes de la compilación.

Las macros declarativas de Rust usan la palabra clave macro_rules!. Definen un conjunto de reglas que coinciden con patrones específicos de código Rust.

Considérelas como una coincidencia de patrones aplicada al código. Cuando el compilador encuentra una invocación de macro, intenta hacer coincidir la entrada con una de las reglas que ha definido.

Vamos a crear una macro muy sencilla que imprima un saludo. Observe la palabra clave macro_rules! y la sintaxis () => {}, que define una regla sin patrón de entrada.

Pruebe a ejecutar este ejemplo:

Las macros pueden recibir entradas mediante «designadores». Estos indican a la macro qué tipo de sintaxis de Rust debe esperar capturar.

• $expr: una expresión (por ejemplo, 1 + 2, "hello")
• $ident: un identificador (por ejemplo, el nombre de una variable o función)
• $ty: un tipo (por ejemplo, i32, String)
• $block: un bloque de código (por ejemplo, { ... })
• ...¡y muchos más!

Aquí tiene una macro que recibe una expresión ($e:expr) e imprime su valor. :expr es el designador.

El $e capturado queda disponible para usarlo en el cuerpo de la macro. La macro stringify! convierte la expresión en su representación como cadena.

¿Qué ocurre si quiere que una macro reciba varios argumentos del mismo tipo? Puede usar operadores de repetición: $()*.

• $(): el contenido interno es el patrón que se repetirá.
• *: cero o más repeticiones.
• +: una o más repeticiones.
• También puede especificar un separador, como $(...),* para elementos separados por comas.

Vamos a crear una macro que reciba varias expresiones separadas por comas e imprima cada una individualmente. Esto resulta muy útil para crear estructuras similares a listas.

Las macros de Rust son «higiénicas». Esto significa que las variables definidas dentro de una macro no entrarán en conflicto accidentalmente con las variables externas, aunque tengan el mismo nombre.

Durante la expansión, el compilador cambia internamente los nombres para evitar efectos secundarios no deseados, lo que hace que las macros sean más seguras y previsibles.

A veces las macros no se expanden como espera. Rust ofrece una forma de ver el código expandido:

• Ejecute cargo expand (requiere instalar la herramienta cargo-expand).
• Use directamente rustc --pretty expanded en el archivo de código fuente.

Esto muestra el código Rust sin procesar que genera su macro, lo que resulta invaluable para depurar y comprender el comportamiento de macros complejas.

Considere la siguiente definición de macro:

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

¿Cuál de las siguientes líneas se compilaría correctamente y usaría la macro make_tuple!?

En esta lección, ha aprendido sobre las macros declarativas que usan macro_rules!:

• Generan código en tiempo de compilación y abstraen patrones repetitivos.
• Usan coincidencia de patrones para capturar entradas según su sintaxis.
• Los designadores como $expr y $ident especifican qué tipo de sintaxis se espera.
• Los operadores de repetición como $()* gestionan varios argumentos con separadores flexibles.
• Las macros son higiénicas, lo que evita conflictos accidentales entre nombres.

¡Las macros son una herramienta muy potente para reducir el código repetitivo y crear API flexibles y ergonómicas en Rust!