Problem

Given an array of asynchronous functions functions, return a new promise promise. Each function in the array accepts no arguments and returns a promise. All the promises should be executed in parallel.

promise resolves:

  • When all the promises returned from functions were resolved successfully in parallel. The resolved value of promise should be an array of all the resolved values of promises in the same order as they were in the functions. The promise should resolve when all the asynchronous functions in the array have completed execution in parallel.

promise rejects:

  • When any of the promises returned from functions were rejected. promise should also reject with the reason of the first rejection.

Please solve it without using the built-in Promise.all function.

Examples

Example 1

1
2
3
4
5
6
7
8

Input: functions = [
  () => new Promise(resolve => setTimeout(() => resolve(5), 200))
]
Output: {"t": 200, "resolved": [5]}
Explanation: 
promiseAll(functions).then(console.log); // [5]

The single function was resolved at 200ms with a value of 5.

Example 2

1
2
3
4
5
6

Input: functions = [
    () => new Promise(resolve => setTimeout(() => resolve(1), 200)), 
    () => new Promise((resolve, reject) => setTimeout(() => reject("Error"), 100))
]
Output: {"t": 100, "rejected": "Error"}
Explanation: Since one of the promises rejected, the returned promise also rejected with the same error at the same time.

Example 3

1
2
3
4
5
6
7

Input: functions = [
    () => new Promise(resolve => setTimeout(() => resolve(4), 50)), 
    () => new Promise(resolve => setTimeout(() => resolve(10), 150)), 
    () => new Promise(resolve => setTimeout(() => resolve(16), 100))
]
Output: {"t": 150, "resolved": [4, 10, 16]}
Explanation: All the promises resolved with a value. The returned promise resolved when the last promise resolved.

Constraints

  • functions is an array of functions that returns promises
  • 1 <= functions.length <= 10

Solution

Method 1 – Manual Promise Coordination (No Promise.all)

Intuition

We need to run all asynchronous functions in parallel and resolve with their results in order, or reject if any fails. We cannot use Promise.all, so we manually track completion and results.

Approach

  1. Create a new Promise.
  2. For each function in the array:
    • Call it immediately to start all in parallel.
    • On resolve, store the result at the correct index and increment a counter.
    • On reject, reject the main promise immediately (if not already rejected).
  3. When all have resolved, resolve the main promise with the results array.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

function promiseAll(functions) {
    return new Promise((resolve, reject) => {
        const n = functions.length;
        const results = new Array(n);
        let resolvedCount = 0;
        let finished = false;
        if (n === 0) return resolve([]);
        functions.forEach((fn, i) => {
            fn().then(res => {
                if (finished) return;
                results[i] = res;
                resolvedCount++;
                if (resolvedCount === n) {
                    finished = true;
                    resolve(results);
                }
            }, err => {
                if (!finished) {
                    finished = true;
                    reject(err);
                }
            });
        });
    });
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

function promiseAll<T>(functions: (() => Promise<T>)[]): Promise<T[]> {
    return new Promise((resolve, reject) => {
        const n = functions.length;
        const results: T[] = new Array(n);
        let resolvedCount = 0;
        let finished = false;
        if (n === 0) return resolve([]);
        functions.forEach((fn, i) => {
            fn().then(res => {
                if (finished) return;
                results[i] = res;
                resolvedCount++;
                if (resolvedCount === n) {
                    finished = true;
                    resolve(results);
                }
            }, err => {
                if (!finished) {
                    finished = true;
                    reject(err);
                }
            });
        });
    });
}

Complexity

  • ⏰ Time complexity: O(n), where n is the number of functions.
  • 🧺 Space complexity: O(n), for the results array.