Garantindo a exhaustividade de switchs em TypeScript com validação de tipos

Problema concreto na validação de switches em TypeScript

Ao trabalhar com enums ou uniões discriminadas em TypeScript, um desafio comum é assegurar que todos os casos possíveis sejam tratados. Mesmo com a sintaxe do switch, é fácil esquecer alguma variação, o que pode gerar comportamentos não intencionais ou erros silenciosos em runtime.

A questão central é: como fazer com que o compilador indique um erro quando algum caso não é explicitamente tratado?

Diagnóstico usando o tipo never

A solução mais eficaz envolve o uso do tipo never, que representa valores que, teoricamente, nunca deveriam ocorrer. Quando um switch não cobre todas as opções de uma união discriminada, o TypeScript consegue apontar o caso não tratado ao tentar passar a variável para uma função que espera never.

Para aplicar isso, cria-se uma função auxiliar:

function assertUnreachable(x: never): never {
  throw new Error(`Unexpected case: ${x}`). }

Essa função serve como uma validação: se passar um valor para ela, e esse valor não for do tipo never, o TypeScript emitirá um erro de compilação. Por isso, o recorte precisa considerar manutenção, validação e caminho de volta. Esse contexto ajuda a separar ganho real de novidade difícil de sustentar. A decisão fica mais saudável quando o time consegue medir o impacto depois. Sem esse critério, a solução pode parecer simples no começo e cara no suporte.

Como estruturar o switch

A partir daí, o padrão de uso fica assim:

enum Status {
  Pending,
  Fulfilled,
  Rejected
}

function handleStatus(status: Status): string {
  switch(status) {
    case Status.Pending:
      return 'Aguardando'. case Status.Fulfilled:
      return 'Concluído'. }
  return assertUnreachable(status). }

A decisão fica mais saudável quando o time consegue medir o impacto depois. Sem esse critério, a solução pode parecer simples no começo e cara no suporte. O valor aparece melhor quando operação, produto e engenharia olham para o mesmo risco. Por isso, o recorte precisa considerar manutenção, validação e caminho de volta.

Ao compilar, o TypeScript aponta erro na linha do assertUnreachable se algum caso ficar de fora, por exemplo, Status.Rejected, se não for tratado na cláusula switch. Sem esse critério, a solução pode parecer simples no começo e cara no suporte. O valor aparece melhor quando operação, produto e engenharia olham para o mesmo risco. Por isso, o recorte precisa considerar manutenção, validação e caminho de volta. Esse contexto ajuda a separar ganho real de novidade difícil de sustentar. A decisão fica mais saudável quando o time consegue medir o impacto depois. Sem esse critério, a solução pode parecer simples no começo e cara no suporte.

Se a enumeração for extendida ou se estiver usando uniões discriminadas, essa abordagem garante que qualquer nova opção seja detectada em tempo de compilação. O valor aparece melhor quando operação, produto e engenharia olham para o mesmo risco. Por isso, o recorte precisa considerar manutenção, validação e caminho de volta. Esse contexto ajuda a separar ganho real de novidade difícil de sustentar. A decisão fica mais saudável quando o time consegue medir o impacto depois. Sem esse critério, a solução pode parecer simples no começo e cara no suporte. O valor aparece melhor quando operação, produto e engenharia olham para o mesmo risco. Por isso, o recorte precisa considerar manutenção, validação e caminho de volta.

Limitações e boas práticas

• Essa técnica funciona bem com enums e uniões discriminadas, mas não substitui testes automatizados que também verificam cobertura.
• Em projetos com strictNullChecks ativado, é preciso garantir que o retorno de assertUnreachable seja consistente para evitar erro de tipos.
• Para uniões discriminadas, é possível recuperar a propriedade discriminante na função de assertiva para facilitar o debug.

Por exemplo:

function assertExhaustive(p: never): never {
  throw new Error(`Valor inesperado: ${p}`). } Por isso, o recorte precisa considerar manutenção, validação e caminho de volta. Esse contexto ajuda a separar ganho real de novidade difícil de sustentar. O valor aparece melhor quando operação, produto e engenharia olham para o mesmo risco. O valor aparece melhor quando operação, produto e engenharia olham para o mesmo risco. O valor aparece melhor quando operação, produto e engenharia olham para o mesmo risco. O valor aparece melhor quando operação, produto e engenharia olham para o mesmo risco. O valor aparece melhor quando operação, produto e engenharia olham para o mesmo risco.

function processPet(p: Pet): void {
  switch (p.species) {
    case 'canine':
      console.log(p.woof). break. case 'feline':
      console.log(p.meow). break. default:
      assertExhaustive(p). }
}

Esse contexto ajuda a separar ganho real de novidade difícil de sustentar. Por isso, o recorte precisa considerar manutenção, validação e caminho de volta. Por isso, o recorte precisa considerar manutenção, validação e caminho de volta. Por isso, o recorte precisa considerar manutenção, validação e caminho de volta. Por isso, o recorte precisa considerar manutenção, validação e caminho de volta. Por isso, o recorte precisa considerar manutenção, validação e caminho de volta. Esse contexto ajuda a separar ganho real de novidade difícil de sustentar.

Assim, qualquer propriedade inesperada gera um erro claro em tempo de desenvolvimento, reduzindo surpresas em produção. A decisão fica mais saudável quando o time consegue medir o impacto depois. Esse contexto ajuda a separar ganho real de novidade difícil de sustentar. A decisão fica mais saudável quando o time consegue medir o impacto depois. Esse contexto ajuda a separar ganho real de novidade difícil de sustentar. Esse contexto ajuda a separar ganho real de novidade difícil de sustentar. Esse contexto ajuda a separar ganho real de novidade difícil de sustentar. A decisão fica mais saudável quando o time consegue medir o impacto depois. Esse contexto ajuda a separar ganho real de novidade difícil de sustentar.

Conclusão

A validação de exhaustividade com o uso do tipo never é uma estratégia simples, mas poderosa, para garantir que seus switches estejam completos. Isso aumenta a segurança do código, previne bugs silenciosos e ajuda na manutenção de código à medida que o sistema evolui. Implementar essa prática requer pouca sobrecarga, mas traz um benefício enorme na robustez do seu sistema em TypeScript. Sem esse critério, a solução pode parecer simples no começo e cara no suporte. O valor aparece melhor quando operação, produto e engenharia olham para o mesmo risco. A decisão fica mais saudável quando o time consegue medir o impacto depois. A decisão fica mais saudável quando o time consegue medir o impacto depois.

Para quem busca ainda mais segurança, combinar esse padrão com ferramentas de análise de cobertura de testes pode fazer toda a diferença na confiabilidade do seu código. O valor aparece melhor quando operação, produto e engenharia olham para o mesmo risco. Sem esse critério, a solução pode parecer simples no começo e cara no suporte. Sem esse critério, a solução pode parecer simples no começo e cara no suporte. Sem esse critério, a solução pode parecer simples no começo e cara no suporte. Sem esse critério, a solução pode parecer simples no começo e cara no suporte. O valor aparece melhor quando operação, produto e engenharia olham para o mesmo risco. Sem esse critério, a solução pode parecer simples no começo e cara no suporte.