Fale conosco
Desenvolvimento

Rust 1.100: o never type `!` vira estável e o `Infallible` muda de identidade

29 min de leitura
Rust 1.100: o never type `!` vira estável e o `Infallible` muda de identidade

Rust 1.100: o never type ! vira estável e o Infallible muda de identidade

Em 12 de novembro, o time do Rust publicou a versão 1.100.0 — a primeira de três dígitos na história do projeto — e, com ela, o corte mais substancial em anos. O destaque anunciado no é a estabilização do tipo never, escrito ! , depois de cerca de dez anos de trabalho e cinco tentativas frustradas de estabilização. Junto vieram as partes centrais da Allocator API, o tipo DropGuard na biblioteca padrão e duas mudanças no Cargo que alteram o comportamento do seu build: idade mínima para dependências recém-publicadas e avisos mais confiáveis de dependências não usadas.

Para quem escreve código no dia a dia, o ! deixa de ser um detalhe escondido na assinatura de panic! e passa a ser algo que você pode escrever em qualquer posição de tipo. E, como quase sempre em Rust, a estabilização chega acompanhada de uma mudança de compatibilidade que merece atenção: std::convert::Infallible agora é um alias do never type.

O que o ! faz — e o que passa a ser possível

O never type descreve computações que não produzem valor. return , break , continue , std::process::exit , panic! e unreachable!() têm esse tipo. Você sempre pôde usar essas expressões, mas não pôde escrevê-lo explicitamente: qualquer assinatura com -> ! exigia #![feature(never_type)] e um compilador nightly.

A partir da 1.100, o mesmo código compila em stable. O ganho real, porém, aparece em posição de parâmetro de tipo, onde antes era preciso inventar um enum vazio:

Result<T, !> diz no próprio tipo que o erro é impossível — e o compilador sabe disso. Um match sobre esse Result não ganha braço de erro, funções genéricas que exigem E: Error ou E: Debug deixam de precisar de boilerplate, e wrappers como Box<dyn Fn() -> !> passam a ser expressáveis sem gambiarra. É uma melhoria de modelagem pequena em linhas de código, mas grande em clareza de contrato: quem lê a assinatura não precisa mais consultar a documentação para descobrir que aquele Infallible nunca acontece.

Infallible virou ! : onde o código existente sente

A parte que exige cautela é a segunda. Transformar Infallible em alias do never type não é só cosmético: as regras de inferência do ! em posições ambíguas são justamente o terreno que derrubou as tentativas anteriores. Segundo relatos de quem acompanhou os testes de pré-lançamento, o processo encontrou milhares de regressões no ecossistema antes do corte final — a maioria em crates antigas, com traits genéricos, From / TryFrom e usos de ? onde o tipo nunca era realmente inferido.

Na prática, três sintomas aparecem primeiro:

match que antes era exaustivo passa a acusar braço inalcançável ou tipo incompatível, quando o código tratava Infallible como enum nominal de dois casos impossíveis.

Impls específicas para Infallible podem entrar em conflito com impls genéricas que agora casam com ! .

Crates com MSRV baixa que usam ! em API pública deixam de compilar em toolchains anteriores — o que importa se você publica biblioteca.

O caminho mais barato é rodar cargo +1.100 check --all-targets (incluindo testes e exemplos) numa branch isolada, antes de mexer em qualquer rust-version . Se o projeto tem dependências com proc-macros ou geração de código, vale rodar também o build em modo release: divergências de inferência costumam aparecer só quando a otimização muda a ordem de expansão.

Allocator API e DropGuard saem do nightly

As partes centrais da Allocator API foram estabilizadas: o trait Allocator e os tipos que aceitam alocador explícito, como Box::new_in , Vec::new_in e Rc::new_in . Isso permite implementar um alocador próprio — arena de curta duração para um parser, pool por request em um servidor — sem #![feature(allocator_api)] . Vale ler o anúncio com atenção: o desenho completo da API ainda não está congelado, então trate como base estável para experimentação controlada, não como convite para reescrever a camada de memória de um serviço em produção.

