0Pricing
TypeScript Academy · Aula

Compondo Efeitos

Encadeie e combine efeitos com pipe e geradores.

Compondo Efeitos é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 3 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.

Compondo efeitos

Os efeitos são valores, portanto você cria programas compondo-os. As ferramentas principais são Effect.pipe, Effect.map, Effect.flatMap e a sintaxe Effect.gen baseada em geradores.

pipe: encadeando por funções

pipe passa um efeito por uma série de transformações, da esquerda para a direita, evitando aninhamento profundo.

import { Effect, pipe } from "effect";

const program = pipe(
  Effect.succeed(2),
  Effect.map((n) => n + 1),
  Effect.map((n) => n * 10)
);
// Effect<number, never, never> producing 30

map: transformando o valor de sucesso

Effect.map aplica uma função pura ao valor de sucesso, deixando os canais de erro e de requisitos inalterados.

import { Effect } from "effect";

const doubled = Effect.map(Effect.succeed(21), (n) => n * 2);
// Effect<number, never, never>

flatMap: encadeando efeitos

Quando a próxima etapa é, por si só, um efeito, use flatMap, também chamado de chain. Ele executa o primeiro efeito e depois fornece seu valor a uma função que retorna outro efeito.

import { Effect, pipe } from "effect";

const getId = Effect.succeed(1);
const loadUser = (id: number) => Effect.succeed({ id, name: "Ada" });

const program = pipe(getId, Effect.flatMap(loadUser));
// Effect<{ id: number; name: string }, never, never>

map vs flatMap

Use map quando sua função retornar um valor simples; use flatMap quando ela retornar um efeito. Usar map com uma função que retorna um efeito deixa você com um efeito aninhado.

Os canais se acumulam

À medida que você encadeia efeitos, seus tipos de erro formam uma união e seus requisitos também. O tipo composto reflete tudo o que pode falhar e tudo o que é necessário.

// Effect<A, E1, R1> then Effect<B, E2, R2>
// => Effect<B, E1 | E2, R1 | R2>

Effect.gen: sintaxe de geradores

Effect.gen permite escrever código de efeitos sequenciais que se lê como async/await, usando yield* para extrair cada efeito.

import { Effect } from "effect";

const program = Effect.gen(function* () {
  const id = yield* Effect.succeed(1);
  const user = yield* Effect.succeed({ id, name: "Ada" });
  return user.name;
});
// Effect<string, never, never>

gen vs pipe

gen é mais claro para fluxos lineares com várias etapas e variáveis intermediárias; pipe se destaca em cadeias curtas de transformações. Eles interoperam livremente.

Combinando efeitos independentes

Effect.all executa vários efeitos e reúne seus resultados, acumulando os erros e requisitos de todos eles.

import { Effect } from "effect";

const both = Effect.all([Effect.succeed(1), Effect.succeed("x")]);
// Effect<[number, string], never, never>

Ainda com execução adiada

Tudo isso apenas descreve o programa. Nada é executado até que você o execute na borda do sistema com Effect.runPromise ou Effect.runSync.

import { Effect } from "effect";
// const result = await Effect.runPromise(program);

Por que isso é importante

A composição é o que torna os efeitos práticos: você reúne partes pequenas e tipadas em programas grandes, enquanto o compilador acompanha cada erro e dependência. map, flatMap, pipe e gen são os verbos usados no dia a dia do código Effect.

Verificação rápida

Verifique seu entendimento sobre a composição de efeitos.

Recapitulação

Você compõe efeitos com map (transforma valores de sucesso), flatMap (encadeia etapas que retornam efeitos), pipe (encadeia transformações) e Effect.gen (sintaxe de gerador semelhante à espera assíncrona). Os canais de erros e requisitos acumulam-se como uniões, e nada é executado até que você o execute na borda.

Perguntas Frequentes

A aula “Compondo Efeitos” é grátis?

Sim — o texto completo de “Compondo Efeitos” é 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 “Compondo Efeitos”?

Encadeie e combine efeitos com pipe e geradores. 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 3 de 4.

Quanto tempo leva a aula “Compondo Efeitos”?

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