@ts-delight/pipe

Type-safe left-to-right functional pipeline composition

Features

1. No ad-hoc limit on steps being composed
2. Supports async
3. Supports both eager and lazy invocations
4. No dependencies

Installation

npm install --save @ts-delight/pipe

Usage

Eager evaluation

1import {pipe} from "@ts-delight/pipe";
2
3const result = pipe(10).thru((i: number) => i + 1).thru((i: number) => `Result: ${i}`).value;
4//                   |           ^
5//                   |___________|
6//                         |
7//                         Type of input must match input of first step
8//
9// result: string = "Result: 11"
10//         ^        ^
11//         |        |__ Result of left-to-right composition
12//         |
13//         |__ Output type inferred from output type of last step
14//

Eager evaluation with async steps

1import {pipe} from "@ts-delight/pipe";
2
3const result = pipe(10)
4    .thruAsync(async (i: number) => i + 1)
5    .thru((i: number) => `Result: ${i}`)
6    .value;
7// result: Promise<string>

Lazy evaluation with sync steps

1import {pipeFn} from "@ts-delight/pipe";
2
3const {fn} = pipeFn()
4    .thru((i: number) => i + 1)
5    .thru((i: nmber) => `Result: ${i}`);
6// fn: (i: number) => string;
7
8fn(10); // => "Result: 11"

Lazy evaluation with async steps

1import {pipeFnAsync} from "@ts-delight/pipe";
2
3const {fn} = pipeFnAsync()
4    .thru(async (i: number) => i + 1)
5    .thru(async (i: nmber) => `Result: ${i}`);
6// fn: (i: number) => Promise<string>;
7
8fn(10); // => Promise which resolves to "Result: 11"