Higher-Order Function Patterns in JavaScript

Higher-Order Function Patterns in JavaScript

Here are the most common higher-order function patterns and how to implement each.

1. compose (Right to Left)

function compose(...fns) {
  return (x) => fns.reduceRight((acc, fn) => fn(acc), x);
}
const addOne = (n) => n + 1;
const double = (n) => n * 2;
const result = compose(double, addOne)(5); // 12 (addOne first, then double)
``
### 2. pipe (Left to Right)

```js
function pipe(...fns) {
  return (x) => fns.reduce((acc, fn) => fn(acc), x);
}
const result = pipe(addOne, double)(5); // 12 (addOne first, then double)
``
`pipe` is like `compose` but left-to-right (more natural to read).

### 3. curry

```js
function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) return fn(...args);
    return (...next) => curried(...args, ...next);
  };
}
const sum = curry((a, b, c) => a + b + c);
sum(1)(2)(3); // 6
sum(1, 2)(3); // 6
``
### 4. partial

```js
function partial(fn, ...presetArgs) {
  return (...laterArgs) => fn(...presetArgs, ...laterArgs);
}
const add = (a, b, c) => a + b + c;
const add5 = partial(add, 5);
add5(3, 2); // 10
``
### 5. memoize

```js
function memoize(fn) {
  const cache = {};
  return (...args) => {
    const key = JSON.stringify(args);
    if (!(key in cache)) cache[key] = fn(...args);
    return cache[key];
  };
}
``
### 6. debounce

```js
function debounce(fn, delay) {
  let timer;
  return (...args) => {
    clearTimeout(timer);
    timer = setTimeout(() => fn(...args), delay);
  };
}
``
### 7. throttle

```js
function throttle(fn, delay) {
  let last = 0;
  return (...args) => {
    const now = Date.now();
    if (now - last >= delay) {
      last = now;
      fn(...args);
    }
  };
}
``
### 8. once

```js
function once(fn) {
  let done = false;
  let result;
  return (...args) => {
    if (done) return result;
    done = true;
    result = fn(...args);
    return result;
  };
}
``
### The Takeaway

Common HOF patterns: `compose` (right to left), `pipe` (left to right), `curry` (one arg at a time), `partial` (preset some args), `memoize` (cache results), `debounce` (delay until activity stops), `throttle` (limit rate), `once` (run only once). All rely on closures and first-class functions.