Promises interview questions

Implement a countdown latch whose wait resolves once countDown has been called the required number of times.

Run async tasks in sequence, feeding each result into the next, stopping the chain on the first rejection.

Implement Promise.race so it settles with the outcome of whichever input promise settles first.

Implement a function that returns a Promise already rejected with the given reason.

Implement a function that returns a promise resolving after the specified number of milliseconds.

Fetch with a timeout that aborts the request via AbortController and honors an external abort signal.

Implement Array.fromAsync: build a promise of an array from a sync or async iterable, awaiting each value in order.

Implement an async debounce that resolves only the newest call and discards the results of superseded ones.

Implement an async mutex whose acquire returns a release function, serializing access so only one holder runs at a time.

Implement an async semaphore that admits up to N concurrent holders and queues the rest until a permit frees.

Implement a task queue that runs async jobs under a concurrency limit and resolves an idle promise when drained.

Wrap a promise so it can be cancelled — the wrapper rejects on cancel and ignores the underlying settlement.

Implement a function that applies an async mapper to every item in an array and resolves with the results.

Coalesce all schedule calls made in one synchronous frame into a single flush on the next microtask.

Implement pollUntil — call an async function on an interval until a predicate passes or a timeout elapses.

Implement a function that combines the results of two promises into a single value using a merger function.

Implement a promise pool that runs task factories with a concurrency cap and resolves to their results in order.

Implement a function that races a promise against a timer and rejects if the promise doesn't settle in time.

Implement Promise.all so it resolves with an array of results or rejects on the first rejection.

Implement Promise.allSettled from scratch, resolving to an array of fulfilled or rejected outcomes for each input.

Implement Promise.any so it resolves with the first fulfilled value or rejects with an AggregateError.

Implement Promise.resolve — wrap a value in a fulfilled promise, returning thenables unchanged and adopting their state.

Implement Promise.withResolvers — return a new promise alongside its external resolve and reject functions.

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 retry — re-run a failing async function with a delay that grows exponentially between attempts.

Implement singleflight so concurrent calls for the same key share one in-flight promise instead of duplicating work.

Implement a hook that tracks the loading, data, and error states of a promise-returning request.

Implement Node-style async runners — run error-first tasks in parallel or in series and collect their results.

Implement a read-write lock that allows many concurrent readers or one exclusive writer without starving writers.

Implement an async map that processes an array with a bounded number of in-flight tasks.

Extend a tiny test runner so it correctly awaits asynchronous specs and asynchronous setup or cleanup hooks.