Macros declarativas em Rust (macro_rules!)

Elemar Júnior

Quem programou com C/C++, com certeza, em algum momento, se deparou com a necessidade/possibilidade de escrever macros. Trata-se de um recurso útil mas que em C/C++, frequentemente, se converte em “dor de cabeça”.

A linguagem Rust incentiva a criação de macros (rotinas executadas durante a compilação) como forma de melhorar ainda mais a performance de nossas aplicações. Entretanto, em Rust, as macros são mais fáceis de criar e de entender do que em C++.

Todas as vezes que vemos a chamada para uma “aparente” função cujo o nome encerra com uma exclamação (!), estamos, de fato, instruindo o compilador a executar uma macro durante o processo de compilação.

Talvez, a macro mais utilizada, em Rust, seja println!.

use std::io;

fn main() {
    println!("Enter a name:");

    let mut name = String::new();

    io::stdin().read_line(&mut name)
        .expect("Failed to read line");

    println!("Hello, {}", name);
}

Graças ao poder das macros Rust processa a interpolação durante a compilação. Logo, o código executável acaba sendo bem mais limpo, performático e objetivo.

Podemos entender macros como “código que escreve código”.

Nossa primeira macro em Rust

Para que possamos entender melhor como macros em Rust funcionam, comecemos com um exemplo bem simples. A sintaxe de Rust para definição de macros declarativas é um pouco exótica, mas muito poderosa.

macro_rules! hello {
    () => { println!("Hello from Macros World"); }
}

fn main() {
    hello!()
}

No exemplo acima, a “chamada” para a macro hello! é substituída, durante a compilação, pela instrução que chama (a também macro) println!. A macro hello! não existe no código executável.

Observe como a própria definição de macro, em Rust, é feita através de uma macro (macro_rules!)

Macros e Pattern matching

macro_rules permite que definamos diferentes padrões para fazer a substuição do código de maneira mais apropriada.

É como se pudéssemos definir sobrecargas para as macros que estamos escrevendo.

macro_rules! hello {
    () => { 
        println!("Hello, World"); 
    };
    ($x:expr) => {
        println!("Hello, {}", $x);
    }
}

fn main() {
    hello!();
    hello!("Elemar");
}

No exemplo acima, a primeira “chamada” para a macro hello! é substituiída por um print! de “Hello World” (primeiro padrão). A segunda, por um print com concatenação (segundo padrão).

Novamente, a utilização de macros nos permite escrever código expressivo e leve.

Macros, Pattern matching e recursão

Rust permite que macros sejam chamadas recursivamente.

macro_rules! hello {
    () => { 
        println!("Hello, World"); 
    };

    ($x:expr) => {
        println!("Hello, {}", $x);
    };

    ($head:expr $(, $tail:expr)+) => {
        hello!($head); 
        hello!($($tail),*);
    }
}

fn main() {
    hello!();
    hello!("Elemar");
    hello!("Gabriel", "Otávio");
    hello!(1, 2, 3, 4, 5);
}

No exemplo acima, o terceiro pattern aceita um número variável de argumentos e usa recursão para garantir que todos os valores sejam devidamente processados.

Em tempo de execução não há nenhum laço ou recursão. Afinal,como  todas as chamadas de macro são processadas pelo compilador e o código final acaba sendo apenas aquele “emitido” pela execução dessas macros (Por exemplo, a chamada hello!(1, 2, 3, 4, 5); se converte em cinco chamadas distintas e simples para a macro println!

Usando macros para especializar Rust

Rust permite que definamos palavras chaves para serem consideradas no pattern matching. Essa ideia simples permite implementações poderosas de linguagens específicas de domínio.

macro_rules! printer {
    (print $e:expr) => {
        println!("Just {}", $e);
    };
    (print twice $e:expr) => {
        println!("First : {}", $e);
        println!("Second: {}", $e);
    }
}

fn main() {
    printer!(print "Elemar");
    printer!(print twice "Elemar Jr");
}

No exemplo acima, temos dois patterns para a macro printer!. O primeiro, faz a substituição do código por uma chamada simples de println! e o segundo faz uma substituição por duas chamadas. Perceba, entretanto, que print print twice não estão definidos na linguagem Rust – são “inovações” da nossa macro.

Por enquanto… era isso!

Macros são essenciais para a escrita de código expressivo e econômico. Rust oferece recursos poderosos para definição de macros e as utiliza de maneira intensa. Entretanto, diferente de C++, as macros estão integradas ao processo de compilação e, quando geram erros, estes são bem detectados pelo compilador e são apresentados em linguagem simples e direta.

O objetivo desse post não era mostrar como escrever macros em Rust. Em vez disso, nosso desejo era mostrar algumas potencialidades dessa feature.

Você já utilizou macros em Rust? Tem alguma contribuição para o conteúdo que apresentamos? Compartilhe suas opiniões conosco nos comentários.

Compartilhe este insight:

Comentários

Participe deixando seu comentário sobre este artigo a seguir:

Subscribe
Notify of
guest
0 Comentários
Inline Feedbacks
View all comments

AUTOR

Elemar Júnior
Fundador e CEO da EximiaCo atua como tech trusted advisor ajudando empresas e profissionais a gerar mais resultados através da tecnologia.

NOVOS HORIZONTES PARA O SEU NEGÓCIO

Nosso time está preparado para superar junto com você grandes desafios tecnológicos.

Entre em contato e vamos juntos utilizar a tecnologia do jeito certo para gerar mais resultados.

Insights EximiaCo

Confira os conteúdos de negócios e tecnologia desenvolvidos pelos nossos consultores:

Arquitetura de Dados

Insights de um DBA na análise de um plano de execução

Especialista em performance de Bancos de Dados de larga escala
Arquitetura de Software

Estratégias para modernização do legado

Desenvolvedor .NET/NodeJs e especialista em Kafka com experiência em startups e grandes empresas
Infraestrutura e Nuvem

Migração para a nuvem, mais do que mudança tecnológica, implica em mudança da cultura organizacional

Engenheiro de nuvem, arquiteto de software e especialista em Containers e Devops

Acesse nossos canais

Simplificamos, potencializamos e aceleramos resultados usando a tecnologia do jeito certo

EximiaCo 2022 – Todos os direitos reservados

0
Queremos saber a sua opinião, deixe seu comentáriox
()
x

Macros declarativas em Rust (macro_rules!)

Para se candidatar nesta turma aberta, preencha o formulário a seguir:

Condição especial de pré-venda: R$ 14.000,00 - contratando a mentoria até até 31/01/2023 e R$ 15.000,00 - contratando a mentoria a partir de 01/02/2023, em até 12x com taxas.

Tenho interesse nessa capacitação

Para solicitar mais informações sobre essa capacitação para a sua empresa, preencha o formulário a seguir:

Tenho interesse em conversar

Se você está querendo gerar resultados através da tecnologia, preencha este formulário que um de nossos consultores entrará em contato com você:

O seu insight foi excluído com sucesso!

O seu insight foi excluído e não está mais disponível.

O seu insight foi salvo com sucesso!

Ele está na fila de espera, aguardando ser revisado para ter sua publicação programada.

Tenho interesse em conversar

Se você está querendo gerar resultados através da tecnologia, preencha este formulário que um de nossos consultores entrará em contato com você:

Tenho interesse nessa solução

Se você está procurando este tipo de solução para o seu negócio, preencha este formulário que um de nossos consultores entrará em contato com você:

Tenho interesse neste serviço

Se você está procurando este tipo de solução para o seu negócio, preencha este formulário que um de nossos consultores entrará em contato com você:

× Precisa de ajuda?