fp-ts para TypeScript: guia completo de programação funcional

1. O que é e por que usar

fp-ts (Functional Programming in TypeScript) é uma poderosa biblioteca de código aberto que traz o paradigma da programação funcional para o TypeScript. Ela fornece um conjunto de tipos, funções e combinadores inspirados em linguagens como Haskell, PureScript e Scala. Diferente da abordagem imperativa ou orientada a objetos, o fp-ts permite escrever código que é puro, previsível e facilmente testável. A biblioteca é construída sobre conceitos como functores, mônadas, functores aplicativos e outras abstrações que ajudam a gerenciar efeitos colaterais, tratar erros e trabalhar com assincronicidade sem exceções e mutações de estado.

Por que usar fp-ts? No desenvolvimento moderno com TypeScript, problemas comuns incluem: exceções inesperadas (como ao lidar com null ou undefined), dificuldade de testar devido a dependências ocultas e efeitos colaterais, além de código assíncrono confuso com callbacks. O fp-ts resolve esses problemas oferecendo um sistema de tipos rigoroso e abstrações combináveis. Por exemplo, o tipo Option modela explicitamente a ausência de valor, enquanto Either trata erros sem try/catch. Isso torna o código mais seguro e documentado no nível dos tipos.

A biblioteca é especialmente útil em projetos com lógica de negócios complexa, onde confiabilidade e manutenibilidade são cruciais. Ela também é ideal para equipes que desejam adotar princípios funcionais gradualmente, sem reescrever todo o projeto. O fp-ts é ativamente mantido pela comunidade e possui um rico ecossistema, incluindo integração com io-ts (validação de dados), monocle-ts (lentes) e hyper-ts (servidores web).

2. Instalação

O fp-ts é distribuído via npm. Para instalar, execute o comando:

npm install fp-ts

Também é recomendado instalar o @types/node para suporte a tipos do Node.js, caso você não esteja trabalhando no navegador:

npm install -D @types/node

Para usar o fp-ts, é necessário TypeScript versão 4.0 ou superior. Certifique-se de que a opção "strict": true esteja habilitada no seu tsconfig.json para máxima segurança de tipos.

3. Início rápido — exemplo mínimo funcional

Vamos ver um exemplo simples: divisão segura de dois números com tratamento de divisão por zero. Sem o fp-ts, escreveríamos:

function divide(a: number, b: number): number | null {
  if (b === 0) return null;
  return a / b;
}

const result = divide(10, 2);
if (result !== null) {
  console.log(result); // 5
}

Com o fp-ts, usamos o tipo Option:

import { pipe } from 'fp-ts/function';
import { Option, some, none, fromPredicate } from 'fp-ts/Option';

const safeDivide = (a: number, b: number): Option =>
  pipe(
    b,
    fromPredicate((x) => x !== 0),
    Option.map((divisor) => a / divisor)
  );

const result = safeDivide(10, 2);
// result: Option — some(5) ou none

// Extraindo o valor
import { fold } from 'fp-ts/Option';

const message = pipe(
  result,
  fold(
    () => 'Erro: divisão por zero',
    (value) => `Resultado: ${value}`
  )
);
console.log(message); // "Resultado: 5"

Este exemplo demonstra os princípios-chave do fp-ts: composição através de pipe, modelagem explícita da ausência de valor e tratamento de erros sem exceções.

4. Principais métodos/funções/classes

4.1. Option — trabalhando com valores opcionais

Assinatura:

// Construtores
declare const some: (a: A) => Option;
declare const none: Option;

// Métodos principais
declare const map: (f: (a: A) => B) => (fa: Option