O std::mem::DropGuard é o utilitário discreto do release: um guard genérico que executa um fechamento no Drop , substituindo o padrão de declarar um struct de uma linha só para garantir limpeza (liberar lock, fechar span de tracing, marcar fim de transação). É exatamente o tipo de código que some dos PRs sem drama — e que reduz a chance de esquecer um drop() manual em caminho de erro.

Cargo: cooldown de dependências e avisos que funcionam

A mudança com maior efeito operacional é a idade mínima para dependências recém-publicadas, apelidada de dependency cooldown . A ideia: definir uma janela (por exemplo, sete dias) durante a qual o Cargo não adota versões publicadas há menos tempo que isso. O alvo é o ataque clássico de supply chain — pacote comprometido, versão maliciosa publicada e removida em questão de horas, antes que o registro reaja. Já existia ferramenta de terceiros fazendo isso; agora é configuração de Cargo, aplicada de forma consistente para todo o time e para o CI.

O segundo item é menos glamouroso e provavelmente mais útil no dia a dia: o Cargo passou a apontar dependências não usadas com mais confiabilidade. Menos crates declaradas e nunca importadas significa menos superfície de build, menos tempo de compilação e menos risco.

Em times que mantêm bibliotecas internas compartilhadas por vários produtos — cenário comum em projetos de software sob medida, como os que a Maquinaweb conduz com squads multidisciplinares em Python, Node.js, C#/.NET, Angular e TypeScript, além de componentes em Rust onde latência importa —, o cooldown precisa vir com processo. Uma política de dependências que ninguém sabe explicar é pior do que não ter política.

Riscos e armadilhas

Cooldown esconde patch de segurança. Se um CVE é corrigido numa versão publicada há duas horas, a janela de sete dias bloqueia justamente a correção. Defina uma exceção documentada (pin explícito com justificativa e prazo) e uma janela curta para dependências críticas.

! em API pública força MSRV 1.100. Em bibliotecas, isso pode ser aceitável; em SDKs consumidos por terceiros, é uma decisão de produto, não de estilo.

! não é () . Trocar -> () por -> ! numa função que às vezes retorna quebra a compilação — e o contrário silencia erros que você queria ver.

Fallback de inferência. Código que dependia do comportamento antigo do ! em posições ambíguas (closure sem anotação, ? em contexto genérico) é a fonte mais provável de surpresa. Não presuma que "compilou na minha máquina" significa que os outros crates do workspace compilam.

DropGuard em fluxo assíncrono. Guard que roda em Drop não espera await ; não tente usá-lo para aguardar flush assíncrono.

Recomendação prática

Atualize primeiro o toolchain, depois o código: rustup update stable , cargo +1.100 check --all-targets e a suíte de testes completa em uma branch, com rust-version mantida até o resultado estar limpo. Adote o cooldown de dependências em 3 a 7 dias com um caminho de exceção escrito no repositório — e prefira começar pelas dependências de build e pelas transitivas mais profundas, onde o risco de takeover é maior. O ! vale a pena primeiro em tipos internos e em handlers que nunca falham; em API pública de biblioteca, espere uma versão minor para medir o impacto no ecossistema.

Se o seu time está avaliando migrar parte da stack para Rust ou precisa revisar a política de dependências e MSRV de um projeto existente, o time de engenharia da Maquinaweb pode ajudar a mapear o custo real antes de mexer em produção — incluindo arquitetura, migração de stack e desenvolvimento sob medida.

Fontes

#rust #never type #cargo #allocator api #linguagens de programação #inferência de tipos #msrv #migração
Contato

Bora conversar?

Três campos. A resposta vem no WhatsApp.

Ou escreva para contato@maquinaweb.com.br.

Você vai para o WhatsApp com a mensagem pronta. Sem spam, sem lista.

Seus dados seguem a nossa política de privacidade.