Artigos aprofundados sobre a tecnologia que molda o que vem a seguir.

Rust 1.100: o tipo never e dez anos de paciência

Rust 1.100 finalmente estabiliza o tipo never, alocadores customizados e cooldowns de dependências no Cargo. O que 100 releases ensinam sobre design de linguagens.

Uma longa escadaria de pedra construída degrau por degrau encosta acima, com ferramentas de pedreiro repousando no meio da obra
Cem degraus pequenos e nivelados: a cadência de releases do Rust como filosofia de construção.

Imagine um cenário que deveria ser notável e não é: você roda rustup update stable numa quinta-feira de manhã, recompila um workspace com algumas centenas de crates e meio milhão de linhas de código, e tudo compila. Sem avisos de depreciação que você não tenha merecido, sem quebras surpresa em uma dependência transitiva, sem correria para fixar versões. Com o Rust 1.100 — uma release enorme que finalmente traz o tipo never depois de uma década de tentativas — a coisa mais interessante é como a atualização será tranquila para quase todo mundo. Isso não é acidente. É o resultado de cem releases de disciplina institucional, e vale a pena ler essa release como se fosse um documento de design.

O tipo Never, uma década em construção

A grande novidade do 1.100 é um tipo que, por definição, não tem valores. O tipo never, escrito !, é o tipo inabitado canônico: ele descreve computações que nunca resolvem para um valor — um loop infinito, um return, um panic!(), uma chamada a std::process::exit. Teóricos de tipos conhecem essa criatura há muito tempo; é o tipo de fundo, o ⊥ do cálculo lambda, o conjunto vazio num canto do seu reticulado de tipos. Usuários de Haskell a conheciam como Void. O Rust vem rodeando isso desde antes da 1.0, e levou dez anos e cinco tentativas de estabilização frustradas para finalmente pousar.

Por que foi tão difícil? Porque ! pode ser coagido para qualquer outro tipo — que é exatamente o seu poder — e cada ponto de coerção é um lugar onde inferência de tipos, resolução de traits e verificação de exaustividade precisam concordar. Como um braço de match que diverge tem tipo !, este código compila:

fn infallible_unwrap<T>(res: Result<T, !>) -> T {
// ^^ naming `!` in a type position like this
// was not allowed on stable before 1.100
let Ok(v) = res;
v
}

A linha let Ok(v) = res; é a recompensa: como Err(!) nunca pode existir, o compilador aceita o padrão irrefutável, e toda uma categoria de chamadas defensivas de unreachable!() simplesmente desaparece. Junto com isso, o antigo enum std::convert::Infallible vira um alias de tipo para !, então toda API escrita com Infallible nos últimos anos fica automaticamente compatível com o tipo never de verdade. Essa unificação era o plano desde o início — e também foi o motivo de a estabilização ter escorregado repetidas vezes, porque mudar o alias exigia mudar o fallback do tipo never nas edições anteriores a 2024, uma mudança tecnicamente incompatível.

Veja como a equipe lidou com essa quebra, porque ela resume a filosofia inteira. Eles lançaram avisos de compatibilidade futura com muita antecedência, testaram o ecossistema com crater e enviaram proativamente correções para crates públicos que seriam afetados. Uma mudança incompatível, executada ao longo de vários ciclos de release, com o raio de impacto medido e corrigido antes que a maioria dos usuários percebesse qualquer coisa. Compare com a jogada comum da indústria de subir a versão maior e dar de ombros. Já escrevi sobre o que a soundness realmente compromete no Rust — a saga do tipo never é a versão no nível de processo do mesmo compromisso. Quando a sua garantia é "código seguro não pode ter comportamento indefinido", até um tipo sem nenhum habitante precisa merecer seu lugar.

Alocadores customizados finalmente ganham uma base estável

Quase tão aguardado: o núcleo do trabalho em allocator_api está estável. O trait Allocator, Global, System e os construtores *_in — Vec::new_in, Vec::with_capacity_in, Box::new_in, Box::from_raw_in — já podem ser usados no Rust estável. Autores de bibliotecas podem definir um alocador e entregá-lo às coleções padrão:

use std::alloc::{Allocator, Global};
// A Vec that allocates from your arena/pool/slab instead of the heap
let mut v: Vec<u64, _> = Vec::new_in(MyArena::new());
v.push(42);

Se você só escreveu código de aplicação, isso pode parecer encanamento. E é encanamento — e é no encanamento que linguagens de sistema vivem ou morrem. Até agora, trocar de alocador significava o instrumento bruto de #[global_allocator]: um alocador para o processo inteiro. Isso serve quando você quer jemalloc ou mimalloc em tudo (e há ganho real de desempenho em jogo — o jemalloc ganhou sua reputação em escala), mas não serve quando você quer um Vec apoiado por uma arena que é liberada de uma vez no fim de uma requisição, enquanto todo o resto usa o heap padrão. Engines de jogos, bancos de dados, alvos embarcados com múltiplas regiões de RAM, código próximo ao kernel — todos querem controle por coleção, e vêm querendo isso há anos.

