Lição 46: Macros Declarativas (Sistema de Expansão)

1. Narrativa

O mecha Æther possui um sistema de expansão que permite criar novos comandos a partir de padrões existentes. As macros declarativas são como moldes de fabricação — você define um padrão e o compilador gera código repetitivo automaticamente. É o mecanismo por trás de println!, vec! e assert_eq!.

2. Conceito

Macros declarativas (macro_rules!) são sistema de metaprogramação do Rust:

• macro_rules! nome: Define uma macro declarativa
• Padrões (arms): ($arg:expr) => { ... } — casamento de padrões sobre tokens
• Fragmentos: expr, ident, ty, path, stmt, block, pat, meta, tt, item, lifetime, vis, literal
• Repetição: $($x),* — repete zero ou mais vezes; $(...),+ — uma ou mais
• Higiene: Macros não poluem o escopo do chamador

3. Requisitos

• Criar macros com macro_rules!
• Usar diferentes fragmentos (expr, ident, ty, tt)
• Usar repetição $(...),* e $(...),+
• Criar macros que geram funções e structs

4. Design de Dados

graph LR
    A[Macro Call] --> B[Pattern Match]
    B --> C[Token Substitution]
    C --> D[Expanded Code]

5. Diagrama de Fluxo

flowchart TD
    A[Chamar macro] --> B[Match padrão]
    B --> C{Encontrou arm?}
    C -->|Sim| D[Substituir $vars]
    D --> E[Expandir repetição]
    E --> F[Código gerado]
    C -->|Não| G[Erro de compilação]

6. Funções

Função	Descrição
duplicar_macro	Macro que duplica uma expressão
vetor_macro	Macro que cria Vec como vec!
soma_macro	Macro que soma números variádicos
mapa_macro	Macro que cria HashMap
imprimir_macro	Macro de debug como println!
comparar_macro	Macro de comparação customizada
contar_macro	Macro que conta argumentos
criar_vetor	Cria um Vec de i32 usando a vetor_macro
criar_mapa	Cria um HashMap de Strings usando a mapa_macro
somar_lista	Usa a soma_macro para somar uma lista
encontrar_maximo	Usa a comparar_macro para encontrar o máximo
contar_elementos	Usa a contar_macro para verificar comprimento

7. Exemplo

macro_rules! duplicar {
    ($x:expr) => { $x * 2 };
    ($x:expr, $y:expr) => { $x * 2 + $y * 2 };
}

assert_eq!(duplicar!(5), 10);
assert_eq!(duplicar!(3, 4), 14);

8. Missão

1. Estudar como duplicar_macro duplica expressões
2. Estudar como vetor_macro cria Vec como vec![]
3. Estudar como soma_macro soma números variádicos
4. Estudar como mapa_macro cria HashMap de pares
5. Estudar como imprimir_macro imprime com formato
6. Estudar como comparar_macro compara dois valores
7. Estudar como contar_macro conta argumentos recebidos
8. Implementar criar_vetor, criar_mapa, somar_lista, encontrar_maximo e contar_elementos. Lembre-se: macros declarativas operam em tokens de compile-time, então não podem receber dados de runtime. Apenas encontrar_maximo consegue usar comparar_macro! internamente (com variáveis); as demais devem ser implementadas com Rust padrão (iterators, Vec, HashMap)

9. Como Executar

cargo build
cargo test
cargo clippy -- -D warnings
cargo fmt --check

10. Dicas

• Macros são expandidas em tempo de compilação, não em runtime
• $x:expr casa uma expressão, $x:ident casa um identificador
• $(...),* repete zero ou mais; $(...),+ repete uma ou mais
• Use cargo expand para ver o código expandido
• Macros não podem acessar variáveis do escopo diretamente (higiene)