The Relationship Between Closures and Higher-Order Functions

The Relationship Between Closures and Higher-Order Functions

Higher-order functions and closures are deeply connected. Closures are what make HOFs like compose, curry, and memoize work.

How HOFs Use Closures

When a HOF returns a function, the returned function closes over the HOF's local variables. This is a closure.

Example: multiplier

function multiplier(factor) {
  return (n) => n * factor;
}
const double = multiplier(2);
double(5); // 10
``
The returned arrow closes over `factor`. Even after `multiplier` returns, `double` can access `factor` via its closure.

### Example: `compose`

```js
function compose(f, g) {
  return (x) => f(g(x));
}
const h = compose(double, addOne);
``
The returned function closes over `f` and `g`. Each call to `h` invokes `f(g(x))` using the closed-over functions.

### Example: `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];
  };
}
``
The returned function closes over `cache` and `fn`. The cache persists across calls.

### Example: `curry`

```js
function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) return fn(...args);
    return (...next) => curried(...args, ...next);
  };
}
``
Each partial call returns a new function that closes over the accumulated `args`.

### Why Closures Are Essential for HOFs

Without closures, a returned function could not access the HOF's local variables. `multiplier` could not return a function that remembers `factor`. `memoize` could not remember `cache`. HOFs that return functions rely on closures to persist state.

### The Takeaway

Closures are what make higher-order functions work. When a HOF returns a function, the returned function closes over the HOF's local variables. This is how `multiplier`, `compose`, `memoize`, `curry`, `debounce`, and `throttle` persist state across calls. Without closures, HOFs that return functions would not be possible.