Handle TypeScript errors as values with fp-ts Either

This skill teaches practical fp-ts error handling built on one idea: errors are data, returned as values TypeScript can track, instead of thrown into the void. Either<E, A> holds Left (error) or Right (success); E.tryCatch/E.tryCatchK wrap throwing code, E.map/E.mapLeft transform either side, E.fold pattern-matches both cases, and E.chain composes operations where any step's failure short-circuits the rest. TaskEither<E, A> is the async equivalent - a lazy function returning Promise<Either<E, A>> - with the same map/chain/fold vocabulary plus TE.orElse for fallback chains and sequenceS(TE.ApplyPar) for running independent async operations in parallel.

Use it when replacing exception-heavy code with Either/TaskEither, when building validation or domain-error contracts, or when pragmatic fp-ts guidance is needed for real application code rather than academic functional-programming theory. It is specifically about error-as-value patterns; general fp-ts usage beyond error handling (lenses, IO, non-error monadic composition) is out of scope.

Chaining with E.chain/E.chainW stops at the first Left and automatically unions differing error types across steps; E.filterOrElse adds validation checks mid-chain, and E.Do/E.bind ("Do notation") keeps intermediate values addressable by name in a pipeline. When every error needs surfacing at once - the classic form-validation case - E.getApplicativeValidation paired with NEA.getSemigroup and sequenceS(validation) accumulates all failures into a NonEmptyArray instead of stopping at the first one, with a field-level variant for attaching errors to specific form fields. For boundary conversion, E.fromNullable/E.fromOption handle T | undefined, E.tryCatch wraps throwing libraries like Zod's schema.parse, and TE.tryCatch wraps Promise-based APIs (fetch, Prisma) into typed TaskEithers; going back out to a plain Promise uses either await te() (preserves the Either), a throw-on-error wrapper for legacy callers, or TE.getOrElse for a default value.

const getUser = (id: string): E.Either<string, User> =>
  !id ? E.left('ID required') : E.right(db.find(id))

Built entirely on fp-ts's Either, TaskEither, NonEmptyArray, and Apply modules, composed via pipe. Worked scenarios include exponential-backoff retry (TE.orElse plus T.delay), cache-then-API fallback chains, safely parsing untyped input field-by-field, typed API-error handling with switch-based recovery per error code, and bulk/list operations that process every item and report successes and failures separately rather than failing the whole batch on one bad item.

TypeScript developers migrating exception-heavy or nested-try/catch code to typed, composable error handling - anyone building form validation that needs every error at once, async pipelines that need retries and fallbacks, or API boundaries that need to convert between throwing functions, nullable values, Promises, and Either/TaskEither cleanly at the edges.