Aprender Rust Macros

Las macros en Rust son una forma de metaprogramación: código que genera código durante la compilación. A diferencia de las funciones, las macros pueden aceptar un número variable de argumentos, operar sobre el árbol sintáctico y generar código repetitivo automáticamente.

Macros de la librería estándar

Rust incluye macros fundamentales de uso diario: println! y format! para salida y formato, vec! para crear vectores con sintaxis concisa, assert!, assert_eq! y assert_ne! para testing, panic! para errores irrecuperables, todo! y unimplemented! como marcadores, y dbg! para depuración conveniente que imprime el nombre y valor de una expresión.

macro_rules!: macros declarativas

Las macros declarativas definen patrones de entrada y sus correspondientes expansiones. Usan designadores de fragmento (expr, ident, ty, literal, block) y soportan múltiples patrones y repetición con $(...)* o $(...)+:

macro_rules! log_error {
    ($($arg:tt)*) => {
        eprintln!("[ERROR {}:{}] {}", file!(), line!(), format!($($arg)*));
    };
}

Macros procedurales derive

Las macros derive son la forma más común de macros procedurales. Implementan traits automáticamente para structs y enums. Los más comunes son Debug, Clone, PartialEq, Eq, Hash, Serialize y Deserialize (estos últimos de la crate serde). Eliminar código boilerplate es uno de los usos más valiosos de Rust.

Serde como ejemplo práctico

La crate serde con #[derive(Serialize, Deserialize)] es el ejemplo más utilizado de macros procedurales en el ecosistema Rust, generando automáticamente el código de serialización y deserialización para cualquier struct o enum.