Master Pragmatic Functional Programming in TypeScript

Teaches a pragmatic, 80/20 subset of fp-ts for TypeScript, skipping category-theory jargon in favor of five patterns that cover most real-world use: pipe for chaining 3+ transformations in reading order, Option for handling nullable values without nested if checks (O.fromNullable, O.flatMap, O.getOrElse), Either for making expected failures explicit as return values instead of thrown exceptions (E.right/E.left), map for transforming values inside Option/Either/arrays without unwrapping them first, and flatMap for chaining operations that might each fail. It also gives five "quick win" refactors (nested ternaries to pipe + O.fold, try/catch to E.tryCatch, undefined returns to Option, bare error strings to typed error objects, and tagged-union error types with a _tag discriminant) and four worked before/after refactors: callback hell to TaskEither-based pipe chains, stacked null checks to an Option chain, multi-field validation to E.Do/E.bind, and Promise chains to TaskEither.

import { pipe } from 'fp-ts/function'

const result = pipe(
  input,
  parse,
  validate,
  format
)

Use it when writing TypeScript against the fp-ts library and you want cleaner handling of nullable values, expected errors, or async operations without adopting the full academic FP vocabulary. The skill is explicit about when to skip FP entirely: simple null checks (prefer built-in optional chaining, user?.address?.city ?? 'Unknown', over an Option chain), simple loops that need early exit, performance-critical hot paths (fp-ts's A.reduce allocates intermediate structures a plain for loop avoids), and any code a teammate unfamiliar with FP will have to maintain - "if you're the only one who can read the code, it's not good code." The governing rule throughout: if functional programming makes the code harder to read, don't use it.

This is a pattern reference, not a runnable tool - each pattern is TypeScript source meant to replace an equivalent imperative idiom. A included cheat-sheet table maps plain-language intent to the fp-ts call: "wrap this nullable" to O.fromNullable(x), "use this if nothing" to O.getOrElse(() => default), "worked, here's the value" to E.right(value), "failed, here's why" to E.left(error), "try this, catch errors" to E.tryCatch(fn, onError), and "chain operations" to pipe(x, fn1, fn2, fn3).

Built entirely on the fp-ts library's own modules - Option (O), Either (E), Array (A), and TaskEither (TE) for async operations that can fail - with no other external dependency. It points toward further fp-ts concepts (Validation for collecting all errors instead of stopping at the first, Reader for dependency injection without classes, and Do notation) as the next step once these five basics are comfortable.

TypeScript developers already using or adopting fp-ts who want a practical on-ramp - the guide's explicit test for every pattern is "would a junior developer understand this?" - rather than a from-first-principles functional-programming education.