Generate Reusable Code Pipelines with fp-ts
A quick reference for fp-ts's pipe and flow, covering value transforms, reusable pipelines, and Option/Array chaining.
Why it matters
Streamline your TypeScript development by generating reusable data transformation pipelines using the fp-ts library's `pipe` and `flow` functions. This asset helps create elegant, functional code for transforming values and building complex operations.
Outcomes
What it gets done
Generate TypeScript code using `pipe` for single value transformations.
Create reusable transformation functions with `flow`.
Apply functional programming patterns for data manipulation with fp-ts.
Understand and implement common data processing patterns.
Install
Add it to your toolbox
Run in your project directory:
curl -fsSL https://spark.entire.vc/get/ag-fp-pipe-ref | bash Overview
pipe & flow Quick Reference
A quick reference distinguishing fp-ts's pipe (transform a value now) from flow (build a reusable pipeline), with Option and Array chaining examples. Reach for this when composing fp-ts transformations and unsure whether to use pipe for a one-off value or flow for a reusable function.
What it does
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.
When to use - and when NOT to
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.
Inputs and outputs
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.
Integrations
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.
Who it's for
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.
FAQ
Common questions
Discussion
Questions & comments · 0
Sign In Sign in to leave a comment.