Introdução aos Designadores de Macros Rust

Introdução

Neste laboratório, somos introduzidos ao conceito de designadores em macros Rust. Designadores são usados para prefixar os argumentos de uma macro e são anotados com tipos. Alguns exemplos de designadores incluem ident para nomes de variáveis/funções, expr para expressões, block para blocos de código e pat para padrões. Esses designadores são usados dentro das regras da macro para gerar código com base nos argumentos fornecidos.

Nota: Se o laboratório não especificar um nome de arquivo, você pode usar qualquer nome de arquivo que desejar. Por exemplo, você pode usar main.rs, compilar e executá-lo com rustc main.rs && ./main.

Designadores

Os argumentos de uma macro são prefixados por um sinal de dólar $ e anotados com tipo com um designador:

macro_rules! create_function {
    // Esta macro recebe um argumento do designador `ident` e
    // cria uma função chamada `$func_name`.
    // O designador `ident` é usado para nomes de variáveis/funções.
    ($func_name:ident) => {
        fn $func_name() {
            // A macro `stringify!` converte um `ident` em uma string.
            println!("Você chamou {:?}()",
                     stringify!($func_name));
        }
    };
}

// Crie funções chamadas `foo` e `bar` com a macro acima.
create_function!(foo);
create_function!(bar);

macro_rules! print_result {
    // Esta macro recebe uma expressão do tipo `expr` e a imprime
    // como uma string junto com seu resultado.
    // O designador `expr` é usado para expressões.
    ($expression:expr) => {
        // `stringify!` converterá a expressão *como ela é* em uma string.
        println!("{:?} = {:?}",
                 stringify!($expression),
                 $expression);
    };
}

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

    print_result!(1u32 + 1);

    // Lembre-se que blocos também são expressões!
    print_result!({
        let x = 1u32;

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

Estes são alguns dos designadores disponíveis:

• block
• expr é usado para expressões
• ident é usado para nomes de variáveis/funções
• item
• literal é usado para constantes literais
• pat (padrão)
• path
• stmt (declaração)
• tt (árvore de tokens)
• ty (tipo)
• vis (qualificador de visibilidade)

Para uma lista completa, consulte a [Referência Rust].

Resumo

Parabéns! Você concluiu o laboratório de Designadores. Você pode praticar mais laboratórios no LabEx para aprimorar suas habilidades.