Repare no enquadramento da própria release: isso é explicitamente a fundação do objetivo de projeto "Allocators 1.0", com mais coleções e tipos de ponteiro por vir. O projeto Rust ficou confortável em dizer "aqui está o núcleo estável; o resto continua deliberadamente em nightly". Esse sequenciamento — estabilizar o trait e o design, deixar o ecossistema construir sobre ele, expandir a superfície depois — é exatamente como você evita se encurralar com uma API que precisa ser mantida para sempre. C++ seguiu o caminho oposto com o std::allocator nos anos noventa, lançou meio pronto e passou décadas contornando os destroços. Paciência é mais barata.

DropGuard: o defer do Go, do jeito Rust

O sucesso discreto da release é std::mem::DropGuard. O trait Drop do Rust já garante que o código de limpeza rode quando um valor sai de escopo — return, ?, panic, não importa. Mas escrever um tipo inteiro só para executar uma closure na saída é boilerplate que a maioria de nós já resmungou. O DropGuard envolve um valor e uma closure, faz deref para o valor para que você possa usá-lo normalmente, e executa a closure quando o guard morre. Um método dismiss() o desarma. O uso canônico é rollback transacional:

use std::mem::DropGuard;
use std::num::ParseIntError;
/// Push every parsed string into `nums`, or leave `nums` untouched.
fn parse_all(nums: &mut Vec<u32>, strings: &[&str]) -> Result<(), ParseIntError> {
let len = nums.len();
let mut nums = DropGuard::new(nums, move |nums| {
nums.truncate(len); // rollback on failure
});
for s in strings {
nums.push(s.parse()?); // `?` exits early; the guard truncates
}
DropGuard::dismiss(nums); // success: keep the values
Ok(())
}

Se isso cheira a defer do Go, é isso mesmo — mas com uma diferença crucial em onde a garantia mora. O defer do Go é uma instrução com escopo de função: roda quando a função retorna, e é invisível para o sistema de tipos. O DropGuard é um valor. Você pode movê-lo, armazená-lo, entregá-lo a outro escopo, desarmá-lo condicionalmente. A linhagem aqui passa pelo RAII do C++ e pelo velho truque ScopeGuard de Alexandrescu, dos primórdios do C++ moderno, que fazia a mesma dança com destrutores e uma chamada Dismiss(). O Rust não inventou a ideia; ele absorveu um idioma de C++ com vinte anos, deu a ele semântica de ownership e o colocou no core. É assim que a boa evolução de linguagens funciona de verdade — não novidade, mas adoção de padrões comprovados no vocabulário padrão.

Um equilibrista atravessando um cânion com uma corda de segurança ancorada atrás de si
O DropGuard é a corda de segurança ancorada: aconteça o que acontecer na linha, o rollback roda.

Invocando o nada: tipos de tamanho zero feitos direito

Mais abaixo nas notas há uma função com um nome que eu genuinamente adoro: std::mem::conjure_zst. Tipos de tamanho zero — structs unitárias, tokens de marcador como o Python<'py do PyO3 — estão em todo lugar na programação em nível de tipos do Rust. Se um tipo habitado não tem tamanho, existe exatamente um valor que ele pode conter, então criá-lo é, de certo modo, sempre "seguro". Mas APIs dependem rotineiramente desses tokens serem impossíveis de forjar: invocar um Python<'py do nada permitiria que código seguro fingisse segurar o GIL. Antes, as pessoas invocavam ZSTs com transmutes de () ou com incantações de MaybeUninit, cada uma com implicações sutilmente diferentes para as diretrizes de código unsafe ainda não decididas. Agora existe uma grafia única, abençoada e ruidosamente unsafe. É uma função minúscula que existe para que uma grande questão de especificação tenha uma única resposta auditável. Chato, cuidadoso, correto — a release inteira numa API só.

Cooldowns de dependências no Cargo: defesa da cadeia de suprimentos com timer

A mudança mais consequente do 1.100 talvez nem esteja na linguagem. O Cargo agora suporta resolução de dependências com min-publish-age — cooldowns de dependências. A ideia por trás disso é empírica: versões maliciosas de pacotes costumam ser pegas em horas ou dias após a publicação, por scanners ou por humanos. Então basta recusar resolver para versões mais novas que uma janela configurada:

# .cargo/config.toml
[registry]
global-min-publish-age = "3 days"

A partir daí, o cargo update ignora silenciosamente releases recentes e informa o que segurou — clap 4.6.7 (available: 4.6.9, published 2 days ago). Quando você realmente precisa de um hotfix, uma variável de ambiente de override pontual permite puxá-lo deliberadamente, e essa escolha fica registrada no Cargo.lock em vez de se propagar em silêncio. É um controle de segurança raro que quase não custa nada: você troca alguns dias de frescor por uma quarentena permanente contra todo ataque de zero-day em pacotes que é pego rápido. Dado o que vimos acontecer em outros registries — o comprometimento do LiteLLM no PyPI é uma aula recente de como rápido uma release envenenada se espalha — um cooldown é o seguro mais barato do ecossistema. As notas da release são admiravelmente honestas ao dizer que isso não é uma defesa completa, e que cargo install contorna tudo isso. Suporte a quarentena e detecção automatizada de releases suspeitas ainda estão no roadmap do crates.io. Defesa em profundidade, entregue uma camada por vez.

