The Power of Function Composition in TypeScript

What are Compose and Pipe Functions?

Compose and pipe functions are higher-order functions that take one or more functions as arguments and return a new function that combines the functionality of the input functions. The main difference between compose and pipe functions is the order in which they execute the input functions.

Compose Function

A compose function takes a list of functions and returns a new function that executes the input functions from right to left. The output of each function is passed as the input to the next function in the chain.

function compose<T>(fn1: (value: T) => T, ...fns: ((value: T) => T)[]) {
  return fns.reduce((prevFn, nextFn) => (value: T) => prevFn(nextFn(value)), fn1);
}

Pipe Function

A pipe function takes a list of functions and returns a new function that executes the input functions from left to right. The output of each function is passed as the input to the next function in the chain.

function pipe<T>(fn1: (value: T) => T, ...fns: ((value: T) => T)[]) {
  return fns.reduce((prevFn, nextFn) => (value: T) => nextFn(prevFn(value)), fn1);
}

Using Array.prototype.reduce() to Create Compose and Pipe Functions

We can use the Array.prototype.reduce() method to create compose and pipe functions. The reduce method applies a function to each element of an array and reduces it to a single output value.

function compose<T>(...fns: ((value: T) => T)[]) {
  return fns.reduce((prevFn, nextFn) => (value: T) => prevFn(nextFn(value)));
}

function pipe<T>(...fns: ((value: T) => T)[]) {
  return fns.reduce((prevFn, nextFn) => (value: T) => nextFn(prevFn(value)));
}

Extending the Pipe Function’s Arguments

We can extend the pipe function to accept multiple arguments by using the rest parameter syntax.

function pipe<T, U>(fn1: (...args: T[]) => U, ...fns: ((value: U) => U)[]) {
  return (...args: T[]) => fns.reduce((prevValue, nextFn) => nextFn(prevValue), fn1(...args));
}

By using compose and pipe functions, you can create more readable, maintainable, and efficient code by breaking down complex functions into smaller, reusable functions. Whether you’re new to functional programming or an experienced developer, understanding the concepts of compose and pipe functions can help you write better code.