Higher-Order Functions and Callbacks

## Functions are values In JavaScript a function is an ordinary value — specifically, an object that happens to be callable. Anything you can do with a number you can do with a function: bind it to a variable, store it in an array, use it as an object property, pass it to another function, or return it from one. This is what "first-class functions" means, and it is the entire foundation of the higher-order style. ```js const double = (n) => n * 2; const ops = [double, (n) => n + 1]; // stored in an array const registry = { double }; // stored as a property console.log(typeof double); // "function" ``` Note that `typeof` reports `"function"`, but a function is still an object underneath: it has properties (`double.name` is `"double"`), and you can attach your own. ## The two shapes A higher-order function is any function that **takes a function as an argument**, **returns a function**, or both. Taking a function — the callback shape: ```js function applyTwice(fn, value) { return fn(fn(value)); } applyTwice((n) => n + 3, 1); // 7 ``` `applyTwice` knows nothing about what `fn` does. The caller supplies the behaviour; `applyTwice` supplies the control flow. That inversion is the whole point. Returning a function — the factory shape: ```js function makeAdder(step) { return (n) => n + step; } const addTen = makeAdder(10); addTen(5); // 15 ``` `makeAdder` is called once and produces a specialised function you can call many times. Standard-library examples of the first shape are everywhere: `Array.prototype.map`, `Array.prototype.filter`, `Array.prototype.sort` and `Array.prototype.forEach` all accept a callback; `Object.defineProperty` accepts getter and setter functions. ## Callback is a role, not a type The word *callback* describes a function's role rather than anything about the function itself: it is simply a function that somebody else will call, at a time of their choosing. Any function can be one. The receiving code decides how many arguments to pass it, when to call it, and what to do with its return value — that contract is defined entirely by the higher-order function, and it is why reading the documentation of the callback signature matters. ## Passing versus calling The most common beginner bug is a stray pair of parentheses: ```js function schedule(task) { /* stores task, runs it later */ } schedule(cleanup); // passes the function — usually what you want schedule(cleanup()); // CALLS cleanup now and passes its return value ``` Both lines are valid JavaScript, so nothing throws. The second one runs `cleanup` immediately and then hands `schedule` whatever it returned — very often `undefined`, which then fails much later with a confusing "task is not a function" message. Whenever you write a function name into an argument list, check whether you meant the name or the call. ## Why the pattern is worth learning Higher-order functions let you factor out *what varies*. Instead of writing one loop per operation, you write one traversal that accepts the operation. Instead of ten near-identical validators, you write one validator factory parameterised by a rule. Event-driven and asynchronous APIs are unavoidably higher-order — you cannot hand the runtime code to run later except by handing it a function. Composition helpers, wrappers such as `once` or `memoize`, and middleware chains are all just functions that take and return functions. A small warning about vocabulary: not every function-taking function is worth abstracting. Interviewers ask you to write a higher-order function from scratch mainly to check that you really see a function as a value, not as a piece of syntax that must be immediately invoked. Demonstrating that by writing a four-line factory is worth more than reciting a definition.