Higiene de build: dependências não usadas e colisões de cache

Duas mudanças de qualidade de vida merecem menção porque atacam as duas reclamações mais comuns em qualquer thread sobre Rust: tempo de compilação e uso de disco. Primeiro, o Cargo agora reporta dependências não usadas diretamente, com um aviso apontando para a linha exata do seu Cargo.toml. O rustc já tinha o lint unused_crate_dependencies há muito tempo, mas ele gerava falsos positivos com o Cargo porque as dependências são compartilhadas entre alvos de build — uma dep usada por um bin de um pacote parece não usada para outro. O Cargo tem a visão global que o rustc não tem, então o aviso agora vive onde a verdade vive. Ele fica atrás de compilar todos os alvos relevantes, e é o primeiro cidadão de um novo sistema de lints [lints.cargo] para o próprio manifesto.

Segundo, o diretório de build foi reorganizado. Configurações de build diferentes — conjuntos de features, profiles — produzem artefatos diferentes, e um hash de configuração mantém essas coisas separadas. Esse hash não era aplicado de forma consistente por causa de restrições de plataforma, o que significava rebuilds extras, rebuilds perdidos e muita confusão, tudo pior se você compartilhava um diretório de build entre worktrees do git. A correção move o hash dos nomes de arquivo para uma estrutura de diretórios organizada por etapa de build. Invisível quando funciona, e esse é o ponto — e destrava a coleta de lixo de cache e a deduplicação entre workspaces no futuro. Se o seu target/ já comeu 90 gigabytes e te forçou a rodar cargo clean todo dia, a base da sua salvação acabou de ser lançada. A correção completa ainda não está aqui, mas a refatoração estrutural, sim.

Um vasto armazém com crates empilhados em fileiras organizadas e um canto de quarentena isolado por cordas
Cooldowns e higiene de cache: a logística sem glamour que mantém um ecossistema de pacotes confiável.

O que cem releases ensinam sobre a evolução de linguagens

Estabilidade não é ausência de mudança. É a disciplina de sequenciar mudanças para que o código de ninguém pague o preço do seu roadmap.

Dê um passo atrás e olhe o formato desta release. Um refinamento de teoria de tipos que levou uma década. Um trait de alocador deliberadamente entregue como fundação, não como superfície acabada. Um idioma de scope-guard mais antigo que alguns de seus usuários, finalmente padronizado. Um recurso de segurança construído sobre metadados do registry e ressalvas honestas. Internals do sistema de build refatorados para destravar trabalho futuro. Nenhuma dessas é uma virada de paradigma chamativa, e juntas constituem exatamente isso: uma linguagem que fica cada vez mais profunda sem ficar diferente por baixo dos seus pés. É o mesmo acúmulo silencioso que você vê na marcha sem glamour do Java, outro ecossistema que descobriu que chato é um recurso.

A engrenagem que torna isso possível merece tanto crédito quanto qualquer funcionalidade. O modelo de trem de seis semanas significa que nenhuma estabilização é uma emergência. O crater — ferramenta que compila praticamente todo o ecossistema público de crates contra um compilador candidato — transforma "isso vai quebrar alguém?" de uma oração em uma medição. As edições oferecem um caminho de migração opcional, para que a linguagem possa mudar seus padrões sem mudar o seu código. E a relativamente nova instituição de objetivos de projeto nomeados (Allocators 1.0, o layout do diretório de build, o endurecimento da cadeia de suprimentos do crates.io) dá aos esforços de vários anos uma espinha dorsal pública, então uma funcionalidade como o tipo never pode falhar cinco vezes e ainda ter um caminho designado até o destino, em vez de morrer numa thread de lista de e-mails.

Há uma lição aqui para quem mantém uma plataforma, um protocolo ou uma biblioteca amplamente usada. Usuários não experimentam o seu roadmap; eles experimentam os seus diffs. O tipo never chegando no 1.100 em vez do 1.35 não é uma história sobre lentidão — é uma história sobre o que acontece quando um projeto trata "a gente saberá quando vir" como resposta aceitável por uma década. A maioria das organizações de software não pode se dar ao luxo dessa paciência, e, sinceramente, a maioria nem precisa dela. Mas se você constrói algo sobre o qual outras pessoas constroem, a conta inverte: a confiança dos seus usuários se acumula como juros, e a única forma de conquistá-la é com cem releases em que nada quebra. O Rust 1.100 é uma release grande. A história maior é que você pode instalá-la sem ler as notas antes.