1.1 O trilema que Rust quebra

Historicamente você escolhia dois de três: seguro, rápido, sem coletor de lixo. C/C++ são rápidos e sem GC, mas inseguros (a maioria das CVEs críticas em software de sistema é corrupção de memória). Java/Go/C# são seguros e rápidos, mas com GC (pausas, uso de memória, sem controle fino). Rust entrega os três: a segurança é garantida pelo sistema de tipos e pelo borrow checker em tempo de compilação, com zero custo em runtime — não há GC, não há verificação de bounds onde o compilador prova que é seguro.

1.2 As garantias

Tudo isso sem runtime pesado. O custo é: você aprende a satisfazer o borrow checker, e alguns padrões (grafos, listas duplamente ligadas, cache mutável compartilhado) exigem ferramentas específicas (Módulo 6) ou unsafe encapsulado.

1.3 Onde Rust brilha

• Ferramentas de linha de comando: binário único, rápido, cross-compile fácil — ripgrep, fd, bat, uv, ruff, biome são Rust.
• Infraestrutura e sistemas: partes do Linux kernel, Android, Windows; navegadores (Servo, partes do Firefox); bancos (TiKV), proxies, service meshes (Linkerd2-proxy).
• WebAssembly: Rust é a linguagem com melhor tooling para WASM — no browser (jogos, editores, cripto) e server-side/edge (Cloudflare Workers, Fastly, plugins WASM).
• Serviços de latência crítica: onde pausas de GC ou p99 importam (Discord migrou serviços de Go para Rust por causa disso).
• Bibliotecas de performance embutidas em outras linguagens: extensões nativas de Python (via PyO3), Node (napi-rs), Ruby — o padrão "escreva o núcleo quente em Rust".
• Embedded / no_std: microcontroladores, firmware, sem sistema operacional.
• Blockchain / criptografia (correção e performance).

1.4 Quando NÃO Rust

• Prototipagem rápida / scripts — o ciclo "brigar com o compilador" pesa; Python/TS são mais ágeis.
• CRUD de negócio comum sem exigência de performance — o custo de desenvolvimento raramente compensa.
• Time sem tempo para a curva — Rust exige investimento de semanas antes de produtividade.
• Ecossistema imaturo para o seu domínio específico (GUI desktop, alguns SDKs de nuvem ainda são melhores em outras linguagens).
• ML/ciência de dados — é Python (embora Rust apareça na infra de inferência).

2.1 Ownership

Três regras:

1. Cada valor tem exatamente um dono (uma variável).
2. Quando o dono sai de escopo, o valor é liberado (chamada automática de drop) — determinístico, sem GC.
3. Só pode haver um dono por vez — atribuir ou passar por valor move a posse.

let s1 = String::from("olá");
let s2 = s1;              // MOVE: s1 não é mais válido
// println!("{s1}");     // ERRO de compilação: valor movido
println!("{s2}");          // ok

fn consome(s: String) { /* s é dono; ao fim da função, drop(s) */ }
consome(s2);              // s2 movido para dentro; não usável depois

• Tipos que implementam Copy (inteiros, bool, char, tuplas de Copy) são copiados, não movidos — o velho valor continua válido.
• .clone() faz uma cópia profunda explícita (custa; por isso não é implícito).

2.2 Borrowing (referências)

Para usar um valor sem tomar posse, você o empresta com uma referência:

fn tamanho(s: &String) -> usize { s.len() }   // &String: empréstimo imutável

let s = String::from("olá");
let n = tamanho(&s);      // empresta; s continua dono
println!("{s} tem {n}");   // s ainda válido

fn maiuscula(s: &mut String) { s.push_str("!"); }  // &mut: empréstimo mutável

let mut v = vec![1, 2, 3];
let r = &v[0];              // empréstimo imutável ativo
// v.push(4);              // ERRO: não pode mutar v enquanto r existe
println!("{r}");            // r usado aqui
v.push(4);                 // ok: r não é mais usado (non-lexical lifetimes)

