0Pricing
TypeScript Academy · Aula

Canais de Erro e Dependências

Acompanhe erros tipados e dependências injetadas nos efeitos.

Canais de Erro e Dependências é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 4 aulas no total.

Canais de erros e dependências

Dois canais tornam o Effect poderoso: o canal de erros tipado (E) e o canal de requisitos (R). Nesta lição, você verá como falhar com erros tipados e como fornecer dependências por meio de Context e Layer.

Falhas tipadas com Effect.fail

Effect.fail coloca um valor no canal de erros. Classes marcadas facilitam a discriminação dos erros.

import { Effect } from "effect";

class NotFound { readonly _tag = "NotFound"; }
class Forbidden { readonly _tag = "Forbidden"; }

const load = Effect.fail(new NotFound());
// Effect<never, NotFound, never>

Os erros formam uma união durante a composição

Ao sequenciar efeitos com erros diferentes, eles são unidos no canal E, de modo que o tipo liste todos os modos de falha.

// Effect<A, NotFound, never> then Effect<B, Forbidden, never>
// => Effect<B, NotFound | Forbidden, never>

Tratamento de erros

Effect.catchAll ou catchTag tratam os erros, removendo-os do canal (ou substituindo-os). Tratar NotFound restringe E.

import { Effect, pipe } from "effect";

const safe = pipe(
  Effect.fail(new NotFound()),
  Effect.catchTag("NotFound", () => Effect.succeed("default"))
);
// Effect<string, never, never> -- error handled

Recuperar ou propagar

Se você não tratar um erro, ele permanecerá em E e será propagado ao chamador, que deverá tratá-lo ou propagá-lo novamente. O compilador garante que os erros nunca sejam perdidos silenciosamente.

Declarando uma dependência

Um serviço é declarado como um Context.Tag. Os efeitos que o utilizam passam a ter o serviço em seu canal R.

import { Context, Effect } from "effect";

class Random extends Context.Tag("Random")<
  Random,
  { readonly next: Effect.Effect<number> }
>() {}

const program = Effect.gen(function* () {
  const random = yield* Random;
  return yield* random.next;
});
// Effect<number, never, Random>

Os requisitos aparecem no tipo

Observe que o canal R agora contém Random. O efeito não pode ser executado até que esse requisito seja atendido; o compilador impõe isso.

Fornecendo com uma camada

Uma Layer descreve como criar um serviço. Fornecer uma camada atende ao requisito e o remove de R.

import { Effect, Layer } from "effect";

const RandomLive = Layer.succeed(Random, {
  next: Effect.sync(() => Math.random()),
});

const runnable = Effect.provide(program, RandomLive);
// Effect<number, never, never> -- R cleared

As camadas são compostas

As camadas podem depender de outras camadas e ser combinadas, formando um grafo completo de dependências. O Effect as conecta na ordem correta com base em seus tipos.

import { Layer } from "effect";
// Layer.merge(DatabaseLive, LoggerLive)
// Layer that provides both services

Testando ao trocar camadas

Como as dependências são explícitas, os testes fornecem uma camada diferente (por exemplo, um Random determinístico) sem alterar o programa em teste — uma grande vantagem do acompanhamento de requisitos.

import { Layer, Effect } from "effect";

const RandomTest = Layer.succeed(Random, {
  next: Effect.succeed(0.5),
});
// Effect.provide(program, RandomTest) -> deterministic

Por que isso é importante

Os canais de erros e requisitos transformam suposições invisíveis em contratos verificados pelo compilador: toda falha deve ser tratada ou declarada, e toda dependência deve ser fornecida. É isso que torna grandes programas Effect robustos e fáceis de testar.

Verificação rápida

Confirme seu entendimento sobre canais de erros e dependências.

Recapitulação

O canal de erros acompanha falhas tipadas (Effect.fail, restringidas por catchTag/catchAll) que formam uniões durante a composição, enquanto o canal de requisitos acompanha serviços declarados por meio de Context.Tag e atendidos por Layer com Effect.provide. Juntos, eles tornam falhas e dependências verificadas pelo compilador e facilitam os testes por meio da troca de camadas.

Perguntas Frequentes

A aula “Canais de Erro e Dependências” é grátis?

Sim — o texto completo de “Canais de Erro e Dependências” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 4 aulas no total.

O que vou aprender em “Canais de Erro e Dependências”?

Acompanhe erros tipados e dependências injetadas nos efeitos. Você pratica TypeScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar TypeScript Academy?

Nenhuma experiência prévia é necessária. TypeScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Canais de Erro e Dependências”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de TypeScript Academy?

Sim. Cada aula de TypeScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Por que os Sistemas de Efeitos São Importantes
  2. O Tipo Effect
  3. Compondo Efeitos
  4. Canais de Erro e Dependências
← Voltar para TypeScript Academy