Imersão Rust

Descubra onde cada valor de Rust mora — pilha ou heap —, o que um header de String realmente guarda e por que len e capacity contam histórias diferentes.

A regra que define Rust: cada valor tem um único dono. Veja o que um move realmente copia, decodifique seu primeiro E0382 e entenda por que double free não compila.

Por que um i32 sobrevive à atribuição e uma String não: o trait Copy, o custo real de um clone e o critério para decidir entre mover, copiar e clonar.

Chamar uma função move a posse para dentro; retornar move para fora. Aprenda a devolver ownership, o padrão da tupla — e por que ele pede uma ferramenta melhor.

Quando exatamente um valor morre em Rust: escopo, ordem inversa de drop, o trait Drop e o padrão RAII que fecha arquivos e solta locks sem você escrever uma linha.

Aprenda a ler um valor sem tomar posse dele: como o & cria empréstimos compartilhados, por que vários leitores podem coexistir e o que o erro E0505 protege.

Integre ownership, moves, empréstimos compartilhados e drop em um único modelo de pilha e heap.

Entenda por que o &mut exige exclusividade total, como decodificar os erros E0502 e E0499 e como o compilador encerra empréstimos no último uso.

Aprenda a emprestar pedaços: como &str e &[T] funcionam por dentro como par (ponteiro, comprimento), o que os ranges fatiam e por que temporários derrubam referências (E0716).

Decodifique o E0106 do exemplo longest, aprenda as três regras de elisão que escondem lifetimes do dia a dia, entenda o 'static e saiba quando reestruturar em vez de anotar.

Aprenda a agrupar dados em structs com campos nomeados, structs de tupla e unit structs, e entenda update syntax, ownership de campos e moves parciais.

Organize comportamento em blocos impl, diferencie funções associadas de métodos e escolha entre &self, &mut self e self sem esconder ownership.

Modele alternativas com enums cujas variantes carregam payloads diferentes, entenda ownership dos dados internos e processe cada forma com match.

Represente ausência com Option<T>, processe Some e None com map, and_then e unwrap_or, e empreste valores internos sem mover o container.

Use match como expressão exaustiva, desestruture enums, structs e tuplas, aplique guards e bindings e decodifique o diagnóstico E0004.

Aplique patterns focados com if let, while let, let else, matches! e bindings @, e saiba quando manter um match exaustivo.

Combine structs, enums e patterns em uma máquina de estados de pedidos que carrega dados obrigatórios e remove estados inválidos do modelo.

Defina traits, implemente métodos obrigatórios e padrão, escolha receptores self e entenda as regras de coerência do Rust.

Implemente Debug e Display com intenção, modele igualdade com PartialEq e Eq e saiba quando derive preserva a semântica do tipo.

Escreva funções, structs e enums genéricos, entenda monomorfização e escolha um ou vários parâmetros de tipo com intenção.

Use trait bounds, múltiplas capacidades, cláusulas where e impls condicionais para dizer ao compilador o que um tipo genérico pode fazer.

Compare impl Trait e dyn Trait, entenda dispatch estático e dinâmico e leia um trait object como data pointer mais vtable pointer conceituais.

Implemente From e TryFrom, use Into e TryInto por blanket impl e escolha entre conversões infalíveis e validação explícita.

Entenda o código gerado por derive, as condições legais de Copy, a semântica de ownership e por que recursos com Drop exigem move ou Clone explícito.

Escolha entre panic! e Result com base no que o chamador pode fazer, trate índices e parse sem dogmas e leia um backtrace de panic.

Leia Result<T, E> como um contrato exaustivo, use match e combinadores sem apagar a falha e diferencie erro de ausência com Option.

Use ? para retorno antecipado em Result e Option, entenda a conversão por From e decodifique o E0277 quando o contexto de retorno é incompatível.

Modele falhas com um enum, implemente Display e std::error::Error, preserve a causa em source e permita decisões por variante.

Entenda o que thiserror gera para enums tipados, o que anyhow acrescenta em aplicações e como os dois preservam Display, From, source e contexto.

Combine parse, validação, domínio e I/O com erros tipados na biblioteca, contexto na aplicação e um único relatório na borda externa.

Entenda o header de Vec, a diferença entre len e capacity, quando push pode realocar e como get e o borrow checker protegem acessos.

Use HashMap com ownership explícito, buscas emprestadas, get_mut e entry, sem depender da ordem de iteração ou do layout interno.

Diferencie String e &str, conte bytes e valores escalares UTF-8, recorte somente em fronteiras válidas e reconheça conversões que alocam.

Entenda capturas por borrow, borrow mutável e move, e leia Fn, FnMut e FnOnce como capacidades inferidas pelo uso dos valores capturados.

Implemente e consuma Iterator, acompanhe o estado de next, diferencie Iterator de IntoIterator e entenda laziness e abstração sem custo adicional.

Combine map, filter, filter_map, flat_map, enumerate, zip, take, fold e collect com tipos, ownership e casos de borda explícitos.

Refatore loops para iterators sem mudar semântica, preserve curto-circuito e erros, controle efeitos colaterais e reconheça quando o loop é mais claro.

Use Box para colocar um valor no heap, dar tamanho conhecido a tipos recursivos e manter um único dono sem coleta de lixo.

Compartilhe ownership em uma thread com Rc, entenda contagens forte e fraca e evite confundir clone da handle com clone do valor.

Use RefCell para verificar em runtime a regra de empréstimo da própria célula, controlar guards e escolher entre panic e Result.

Combine Rc e RefCell para estado mutável compartilhado em uma thread, controle guards, quebre ciclos com Weak e reconheça os limites.

Escolha entre valor direto, empréstimo, Box, Rc, RefCell e combinações, com critérios de ownership, mutação, threads, custo e ciclos.

Crie threads do sistema, transfira ownership com closures move, recupere resultados com join e trate panics sem supor uma ordem de execução.

Transfira ownership por channels mpsc, coordene vários produtores, feche o fluxo corretamente e aplique backpressure com sync_channel.

Compartilhe ownership com Arc, proteja mutação com Mutex, limite seções críticas e trate poison somente após validar a invariável.

Entenda Send e Sync como unsafe auto traits, leia bounds de APIs concorrentes e explique por que Rc e RefCell falham entre threads.

Monte um worker pool std-only com backpressure, shutdown, joins, resultados e panics; reconheça limites do Receiver compartilhado e evite deadlocks.

Entenda como async cria uma Future, como await pode suspender e como poll, Pending, Waker e Ready formam o trabalho cooperativo.

Configure o Tokio, execute tarefas assíncronas e separe I/O bloqueante, trabalho curto bloqueante e processamento sustentado de CPU.

Combine Futures com join!, escolha a primeira com select!, use tarefas Tokio e proteja operações contra cancelamento parcial.

Desfaça Result aninhado, preserve contexto, defina timeouts e repita somente operações idempotentes com efeitos externos conhecidos.

Escolha entre código síncrono, threads do sistema e async com base em I/O, CPU, bibliotecas, custo de complexidade e medições.

Monte um Router com sintaxe atual do Axum, handlers async, State com Arc, listener TCP e limites claros para estado compartilhado e trabalho de CPU.

Receba Path, Query, Json e State na ordem correta, valide payloads após a extração e converta erros tipados em respostas HTTP seguras.

Teste um Router com oneshot, colete corpos HTTP, configure o listener, conecte graceful shutdown à vida do servidor e revise a entrega final.