pipe and combine

Readability is important because code is read more often than it is written. This library contains a pipe function to call functions without nesting them. by writing them in a nice way without nesting and taking care of getting the value and passing it to the next function.

1import { pipe } from "pipe-and-combine";
2
3const pipeline = pipe(add(1), multiply(2), subtract(1));
4
5const result = pipeline(3); // result -> 7

Installation

1    npm install pipe-and-combine

Usage

The main function this library provides is pipe and combine, but there are some helper functions to make it easier to use. They currently not all documentend here, but will follow soon.

Pipe

The usual pipe function will simply chain your functions together. It automatically detects if the functions are async or not and handles the return value accordingly. So with Version 0.7.x you have to think less about async or sync pipe functions.

1// general functions
2const inc = (by: number) => (x: number) => x + by;
3const dec = (by: number) => (x: number) => x - by;
4const multiplyBy = (by: number) => (x: number) => x * by;
5const divideBy = (by: number) => (x: number) => x / by;
6const toStr = () => (x: number) => x.toString();
7
8// prepare the pipeline
9const pipeline = pipe(inc(2), multiplyBy(7), dec(7), divideBy(3), toStr());
10
11// execute the pipeline
12expect(pipeline(2)).toBe("7");

1const double = (x: number) => x * 2;
2const increment = async (x: number) => Promise.resolve(x + 1);
3const square = async (x: number) =>
4  new Promise<number>((resolve) => setTimeout(() => resolve(x * x), 100));
5const toStr = (x: number) => x.toString();
6
7const pipeline = pipe(double, increment, square, increment, toStr);
8await expect(pipeline(2)).resolves.toBe("26");

Pre prepare the pipe

While pipe just takes the Input and Output of the functions, you can use preparePipe to prepare the pipe with the input and output value.

1// in this case the first function needs to takes a number and the last function returns a string
2const pipe = preparePipe<[number], string>();
3// but you can also define multiple input values
4const pipe = preparePipe<[number, string], string>();
5// without types it is the same as above
6const pipe = preparePipe();
7// to only define one of the set the other to any
8const pipe = preparePipe<any, string>();

Run

run is a directly executing pipe. Instead of pipe(...fus)(), you could write run(...fus)

Combine

The combine calls functions in the order they are passed and wait for async ones. All function get called with the same arguments.

1const add = (a: number, b: number) => a + b;
2const multiply = (a: number, b: number) => a * b;
3const divide = async (a: number, b: number) => a / b;
4const other = (a: number, b: number) => (a - b).toString();
5const str = (a: number) => a.toString();
6
7const c = combine(add, multiply, divide, other, str);
8expect(c(1, 2)).toEqual([3, 2, 0.5, "-1", "1"]);

Helper functions

apply

apply will take a function and apply an array returned by an other function as arguments.

1const init = () => ["text", 5];
2const repeat = (text: string, times: number) => text.repeat(times);
3const pipeline = pipe(init, apply(repeat));
4expect(pipeline()).toBe("texttexttexttexttext");

map

map could iterate over an array and call a function for each element, like Array.prototype.map.

addDate (generic) (experimental)

This function adds a date to an object and returns the object with the date. It has a required parameter key to define the name of key where the date should be stored.

1pipe(init(), addDate("createdAt"));
2// addDate will add a filed createdAt to the object given by init

omit

Removes one or more keys from an object.

1pipe(omit("text", "createdAt"));

pick

Picks one or more keys from an object.

1pipe(pick("text", "createdAt"));

Experimental

With Version 0.7.x we introduced a new experimental feature to handle generic types. This is a very powerful feature, but also very complex to get typesafe.

1import { pipe, addDate, g } from "pipe-and-combine";
2type InitObject = { text: string };
3const init = () => () => ({ text: "my cool data object " });
4const count = (word: string) =>
5  g((data: { text: string }) => {
6    // just a simple example to show how to handle generic types
7    return {
8      amount: data.text.split(word).length - 1;
9    }
10  };
11
12const pipeline = pipe(init, addDate('createdAt'), count("cool"));

What is the g function?

At least it do a merge of the input and the output of the given function, but on the type level it do much more. It brand the function to know how to henadle the type. Because otherwise information about the type is lost.

Changelog

You can find the changelog in the CHANGELOG.md file.