Functional Programming

Memoization caches a function's result keyed by its arguments, so a repeat call with the same inputs returns the stored value instead of recomputing. It only helps for pure functions whose result depends solely on arguments, and pays off when the same inputs recur and the computation is expensive. It trades memory for speed, so caching cheap or rarely-repeated calls just wastes space.

A pure function returns the same output for the same inputs and produces no side effects — it does not mutate external state, do I/O, or depend on anything but its arguments. For example, (a, b) => a + b is pure, while one that pushes to an outer array or reads Date.now() is impure. Purity makes code predictable and easy to test.

A rest parameter ...args collects the remaining arguments into a real Array, so array methods like map work directly, and it holds only the named-after parameters. The arguments object is array-like but not an array, lacks those methods, and always holds every argument. Arrow functions have no arguments, so rest is the modern choice.

Both combine several functions so one's output feeds the next's input, producing a single new function. They differ only in direction: compose(f, g)(x) runs right-to-left as f(g(x)), while pipe(f, g)(x) runs left-to-right as g(f(x)). They are not built in, and they work best with pure single-argument functions.

Currying transforms a function of many arguments into a chain of nested functions that each take exactly one argument. So (a, b, c) => a + b + c becomes a => b => c => a + b + c, called as f(1)(2)(3). Each call captures its argument in a closure and returns the next function, enabling partial application and reuse.

Wrap the function and hold a Map in the closure; on each call build a cache key from the arguments, return the cached value if present, otherwise compute, store, and return. The pitfall is the key: objects and arrays stringify to the same [object Object], so keying naively collides distinct inputs, and JSON.stringify ignores argument order across keys and drops functions. A Map allows non-string keys but only matches objects by identity.

Partial application fixes some of a function's arguments up front, producing a new function that takes the rest; fn.bind(null, 1) pre-fills the first argument. Currying instead transforms an n-ary function into a chain of single-argument functions, each returning the next. So partial application supplies any number of args once and returns one function, while currying always takes one arg at a time across many calls.

Arity is the number of parameters a function declares. fn.length counts only the parameters before the first one with a default value or the rest parameter, so (a, b) => {} is 2 but (a, b = 1, ...r) => {} is 1. A parameter is the named slot in the declaration; an argument is the actual value passed at call time. Functions with no name are anonymous.

A mixin is an object of reusable methods copied onto a target with Object.assign(Class.prototype, mixin), letting many unrelated classes share behaviour without a common ancestor. Unlike inheritance, which gives one linear prototype chain and an is-a relationship, mixins compose several independent capabilities and express has-a. The cost is that copied methods overwrite same-named ones silently, with no super to reach the original.

Referential transparency means an expression can be replaced by its value without changing the program — pure functions are transparent, so add(2, 3) can become 5. A side effect is any state change beyond the return value: I/O, DOM edits, mutating inputs, Math.random(), or reading the clock. Point-free style composes functions without naming their arguments, building behaviour from small pure pieces.

A thunk is a zero-argument function wrapping a deferred computation, so the work runs only when called — useful for lazy evaluation. The functional technique point-free style builds functions by composing others without naming the arguments. Memoization hurts when inputs rarely repeat or are hard to key, growing an unbounded cache for no gain. Partial application hurts when it hides argument order or fixes the wrong leading slot, making call sites obscure.