Function Composition

We are going to introduce pipe.

A function named pipe is already provided by several libraries, so you may be familiar with it.

• flow in lodash
• pipe in ramda
• pipe in rxjs.

pipe is a function that connects functions by passing the output of a function to the arguments of another function.

Let's take a moment to see why we need pipe.

There is an array, and you want to get the final result by doing filter -> map -> reduce on this array.

const sum = (a: number, b: number) => a + b;
const arr = [1, 2, 3, 4, 5];
// filter
// map
// reduce

All of the code is pure functions, so it's easy to create a function composition, but it seems to be very difficult to read.

reduce(
  sum,
  map(
    (a) => a + 10,
    filter((a) => a % 2 === 0, arr);
  ),
)

We are providing pipe to solve the above problem.

import { filter, map, pipe, reduce } from "@fxts/core";

pipe(
  arr,
  filter((a) => a % 2 === 0),
  map((a) => a + 10),
  reduce(sum),
);

It looks easy to read when used with pipe.

Check out this article for a comparison with Array.prototype.[Function]

Also, you don't have to deal with Promise values directly.

await pipe(
  Promise.resolve(1),
  (a /*: Awaited<number>*/) => a + 1,
  async (b /*: Awaited<number>*/) => b + 1,
  (c /*: Awaited<number>*/) => c + 1,
); // 4

• a : a is inferred as number, and the actual value is also number, not Promise<number>.
• c : Even if the previous function is an asynchronous function, the argument is not c Promise<number>.

If you're not dealing with async values directly, it doesn't mean that errors can not be handled when occur. To check for error handling, see the Error Handling