2.3 Lifetimes

Um lifetime é o intervalo em que uma referência é válida. O compilador rastreia isso e garante que nenhuma referência sobreviva ao dado. Na maioria dos casos ele infere (elisão); às vezes você anota:

// "a referência retornada vive tanto quanto o menor dos dois inputs"
fn maior<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

// isto NÃO compila — retornaria referência a um valor que morre:
// fn dangle() -> &String { let s = String::from("x"); &s }  // s morre ao fim

Lifetimes não mudam quanto tempo o dado vive — só descrevem relações para o compilador verificar. São a parte mais estranha no começo e a que "clica" com prática.

2.4 Stack, heap e String vs &str

• String: dona, na heap, cresce; &str: visão emprestada (slice) de texto UTF-8, não possui nada. Aceite &str em parâmetros (mais flexível), guarde String em structs quando precisa de posse.
• Vec<T> (dona, heap) vs &[T] (slice emprestado) — mesma relação.

3.1 Enums são tipos-soma de verdade

enum Evento {
    Clique { x: i32, y: i32 },   // variante com campos nomeados
    Tecla(char),                  // variante com dado posicional
    Fechar,                        // variante sem dado
}

fn tratar(e: Evento) {
    match e {
        Evento::Clique { x, y } => println!("clique em {x},{y}"),
        Evento::Tecla(c) => println!("tecla {c}"),
        Evento::Fechar => println!("fechando"),
    }   // match é EXAUSTIVO: esqueceu uma variante? erro de compilação
}

Diferente dos enums "lista de constantes" de C/Java, os enums de Rust carregam dados por variante — são tipos algébricos. Combinados com match exaustivo, modelam estados impossíveis de representar errado.

3.2 Sem null: Option<T>

enum Option<T> { Some(T), None }   // da stdlib

let achado: Option<&Usuario> = usuarios.iter().find(|u| u.id == id);
match achado {
    Some(u) => println!("{}", u.nome),
    None => println!("não encontrado"),
}
// o compilador NÃO deixa você usar o valor sem tratar o None

Não existe null. "Pode não haver valor" é Option<T>, e o compilador força você a lidar com o None. A classe inteira de "null pointer exception" desaparece.

3.3 Sem exceções: Result<T, E> e ?

enum Result<T, E> { Ok(T), Err(E) }

fn ler_config(path: &str) -> Result<Config, std::io::Error> {
    let texto = std::fs::read_to_string(path)?;   // ? : se Err, retorna o Err daqui
    let cfg = parse(&texto)?;
    Ok(cfg)
}

Erros recuperáveis são valores Result. O operador ? propaga o erro para cima (early return) sem try/catch, e a assinatura da função declara o que pode falhar. Detalhes no Módulo 4.

3.4 Traits (as "interfaces" de Rust)

trait Area {
    fn area(&self) -> f64;
    fn descricao(&self) -> String {   // método com implementação padrão
        format!("área = {:.2}", self.area())
    }
}

struct Circulo { r: f64 }
impl Area for Circulo {
    fn area(&self) -> f64 { std::f64::consts::PI * self.r * self.r }
}

• Traits definem comportamento compartilhado; impl Trait for Tipo implementa.
• Coherence / orphan rule: você só pode implementar um trait para um tipo se possui o trait ou o tipo — evita conflitos entre crates.
• Traits famosos da stdlib: Debug, Clone, PartialEq, Iterator, From/Into, Display, Default — muitos deriváveis com #[derive(...)].

3.5 Genéricos e trait bounds

// "T qualquer, desde que seja comparável por ordem"
fn maior<T: PartialOrd>(lista: &[T]) -> &T {
    let mut m = &lista[0];
    for x in lista { if x > m { m = x; } }
    m
}

