TypeScript Academy · Aula

Programação Orientada a Trilhos

Encadeie operações que podem falhar sem try/catch.

Programação Orientada a Trilhos é 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.

A metáfora dos trilhos

A programação orientada por trilhos representa um cálculo como dois trilhos paralelos: um trilho de sucesso e um trilho de falha. Depois que você muda para o trilho de falha, permanece nele e ignora o restante.

Encadeando funções de Resultado

Cada etapa recebe um valor e retorna um Result. Queremos conectar as etapas para que a primeira falha interrompa a sequência e seja transportada até o final.

type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };
const ok = <T>(value: T): Result<T, never> => ({ ok: true, value });
const err = <E>(error: E): Result<never, E> => ({ ok: false, error });

map: transformar o valor de sucesso

map aplica uma função comum ao valor quando o Resultado está em estado de sucesso e repassa as falhas sem alterações. Ele permanece no trilho de sucesso.

function map<T, U, E>(r: Result<T, E>, f: (t: T) => U): Result<U, E> {
  return r.ok ? ok(f(r.value)) : r;
}
console.log(map(ok(2), n => n + 1)); // { ok: true, value: 3 }

flatMap: encadear etapas que podem falhar

Quando a própria etapa seguinte retorna um Resultado, use flatMap (também chamado de andThen). Isso evita aninhar Resultados e interrompe a sequência em caso de falha.

function flatMap<T, U, E>(r: Result<T, E>, f: (t: T) => Result<U, E>): Result<U, E> {
  return r.ok ? f(r.value) : r;
}

Por que flatMap, e não map

Se você usasse map com uma função que retorna um Resultado, obteria Result<Result<U,E>,E>. flatMap achata esse nível, mantendo um único Resultado.

Interrupção na primeira falha

Assim que uma etapa retorna err, todos os flatMap posteriores o repassam sem alterações. As etapas restantes nunca são executadas, exatamente como ao mudar para o trilho de falha.

const start = err("boom") as Result<number, string>;
const out = flatMap(start, n => ok(n + 1));
console.log(out); // { ok: false, error: "boom" }

Construindo um fluxo

Componha etapas de validação, cada uma retornando um Resultado. A primeira falha se torna o resultado do fluxo; se todas forem bem-sucedidas, o valor de sucesso flui até o final.

function parseNum(s: string): Result<number, string> {
  const n = Number(s);
  return Number.isNaN(n) ? err("not a number") : ok(n);
}
function positive(n: number): Result<number, string> {
  return n > 0 ? ok(n) : err("must be positive");
}

Executando o fluxo

Encadear flatMap conduz o valor por cada etapa que pode falhar. Uma falha em qualquer ponto interrompe a sequência e apresenta esse erro.

const good = flatMap(parseNum("5"), positive);
console.log(good); // { ok: true, value: 5 }
const bad = flatMap(parseNum("-3"), positive);
console.log(bad); // { ok: false, error: "must be positive" }

Combinando map e flatMap

Use flatMap para etapas que podem falhar e map para transformações puras. Juntos, eles mantêm o caminho de sucesso linear e tratam os erros automaticamente.

const result = map(flatMap(parseNum("10"), positive), n => n * 2);
console.log(result); // { ok: true, value: 20 }

Não é necessário usar try/catch

Todo o fluxo expressa sucesso e falha por meio de valores. Não há try/catch, e o tipo de cada etapa torna o caminho de erro explícito e impossível de ignorar.

Por que isso escala

O código orientado por trilhos mantém fluxos de trabalho complexos legíveis: cada etapa é pequena e pura, os erros se propagam automaticamente e adicionar uma etapa não complica o tratamento de erros existente.

Verificação rápida

Faça uma verificação rápida desta lição.

Recapitulação

A programação orientada por trilhos encadeia etapas que retornam Result com map (transforma o sucesso) e flatMap/andThen (encadeia etapas que podem falhar, achatando Resultados aninhados). O primeiro err interrompe o restante e se propaga até o final sem try/catch.

Perguntas Frequentes

A aula “Programação Orientada a Trilhos” é grátis?

Sim — o texto completo de “Programação Orientada a Trilhos” é 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 “Programação Orientada a Trilhos”?

Encadeie operações que podem falhar sem try/catch. 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 “Programação Orientada a Trilhos”?

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

← Voltar para TypeScript Academy