fp-pipe-flow_skill

Overview

This skill teaches function composition in fp-ts using pipe and flow to build elegant, type-safe data transformation pipelines. It focuses on practical patterns for synchronous and asynchronous workflows with fp-ts types like Option, Either, Task, and ReaderTaskEither. Expect clear rules for when to use pipe vs flow, currying and arity handling, error handling patterns, and examples you can reuse immediately.

How this skill works

It explains pipe as the immediate execution operator that threads a value through functions, and flow as the deferred composer that returns a new function. The skill shows how to compose unary functions, curry multi-argument functions, and combine fp-ts data types (Option, Either, Task, TaskEither, ReaderTaskEither) into readable pipelines. It also covers parallel vs sequential execution, error accumulation, and Do/sequence patterns.

When to use it

• Use pipe when you have a concrete value and want readable, left-to-right transformation.
• Use flow to define reusable transformation functions or callbacks before you have an input value.
• Use fp-ts combinators (flatMap/map/etc.) inside pipelines to work with Option, Either, Task, and Reader types.
• Use parallel applicatives (ApplicativePar) to run independent async tasks concurrently.
• Use Do notation or sequenceS for dependent steps and clearer error propagation.

Best practices

• Keep each pipeline step small and focused; extract named functions for intent and reuse.
• Prefer flow for reusable transforms and pipe for one-off value flows to improve readability.
• Currying or partial application for multi-argument functions keeps pipelines unary and composable.
• Handle errors at the level where you can respond meaningfully; use Validation/Appplicative to accumulate errors when needed.
• Group related operations and comment pipeline sections (filter, transform, sort) to maintain clarity.

Example use cases

• Transforming and filtering arrays: pipe(users, A.filter(isActive), A.map(formatName), A.sort(...)).
• Fetching and composing async resources: pipe(fetchUser(id), TE.flatMap(fetchUserPosts), TE.map(combine)).
• Validating and accumulating errors: use getApplicativeValidation with Either and sequenceS to report multiple validation failures.
• Environment-dependent flows: ReaderTaskEither pipelines for dependency injection (repos, services, logger).
• Fallback chains: combine Option.alt to try env, file, then defaults for config resolution.