Closures interview questions

Implement a setInterval wrapper that returns a function which stops the interval when invoked.

Implement a setTimeout wrapper that returns a function you can call to cancel the pending callback.

Implement a function that composes functions right-to-left so the output of each feeds into the next.

Implement a function that, given several values, returns a function that yields each one in turn and loops forever.

Implement a function that delays invoking another function until a specified period of inactivity has passed.

Implement a factory that takes a starting integer and returns a function that returns the next value on each call.

Implement a function that returns the count of arguments passed to it at call time.

Implement a function that wraps a callback so it runs at most one time and reuses that result thereafter.

Buffer bursty streamed text and emit it one character at a time at a steady cadence, with flush and stop controls.

Implement a hook that returns a ref always holding the newest value, so callbacks and effects can read it without going stale.

Implement before and after — cap how many times a function runs, or delay invoking it until the Nth call.

Implement a wrapper that intercepts console.log calls and records their arguments for later inspection.

Implement a function that transforms a multi-argument function into a chain of single-argument calls.

Implement a flexible curry where each call can supply any number of arguments until the original arity is reached.

Extend curry with placeholder support, so arguments can be supplied in any position across calls.

Extend debounce with cancel and flush methods to abort or immediately invoke pending calls.

Extend debounce with a maxWait option that forces a call after a maximum delay even under constant activity.

Build a DI container that resolves a service dependency graph, caches singletons, and detects circular dependencies.

Implement flow — compose functions left to right so each output feeds the next.

Implement Function.prototype.myBind — return a new function with a fixed `this` and optional preset arguments.

Implement a function that wraps a callback so it runs at most N times and returns the last result thereafter.

Implement a factory that returns a counter object with methods to read, increment, decrement, and reset its value.

Implement a function that caches results of a single-argument function so repeat calls return instantly.

Extend memoize with a custom key resolver and cache controls (.clear() and .delete(key)).

Build atom-based state with primitive and derived atoms that recompute and notify subscribers on change.

Build a Redux core with createStore, combineReducers, and applyMiddleware over a subscribe/dispatch loop.

Implement negate, overEvery, and overSome — build new predicates by combining existing ones.

Implement partial and partialRight — pre-fill some of a function's arguments, with placeholder support.

Implement a function that wraps a Node-style error-first callback function so it returns a promise.

Extend promisify so the wrapped function can override the resolved value via a custom override hook.

Implement the curried Redux middleware chain with working thunk and logger middleware.

Build reactive signals with automatic dependency tracking so computed values and effects update on change.

Implement a Singleton class that always hands back the same instance no matter how many times you construct it.

Implement a curried sum function that accepts numbers one call at a time and returns the running total when invoked with none.

Implement a function that limits how often a wrapped function can be invoked within a time window.

Extend throttle with cancel and flush methods plus leading and trailing edge options.

Implement a useState variant that also returns a getter for reading the newest state from inside stale closures.

Implement a hook that runs a callback after a given delay and cleans up when the component unmounts.

Implement a curry helper that turns a variadic function into one that can be called repeatedly with any number of arguments.