Código limpo em Rust: escrevendo de forma elegante e eficiente

Por que código limpo em Rust não é um luxo, mas uma necessidade

Rust é uma linguagem que exige disciplina do desenvolvedor. O compilador aqui é rigoroso, mas justo: ele não perdoa descuidos com memória, mas oferece em troca uma velocidade e segurança incríveis. No entanto, para realmente liberar o potencial do Rust, não basta apenas fazer o código compilar. É preciso escrever código limpo — compreensível, sustentável e elegante.

Neste artigo, vamos explorar como escrever código limpo em Rust para que seu projeto não se transforme em um labirinto de blocos unsafe e genéricos confusos. Você aprenderá sobre princípios de nomenclatura, expressões idiomáticas de ownership, tratamento de erros e estruturação de código. Vamos lá!

1. Nomenclatura: fale a língua do Rust

A nomenclatura correta é metade do sucesso. Em Rust, existem convenções rigorosas, e violá-las é como um pano vermelho para um touro (especialmente em code review).

Regras básicas

\n
• snake_case para variáveis, funções, métodos e módulos.
\n
• PascalCase para tipos (struct, enum, trait).
\n
• SCREAMING_SNAKE_CASE para constantes e variáveis estáticas.
\n

Exemplo:

// Ruim\nlet UserName = "Alice";\nfn GetUserData() {}\nconst MAX_SIZE: u32 = 100;\n\n// Bom\nlet user_name = "Alice";\nfn get_user_data() {}\nconst MAX_SIZE: u32 = 100;

Evite abreviações (a menos que sejam óbvias)

Em vez de calc_avg(), é melhor escrever calculate_average(). Em vez de tmp, use temp_buffer. Rust incentiva a legibilidade, não a brevidade.

Dica: se você estiver escrevendo uma função que recebe um closure, use os nomes f, g ou closure — esta é uma prática comum.

2. Ownership e borrowing: seja amigo do compilador

O sistema de ownership é o coração do Rust. O código limpo respeita as regras de ownership e borrowing, sem tentar contorná-las com clone() ou Rc desnecessariamente.

Regra: prefira borrowing a ownership

Se uma função não precisa assumir a ownership, aceite uma referência &T ou uma referência mutável &mut T.

// Ruim: clone desnecessário\nfn process(data: Vec<i32>) {\n    let mut sum = 0;\n    for &val in &data {\n        sum += val;\n    }\n    println!("Sum: {}", sum);\n}\n\n// Bom: borrowing\nfn process(data: &[i32]) {\n    let mut sum = 0;\n    for &val in data {\n        sum += val;\n    }\n    println!("Sum: {}", sum);\n}

Evite clonagem excessiva

Se você precisar passar dados para vários lugares, use Rc (para cenários single-thread) ou Arc (para multi-thread). Mas não abuse: para casos simples, referências são suficientes.

3. Tratamento de erros: abandone o pânico

Em Rust, existem duas formas principais de tratar erros: panic! (erro irrecuperável) e Result<T, E> (recuperável). O código limpo usa Result sempre que possível. O pânico é o último recurso para situações truly excepcionais (como divisão por zero).

Use o operador ?

Esta é uma forma concisa de propagar o erro para cima. Em vez de match extensos, escreva:

use std::fs::File;\nuse std::io::Read;\n\nfn read_file(path: &str) -> Result<String, std::io::Error> {\n    let mut file = File::open(path)?;\n    let mut contents = String::new();\n    file.read_to_string(&mut contents)?;\n    Ok(contents)\n}

Crie seus próprios tipos de erro

Em vez de usar String como erro, defina uma enumeração:

#[derive(Debug)]\nenum MyError {\n    Io(std::io::Error),\n    Parse(std::num::ParseIntError),\n}\n\nimpl From<std::io::Error> for My