Macros Declarativas (`macro_rules!`)

Macros são uma forma de escrever código que escreve código! Elas são semelhantes a funções, mas operam sobre árvores sintáticas (a estrutura do seu código), e não sobre valores.

• Elas ajudam a abstrair código repetitivo.
• Permitem criar linguagens específicas de domínio (DSLs) dentro do Rust.
• São executadas em tempo de compilação, gerando código Rust comum antes da compilação.

As macros declarativas do Rust usam a palavra-chave macro_rules!. Elas definem um conjunto de regras que correspondem a padrões específicos de código Rust.

Pense nisso como correspondência de padrões para trechos de código. Quando o compilador encontra uma chamada de macro, ele tenta corresponder a entrada a uma das regras que você definiu.

Vamos criar uma macro muito simples que exibe uma saudação. Observe a palavra-chave macro_rules! e a sintaxe () => {}, que define uma regra sem padrão de entrada.

Experimente executar este exemplo:

Macros podem receber entradas usando "especificadores". Eles informam à macro que tipo de sintaxe Rust ela deve esperar capturar.

• $expr: uma expressão (por exemplo, 1 + 2, "hello")
• $ident: um identificador (por exemplo, nome de variável ou de função)
• $ty: um tipo (por exemplo, i32, String)
• $block: um bloco de código (por exemplo, { ... })
• ...e muitos outros!

Aqui está uma macro que recebe uma expressão ($e:expr) e exibe seu valor. O :expr é o especificador.

O $e capturado fica disponível para uso no corpo da macro. A macro stringify! converte a expressão em sua representação textual.

E se você quiser que uma macro receba vários argumentos do mesmo tipo? Você pode usar operadores de repetição: $()*.

• $(): o conteúdo interno é o padrão a ser repetido.
• *: zero ou mais repetições.
• +: uma ou mais repetições.
• Você também pode especificar um separador, como $(...),* para itens separados por vírgulas.

Vamos criar uma macro que recebe várias expressões separadas por vírgulas e exibe cada uma individualmente. Isso é útil para criar estruturas semelhantes a listas.

As macros do Rust são "higiênicas". Isso significa que as variáveis definidas dentro de uma macro não entrarão acidentalmente em conflito com variáveis externas, mesmo que tenham o mesmo nome.

Durante a expansão, o compilador renomeia elementos internamente para evitar efeitos colaterais indesejados, tornando as macros mais seguras e previsíveis.

Às vezes, as macros não são expandidas como você espera. O Rust oferece uma forma de visualizar o código expandido:

• Execute cargo expand (é necessário instalar a ferramenta cargo-expand)
• Use rustc --pretty expanded diretamente no seu arquivo de código-fonte.

Isso mostra o código Rust bruto gerado pela sua macro, o que é extremamente útil para depurar e compreender comportamentos complexos de macros!

Considere a seguinte definição de macro:

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

Qual das linhas a seguir seria compilada e usaria a macro make_tuple! com sucesso?

Nesta lição, você aprendeu sobre macros declarativas usando macro_rules!:

• Elas geram código em tempo de compilação, abstraindo padrões repetitivos.
• Usam correspondência de padrões para capturar entradas com base na sintaxe.
• Especificadores como $expr e $ident indicam que tipo de sintaxe esperar.
• Operadores de repetição como $()* tratam vários argumentos com separadores flexíveis.
• As macros são higiênicas, evitando conflitos acidentais de nomes.

Macros são uma ferramenta poderosa para reduzir código repetitivo e criar APIs flexíveis e ergonômicas em Rust!