Designadores

Los argumentos de un macro tienen como prefijo un signo de dólar $ y el tipo está anotado con un designador:

macro_rules! crea_funcion {
    // Este macro toma un argumento de designante `ident` y crea una función llamada
    // `$nombre_func`.
    // El designador `ident` se usa para nombres de variables y funciones.
    ($nombre_func:ident) => {
        fn $nombre_func() {
            // El macro `stringify!` convierte un `ident` en una cadena.
            println!("Tu llamste {:?}()",
                     stringify!($nombre_func));
        }
    };
}

// Crea funciones llamadas `foo` y `bar` con el macro anterior.
crea_funcion!(foo);
crea_funcion!(bar);

macro_rules! imprime_resultado {
    // Este macro toma una expresión de tipo `expr` y la imprime como una cadena junto
    // con su resultado.
    // El designador `expr` se usa para expresiones.
    ($expresion:expr) => {
        // `stringify!` convertirá la expresión *como está* en una cadena.
        println!("{:?} = {:?}",
                 stringify!($expresion),
                 $expresion);
    };
}

fn main() {
    foo();
    bar();

    imprime_resultado!(1u32 + 1);

    // ¡Recuerda que los bloques también son expresiones!
    imprime_resultado!({
        let x = 1u32;

        x * x + 2 * x - 1
    });
}

Estos son algunos de los designadores disponibles:

  • block
  • expr se usa para expresiones
  • ident se usa para nombres de variables y funciones
  • item
  • literal se usa para constantes literales
  • pat (patron)
  • path
  • stmt (declaración)
  • tt (árbol de tokens)
  • ty (tipo)
  • vis (calificador de visibilidad)

Para obtener una lista completa, consulta la Referencia Rust.