Apply pragmatic functional programming patterns in TypeScript

Pragmatic Functional Programming is an 80/20 entry point to fp-ts built around one golden rule: if functional programming makes code harder to read, don't use it - FP is a tool, not a religion. It identifies five patterns that deliver most of the benefit - pipe for chaining 3+ transformations in reading order, Option for nullable chains without cascading null checks, Either for making failure explicit instead of throwing, map for transforming values inside a container without unpacking them, and flatMap for chaining operations that might each fail - and explicitly tells the reader to master these before exploring anything else.

Use it as a pragmatic starting point for fp-ts in TypeScript, or for an exploratory/educational 80/20 view of what's actually worth adopting versus academic functional-programming theory. It devotes an entire section to when NOT to use FP: simple null checks are better served by native optional chaining (user?.address?.city ?? 'Unknown') than an Option chain, a plain for loop beats forcing A.findFirst/O.toNullable when early exit or complex logic is involved, performance-critical hot paths favor imperative code over fp-ts's intermediate-array-creating combinators, and any pattern the team can't read is bad code regardless of theoretical elegance - "if you're the only one who can read the code, it's not good code."

Its "quick wins" section gives concrete before/after refactors: nested ternaries become pipe plus O.fold, scattered try/catch becomes one E.tryCatch plus E.getOrElse, functions returning undefined become functions returning Option (forcing callers to handle the missing case), plain error strings become structured typed errors, and hand-rolled error variants become tagged unions ({ _tag: 'NotFound' as const, id }) matched with a switch. The readability rule is illustrated directly: a "too clever" one-liner chaining flow/prop/equals/monoid is shown next to both a plain imperative version and a "middle ground" pipe version, with guidance to prefer whichever a junior developer would actually understand.

const getUserCity = (user: User | null): string =>
  pipe(
    O.fromNullable(user),
    O.flatMap(u => O.fromNullable(u.address)),
    O.getOrElse(() => 'Unknown')
  )

Built on fp-ts's Option, Either, Array, and function (pipe) modules for the core patterns, with a cheat-sheet table translating each fp-ts call into plain language, and pointers toward TaskEither, the validation applicative, Reader, and Do-notation as the next tier once these five patterns feel natural.

TypeScript developers deciding whether and how much functional-programming style to adopt in a real codebase - especially teams new to fp-ts who need a judgment framework for when FP genuinely improves a piece of code versus when it's over-engineering a simple null check or loop.