• Monomorfização: o compilador gera uma versão especializada por tipo concreto usado — zero custo em runtime (vs dynamic dispatch).
• Static dispatch (impl Trait / genérico) vs dynamic dispatch (&dyn Trait / Box<dyn Trait>, via vtable — flexível, custo pequeno de indireção).
• where clauses para bounds complexos legíveis.

4.1 Recuperável (Result) vs irrecuperável (panic!)

4.2 Propagação com ? e conversão de erro

fn carregar() -> Result<Dados, MeuErro> {
    let raw = std::fs::read_to_string("dados.json")?;  // io::Error -> MeuErro via From
    let d: Dados = serde_json::from_str(&raw)?;         // serde_json::Error -> MeuErro
    Ok(d)
}

O ? faz duas coisas: se Ok(v), extrai v; se Err(e), converte e para o tipo de erro da função (via trait From) e faz return Err(...). É por isso que definir From<io::Error> for MeuErro (ou usar thiserror) faz o ? "simplesmente funcionar".

4.3 thiserror (bibliotecas) e anyhow (aplicações)

// EM BIBLIOTECA: erro tipado, para o chamador ramificar
use thiserror::Error;

#[derive(Error, Debug)]
pub enum RepoError {
    #[error("pedido {0} não encontrado")]
    NotFound(String),
    #[error("falha de banco")]
    Db(#[from] sqlx::Error),      // gera From automaticamente -> ? funciona
}

// EM APLICAÇÃO (main, handlers): não importa o tipo exato, só o contexto
use anyhow::{Context, Result};

fn run() -> Result<()> {
    let cfg = ler_config().context("carregar config")?;
    // erro final: "carregar config: arquivo dados.json não existe"
    Ok(())
}

4.4 unwrap, expect, e as alternativas

• .unwrap() — pega o valor ou panic!. Ok em testes/protótipo; em produção, sinal de código a revisar.
• .expect("mensagem") — como unwrap mas com mensagem; use quando você provou que não falha ("regex literal é sempre válida").
• .unwrap_or(default), .unwrap_or_else(|| ...), .unwrap_or_default() — fallback sem panic.
• if let / let ... else / match — tratamento explícito.
• Configurar panic = "abort" no perfil release para binário menor e sem unwinding (comum em embedded/CLI).

5.1 Coleções principais

5.2 Iterators: lazy e zero-cost

let nums = vec![1, 2, 3, 4, 5, 6];

let soma_pares_ao_quadrado: i32 = nums
    .iter()                       // &i32
    .filter(|&&x| x % 2 == 0)      // nada roda ainda (lazy)
    .map(|&x| x * x)
    .sum();                       // consumidor: AGORA a cadeia executa, num passo só
// resultado: 4 + 16 + 36 = 56 — compilado tão rápido quanto o loop manual

• Lazy: adaptadores (map, filter, take, zip, enumerate...) não fazem nada até um consumidor (collect, sum, for, fold, find, count).
• Zero-cost: a cadeia inteira compila para um único loop sem alocações intermediárias — não há penalidade por escrever no estilo funcional.
• Três formas de iterar: .iter() (&T), .iter_mut() (&mut T), .into_iter() (T, consome a coleção).
• .collect::<Vec<_>>() ou .collect::<Result<Vec<_>, _>>() (curto-circuita no primeiro erro — idioma muito útil).

5.3 Closures e os traits Fn

let fator = 3;
let multiplica = |x: i32| x * fator;   // captura `fator` do ambiente
println!("{}", multiplica(10));           // 30

• O compilador infere o trait mais permissivo possível. move força captura por valor (essencial ao passar para outra thread).
• Passar closures: genérico fn f<F: Fn(i32) -> i32>(g: F) (static dispatch) ou Box<dyn Fn(i32) -> i32> (dynamic, quando precisa guardar em struct/coleção).

5.4 Padrões idiomáticos

// agrupar
let mut por_categoria: HashMap<&str, Vec<&Produto>> = HashMap::new();
for p in &produtos {
    por_categoria.entry(p.categoria.as_str()).or_default().push(p);
}

// transformar com early-return de erro
let numeros: Result<Vec<i32>, _> = linhas.iter().map(|l| l.parse::<i32>()).collect();

6.1 Box<T>

Aloca T na heap; o Box é o dono único. Usos: tipos recursivos (enum No { Folha, Ramo(Box<No>) } — o compilador precisa de um tamanho conhecido), mover um valor grande sem copiar, e Box<dyn Trait> para dynamic dispatch / apagar o tipo concreto.

6.2 Rc<T> e Arc<T> — posse compartilhada

use std::rc::Rc;

let config = Rc::new(Config::carregar());
let a = Rc::clone(&config);   // +1 no contador; NÃO copia a Config
let b = Rc::clone(&config);
// a Config é liberada quando o último Rc sai de escopo

• Rc<T>: contagem de referências, single-thread. Vários donos de leitura; o valor vive enquanto houver um Rc.
• Arc<T>: o mesmo, mas atômico — seguro para compartilhar entre threads (Módulo 7). Custa um pouco mais.
• Ambos dão acesso imutável. Para mutar o conteúdo compartilhado, combine com interior mutability.
• Ciclos de Rc vazam memória (o contador nunca chega a zero) — quebre com Weak<T>.

6.3 Interior mutability: Cell, RefCell, Mutex

Às vezes você precisa mutar um valor através de uma referência imutável (&T) — por exemplo, um cache dentro de um método &self. As regras de borrow passam a ser checadas em runtime:

use std::cell::RefCell;

struct Cache { dados: RefCell<HashMap<String, String>> }
impl Cache {
    fn get(&self, k: &str) -> Option<String> {   // &self, mas muta o interior
        if let Some(v) = self.dados.borrow().get(k) { return Some(v.clone()); }
        let v = calcular(k);
        self.dados.borrow_mut().insert(k.to_string(), v.clone());
        Some(v)
    }
}

6.4 Os padrões combinados

• Rc<RefCell<T>>: posse compartilhada + mutação, single-thread. O padrão para grafos, árvores com pais, observadores. Cuidado com panics de borrow e com ciclos.
• Arc<Mutex<T>>: a versão multi-thread — estado compartilhado entre threads com bloqueio.
• Arc<RwLock<T>>: quando há muito mais leitura que escrita.

6.5 Deref e Drop

• Deref: faz um tipo se comportar como uma referência ao que ele contém (Box<T>, Rc<T>, String→&str). É o que permite chamar métodos de T num Box<T>.
• Drop: código a rodar quando o valor é liberado (fechar arquivo, liberar lock, log). É determinístico — roda no fim do escopo, ordem inversa da declaração. É o RAII de C++, garantido.

7.1 Threads e o porquê de "fearless"

use std::{sync::{Arc, Mutex}, thread};

let contador = Arc::new(Mutex::new(0));
let mut handles = vec![];
for _ in 0..10 {
    let c = Arc::clone(&contador);
    handles.push(thread::spawn(move || {   // move: a thread toma posse do que captura
        let mut n = c.lock().unwrap();
        *n += 1;
    }));
}
for h in handles { h.join().unwrap(); }
println!("{}", *contador.lock().unwrap());   // 10, sempre

7.2 Paralelismo de dados com rayon

use rayon::prelude::*;

let soma: u64 = numeros.par_iter().map(|&x| caro(x)).sum();
// troca .iter() por .par_iter() e a stdlib distribui em todos os cores.
// o borrow checker garante que a paralelização é segura.

rayon é a forma mais fácil de ganhar paralelismo: em cargas CPU-bound "embaraçosamente paralelas" (processar cada item independente), muitas vezes é só trocar o iterator. Usa um pool de threads com work-stealing por baixo.

7.3 async/await

async fn buscar_usuario(id: u64) -> Result<Usuario> {
    let resp = client.get(&url(id)).send().await?;   // suspende aqui, não bloqueia a thread
    let u = resp.json().await?;
    Ok(u)
}

// concorrência: dois fetches ao mesmo tempo
let (a, b) = tokio::join!(buscar_usuario(1), buscar_usuario(2));

• async fn retorna um Future — uma computação que ainda não rodou. Ela só progride quando um runtime (tokio, o dominante; async-std, smol) a executa e faz poll.
• Zero-cost: o compilador transforma a async fn numa máquina de estados; não há alocação por await, sem "green thread" pesada.
• Escala para centenas de milhares de conexões concorrentes numa mão-cheia de threads do SO — o modelo para servidores de rede I/O-bound.
• tokio::spawn para tarefas concorrentes; select! para esperar a primeira de várias; canais async (tokio::sync::mpsc).

7.4 O "function coloring" e quando async

8.1 Cargo

• cargo new/init, cargo build/run/test/bench, cargo add, cargo doc --open.
• Cargo.toml (manifesto) + Cargo.lock (versões exatas — commite em binários, opcional em libs).
• Workspaces: vários crates no mesmo repositório com Cargo.lock e target/ compartilhados — o padrão para projetos médios/grandes ([workspace] members = [...]).
• Features: flags de compilação opcionais ([features]) para ligar/desligar partes de um crate e suas dependências; default = [...]; cuidado com feature unification.
• Perfis: [profile.release] com opt-level = 3, lto = true, codegen-units = 1, panic = "abort", strip = true — binário menor e mais rápido, build mais lento.

8.2 Qualidade

/// Soma dois números.
/// ```
/// assert_eq!(minha_crate::soma(2, 3), 5);   // este exemplo É um teste
/// ```
pub fn soma(a: i32, b: i32) -> i32 { a + b }

8.3 Cross-compilation

rustup target add x86_64-unknown-linux-musl e cargo build --target .... Com o target musl você gera um binário totalmente estático (roda em qualquer Linux, imagem Docker FROM scratch). Ferramentas: cross (usa Docker para os toolchains), cargo-zigbuild. Rust facilita entregar um binário por plataforma.

8.4 unsafe

unsafe não desliga o borrow checker. Ele só libera cinco superpoderes que o compilador não consegue verificar: desreferenciar ponteiro cru (*const T/*mut T), chamar função unsafe (inclui FFI), acessar/mutar static mut, implementar um trait unsafe, e acessar campos de union.

• O contrato: dentro de um bloco unsafe, você garante as invariâncias que o compilador garantiria. Um bug ali pode causar UB (undefined behavior) em qualquer lugar.
• O padrão: encapsular o unsafe mínimo numa API segura (a stdlib faz isso o tempo todo — Vec usa unsafe por dentro, mas você o usa 100% seguro).
• Quando: FFI (chamar C), estruturas de dados que o borrow checker não expressa, otimizações provadas, no_std/embedded, SIMD manual.
• Verificação: Miri (interpretador que detecta UB), cargo +nightly miri test.
• Regra: se você não precisa de unsafe, não use. A grande maioria do código de aplicação nunca escreve um bloco unsafe.

9.1 CLIs

• clap (com derive): parsing de argumentos declarativo — subcomandos, flags, validação, help e autocompletar gerados.
• anyhow para erros (Módulo 4), indicatif (barras de progresso), console/owo-colors (cor), ratatui (TUIs interativas).
• Configuração: config / figment; directories para paths de config por SO.
• Por que Rust em CLI: binário único sem runtime, arranque instantâneo, cross-compile, e o ecossistema já provou (ripgrep, fd, bat, delta, starship, uv, ruff).

use clap::Parser;

#[derive(Parser)]
#[command(version, about)]
struct Args {
    /// arquivo de entrada
    input: String,
    /// número de threads
    #[arg(short, long, default_value_t = 4)]
    jobs: usize,
}

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    // ...
    Ok(())
}

9.2 WebAssembly

Rust tem o melhor tooling de WASM de qualquer linguagem: sem GC para embarcar, binários pequenos, e wasm-bindgen resolve a ponte com JS. É um dos motivos mais fortes para aprender Rust hoje.

9.3 Serviços web

• axum (sobre hyper + tower): o framework mais recomendado — extractors tipados, middleware via tower, integração tokio. Alternativas: actix-web (muito rápido, ator-based), poem, rocket (mais "mágico").
• tower: abstração de "serviço" (Request -> Future<Response>) — timeout, retry, rate limit, load balance como camadas reutilizáveis.
• Banco: sqlx (async, checa SQL em compile-time contra o schema), sea-orm, diesel (síncrono, ORM maduro).
• Observabilidade: tracing (spans estruturados) + tracing-subscriber; OpenTelemetry via opentelemetry.
• Por que: p99 previsível (sem GC), uso de memória baixo, e o compilador pega classes inteiras de bug antes do deploy. Discord, AWS, Cloudflare, Fly.io rodam serviços Rust em produção crítica.

9.4 FFI: Rust dentro de outras linguagens

O padrão dominante: mantenha a aplicação na linguagem de alto nível e reescreva só o núcleo quente em Rust, exposto como extensão nativa. Ganho de 10–100× no trecho crítico sem reescrever tudo.

9.5 no_std e embedded (panorama)

#![no_std] remove a biblioteca padrão (que assume um SO), deixando o core — para microcontroladores e firmware. Ecossistema: embassy (async em embedded), embedded-hal (abstração de hardware), defmt (logging eficiente), Rust oficialmente suportado em partes do kernel Linux. É um nicho crescente com pouca concorrência de talento.

10.1 Onde Rust contrata

10.2 Roadmap de estudo (10–12 semanas — a curva é real)

10.3 Banco de perguntas de entrevista (com a resposta que aprova)

10.4 Projetos de portfólio que geram entrevista

1. Uma CLI de verdade (âncora): algo útil (um formatador, um analisador de logs, um cliente de API) com clap, tratamento de erro com anyhow, testes + doctests, CI com fmt/clippy/nextest, e releases cross-platform. README com as decisões.
2. Estrutura de dados não trivial: um LRU cache, um trie, ou um pequeno interpretador — mostrando que você modela ownership (arena/índices vs Rc<RefCell>) conscientemente.
3. WASM no browser: um módulo Rust (parser, cripto, processamento de imagem) exposto via wasm-bindgen, com um demo e um benchmark vs a versão JS.
4. Serviço axum: API com sqlx, tracing, testes de integração, Dockerfile scratch, métricas.
5. Extensão nativa: um núcleo quente de um programa Python/Node reescrito em Rust via PyO3/napi-rs, com o "antes/depois" de performance.
6. Contribuições: issues "good first issue" em crates populares; resolver os Rustlings/Advent of Code em Rust e publicar.

10.5 Fontes para continuar

• Oficial: "The Rust Programming Language" ("The Book"), "Rust by Example", Rustlings (exercícios), o "Rust Reference" e o "Nomicon" (para unsafe).
• Livros: Programming Rust (Blandy, Orendorff, Tindall) — o mais completo; Rust for Rustaceans (Jon Gjengset) — nível intermediário→avançado, essencial para subir de nível; Rust Atomics and Locks (Mara Bos) para concorrência a fundo.
• Async: "Asynchronous Programming in Rust" (o livro oficial), a doc do tokio, o blog de Alice Ryhl.
• Prática: o canal do YouTube de Jon Gjengset ("Crust of Rust"); ler o código de ripgrep ou de um crate médio; this-week-in-rust para acompanhar o ecossistema.