Generate Reusable Code Pipelines with fp-ts

A quick reference for fp-ts's two core composition helpers. pipe(startValue, fn1, fn2, fn3) applies functions left to right to a single value right now, equivalent to fn3(fn2(fn1(startValue))) - e.g. trimming, uppercasing, then splitting a string. flow(fn1, fn2, fn3) composes the same kind of chain but returns a reusable function instead of running it immediately, so the same pipeline can be called against multiple different inputs.

Use pipe when you want to transform one specific value right now. Use flow when you want to create a reusable transformation you'll call more than once - for example a flow-built function reused across two different arrays. It's a reference for fp-ts's function-composition utilities specifically, not a general guide to fp-ts's whole type system.

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

const result = pipe(
  '  hello world  ',
  s => s.trim(),
  s => s.toUpperCase(),
  s => s.split(' ')
)
// ['HELLO', 'WORLD']

The reference also covers combining pipe/flow with fp-ts's Option and Array modules: an Option chain (O.fromNullable, O.map, O.getOrElse) for safely unwrapping a nullable value with a fallback, and an Array chain (A.filter, A.map) for filtering then mapping a collection.

Built on fp-ts's function module (pipe, flow) alongside its Option (O) and Array (A) modules, which supply the composable functions passed into a pipeline.

TypeScript developers using fp-ts who need a fast reminder of when to reach for pipe versus flow, including the data-last pattern that lets a flow-built function - such as filtering active users then mapping their names - be reused across different inputs.