09/03/2026, 16:49 Rust e Python Decorators
Sou programador Python aprendendo Rust, tenha ótima
didática e faça correlação entre as linguagens, mostre
como o rust trabalha comSou programador Python
aprendendo Rust, tenha ótima didática e faça correlação
entre as linguagens, mostre como o rust trabalha com o
operdor #, exemplo:
#[tokio::main]
Pensou por 4 segundos
Claro. Em Rust, esse # não é um operador comum como em Python. No contexto de:
#[tokio::main]
async fn main() {
println!("Olá, mundo!");
}
Rust
esse #[] é uma attribute (atributo), e nesse caso específico está ligada a uma macro de
atributo.
Fazendo a ponte com Python
Como você vem de Python, pense assim:
Em Python
Você já viu algo parecido com:
@decorator
def func():
pass
Python Executar
Exemplo real:
[Link] 1/13
09/03/2026, 16:49 Rust e Python Decorators
@[Link]("/")
def home():
Python
return "Olá" Executar
O @algo em Python modifica o comportamento da função, classe, etc.
Em Rust
O equivalente conceitual mais próximo é:
#[alguma_coisa]
fn minha_funcao() {}
Rust
Ou seja:
em Python você usa @decorator
em Rust você usa #[atributo]
Então, para quem vem de Python, a melhor associação mental é:
#[...] em Rust lembra bastante @decorator em Python.
Mas há uma diferença importante:
em Python, decorators são mais diretamente funções que recebem e retornam outra
função
em Rust, attributes podem ser:
apenas metadados para o compilador
instruções especiais
macros que transformam código
O que significa #[tokio::main]
Vamos decompor:
#[tokio::main]
async fn main() {
println!("Olá, mundo!");
}
Rust
[Link] 2/13
09/03/2026, 16:49 Rust e Python Decorators
Esse atributo diz ao Rust:
“gere para mim a infraestrutura necessária para que essa função main assíncrona rode
dentro do runtime do Tokio.”
Problema que isso resolve
Em Rust, a função main tradicionalmente é síncrona:
fn main() {
println!("Olá");
}
Rust
Mas você quer usar async :
async fn main() {
println!("Olá");
}
Rust
Isso não funciona sozinho, porque uma função async retorna um Future , e esse
Future precisa de um executor/runtime para ser executado.
É aí que entra o Tokio.
O que o atributo faz por baixo dos panos
Esse código:
#[tokio::main]
async fn main() {
println!("Olá, mundo!");
}
Rust
é aproximadamente transformado em algo parecido com:
[Link] 3/13
09/03/2026, 16:49 Rust e Python Decorators
fn main() {
let runtime = tokio::runtime::Runtime::new().unwrap();
runtime.block_on(async {
println!("Olá, mundo!");
});
}
Rust
Correlação direta com Python async
Python
Em Python, quando você faz:
import asyncio
async def main():
print("Olá")
[Link](main())
o [Link](main()) cria e executa o loop assíncrono.
Rust com Tokio
Em Rust, #[tokio::main] faz um papel parecido com:
[Link](main())
Python Executar
Ou seja:
Python: [Link](...)
Rust: #[tokio::main]
Essa é uma analogia excelente para fixar.
Então o # em Rust é o quê exatamente?
O # aparece muito em combinações como:
[Link] 4/13
09/03/2026, 16:49 Rust e Python Decorators
#[alguma_coisa]
Rust
Isso representa um atributo.
Sintaxe geral
#[atributo]
item
Rust
Onde item pode ser:
função
struct
enum
módulo
campo
impl
crate inteira
Exemplos comuns de atributos em Rust
1. Derivação automática de traits
#[derive(Debug, Clone)]
struct Pessoa {
nome: String,
}
Rust
Aqui o compilador gera implementações automáticas.
Comparação com Python
Em Python isso lembra um pouco:
from dataclasses import dataclass
[Link] 5/13
09/03/2026, 16:49 Rust e Python Decorators
@dataclass
class Pessoa:
nome: str
Python Executar
Não é igual, mas a ideia de “gerar comportamento automaticamente” é parecida.
2. Ignorar aviso de compilador
#[allow(dead_code)]
fn funcao_nao_usada() {}
Rust
Isso diz ao compilador para não reclamar que a função não está sendo usada.
Em Python seria como se você tivesse uma anotação para silenciar linter, algo na linha de:
# noqa
Python Executar
ou configurações do flake8/pylint .
3. Testes
#[test]
fn meu_teste() {
assert_eq!(2 + 2, 4);
}
Rust
Esse atributo marca a função como teste.
Em Python, a ideia lembra o framework descobrir funções de teste, mas em Rust isso é
explícito via atributo.
4. Compilação condicional
[Link] 6/13
09/03/2026, 16:49 Rust e Python Decorators
#[cfg(target_os = "windows")]
fn so_no_windows() {
println!("Executando no Windows");
} Rust
Isso diz: compile essa função só no Windows.
Em Python, isso seria algo mais manual, como:
import sys
if [Link] == "win32":
...
Python Executar
Mas em Rust isso pode acontecer já em tempo de compilação.
Diferença entre #[] e #![]
Essa parte é importante.
#[...]
Aplica o atributo ao item logo abaixo.
Exemplo:
#[derive(Debug)]
struct Pessoa {
nome: String,
}
Rust
Aplica ao struct Pessoa .
#![...]
Aplica o atributo ao escopo externo, geralmente ao arquivo/crate inteiro.
Exemplo:
[Link] 7/13
09/03/2026, 16:49 Rust e Python Decorators
Rust
#![allow(unused_variables)]
Isso normalmente fica no topo do arquivo e afeta o módulo ou crate inteiro.
O #[tokio::main] é atributo ou macro?
Tecnicamente, ele é uma attribute macro.
Ou seja:
tem forma de atributo: #[...]
mas executa transformação de código como macro
Comparando com Python
Em Python, decorators também podem alterar bastante o comportamento da função.
Então, pensando didaticamente:
#[tokio::main] em Rust está mais próximo de um decorator poderoso
só que operando em tempo de compilação, não em tempo de execução como
normalmente ocorre em Python
Essa diferença é muito importante.
Tempo de compilação vs tempo de execução
Python
Decorators normalmente atuam quando o módulo é carregado/em runtime.
Rust
Attributes e macros frequentemente transformam o código antes do programa rodar,
durante a compilação.
Isso traz:
mais performance
mais segurança
mais checagem antecipada
[Link] 8/13
09/03/2026, 16:49 Rust e Python Decorators
Mas também deixa a linguagem mais rígida.
Exemplo prático lado a lado
Python
import asyncio
async def main():
print("Olá do Python")
[Link](main())
Rust
#[tokio::main]
async fn main() {
println!("Olá do Rust");
}
Rust
Leitura mental correta
Você pode ler assim:
“Use o runtime Tokio para executar essa função main assíncrona.”
Outro detalhe importante: ::
No trecho:
#[tokio::main]
Rust
o tokio::main significa:
tokio = crate/biblioteca
[Link] 9/13
09/03/2026, 16:49 Rust e Python Decorators
main = macro/atributo exportado por ela
Esse :: em Rust lembra:
acesso por namespace
algo próximo de módulo em Python
Comparação:
Python
[Link]
Python Executar
Rust
modulo::item
Rust
Então:
Python usa .
Rust usa :: para caminho de módulo/namespace
Resumo prático para fixar
Em Python
@decorator
def f():
pass
Python Executar
Em Rust
#[atributo]
fn f() {}
Rust
[Link] 10/13
09/03/2026, 16:49 Rust e Python Decorators
Como entender #[tokio::main] de forma simples
Pense assim:
#[] = atributo
tokio::main = atributo especial fornecido pela biblioteca Tokio
ele transforma sua async fn main() em uma fn main() normal que cria e roda o
runtime assíncrono
Regra mental que vai te ajudar muito
Sempre que você vir em Rust algo como:
#[alguma_coisa]
Rust
pergunte:
1. isso é um metadado do compilador?
2. isso está gerando código automaticamente?
3. isso está alterando como esse item será compilado?
Na maioria dos casos, a resposta será uma dessas.
Exemplo mais completo com Tokio
#[tokio::main]
async fn main() {
let resultado = busca_dados().await;
println!("{}", resultado);
}
async fn busca_dados() -> String {
"dados recebidos".to_string()
}
O que acontece aqui
main é assíncrona
busca_dados() retorna um future
[Link] 11/13
09/03/2026, 16:49 Rust e Python Decorators
.await espera a conclusão
#[tokio::main] garante que existe um runtime para tudo isso funcionar
Armadilha comum para quem vem de Python
Em Python, você consegue ser mais flexível e improvisar mais em runtime.
Em Rust, async sem runtime não anda.
Então:
em Python: async def + await + [Link](...)
em Rust: async fn + .await + runtime como Tokio
Sem runtime, não executa.
Conclusão
O # em #[tokio::main] não é um operador aritmético nem lógico. Nesse contexto, ele
faz parte da sintaxe de atributos em Rust.
A melhor correlação com Python é:
@decorator em Python
#[atributo] em Rust
E especificamente:
[Link](main()) em Python
#[tokio::main] async fn main() em Rust
Se quiser, no próximo passo eu posso te mostrar 5 exemplos práticos de atributos em
Rust comparando cada um com Python, incluindo #[derive] , #[test] , #[cfg] e #
[allow] .
Você gosta desta personalidade?
[Link] 12/13
09/03/2026, 16:49 Rust e Python Decorators
[Link] 13/13