Problem Description

This problem asks you to implement a function that mimics the behavior of Promise.all() without using the built-in method. You need to create a function called promiseAll that takes an array of asynchronous functions as input.

Each function in the input array:

• Takes no arguments
• Returns a promise when called

Your promiseAll function should return a new promise that behaves as follows:

Success Case:

• The returned promise should resolve when ALL promises from the input functions have resolved successfully
• The resolved value should be an array containing all the resolved values
• The order of values in the result array must match the order of functions in the input array
• All functions should execute in parallel (not sequentially)

Failure Case:

• If ANY promise rejects, the returned promise should immediately reject
• The rejection reason should be the same as the first promise that rejected
• Once a rejection occurs, it doesn't matter if other promises are still pending

For example, if you have three async functions that resolve to values [1, 2, 3], your function should return a promise that resolves to [1, 2, 3]. But if the second function rejects with error "failed", your promise should reject with "failed" regardless of whether the other functions succeed.

The solution uses a counter to track completed promises and an array to store results at their correct indices. When the counter reaches the total number of functions, all promises have resolved and the result array is returned. If any promise rejects, the entire operation immediately rejects with that error.

Intuition

To understand how to solve this problem, let's think about what Promise.all needs to accomplish. We have multiple asynchronous operations running in parallel, and we need to know when they're all done while preserving their order.

The key insight is that we need to track two things:

1. How many promises have completed - to know when we're done
2. The results in their original order - even though promises may resolve in any order

Since promises can resolve at different times, we can't just push results into an array as they come in - that would lose the original ordering. Instead, we need to place each result at its specific index position.

Think of it like waiting for multiple friends to arrive at a party. You have a list of who's coming, and you need to know when everyone has arrived. Each friend might arrive at different times, but you want to remember them in the order they were on your original guest list, not the order they showed up.

This leads us to use:

• A counter (cnt) to track how many promises have resolved
• A pre-allocated array (ans) where we can place results at their correct indices
• A loop with closures to capture each index i, ensuring each promise's result goes to the right spot

For error handling, we adopt a "fail-fast" approach - as soon as any promise rejects, we immediately reject the entire operation. This is like a chain being only as strong as its weakest link. We don't need to wait for other promises because the overall operation has already failed.

The wrapper new Promise((resolve, reject) => {...}) gives us control over when to resolve (when counter equals array length) or reject (on first error) the overall promise.

Solution Approach

Let's walk through the implementation step by step:

1. Create a wrapper promise:

return new Promise<T[]>((resolve, reject) => {
    // Implementation here
});

We wrap everything in a new promise that we can control - deciding when to resolve with all results or reject with an error.

2. Initialize tracking variables:

let cnt = 0;
const ans = new Array(functions.length);

• cnt tracks how many promises have successfully resolved
• ans is a pre-allocated array with the same length as the input functions array to store results at their correct positions

3. Execute all functions in parallel:

for (let i = 0; i < functions.length; ++i) {
    const f = functions[i];
    f()
        .then(res => {
            // Handle success
        })
        .catch(err => {
            // Handle failure
        });
}

The loop immediately invokes all functions without waiting for any to complete. Each function call returns a promise that we attach handlers to.

4. Handle successful resolution:

.then(res => {
    ans[i] = res;
    cnt++;
    if (cnt === functions.length) {
        resolve(ans);
    }
})

When a promise resolves:

• Store the result at index i in the ans array (preserving order)
• Increment the counter
• Check if all promises are done (cnt === functions.length)
• If all are complete, resolve the main promise with the complete results array

5. Handle rejection:

.catch(err => {
    reject(err);
})

If any promise rejects, immediately reject the main promise with the same error. This implements the "fail-fast" behavior where the first rejection causes the entire operation to fail.

Key implementation details:

• The closure in the loop captures the value of i for each iteration, ensuring each result goes to the correct index
• All functions are invoked immediately in the loop, achieving parallel execution
• The counter approach avoids needing to check the array for completion on every resolution
• No additional error tracking is needed since we reject on the first error

This implementation efficiently handles both the happy path (all succeed) and error cases (any failure) while maintaining the correct order of results.

Example Walkthrough

Let's walk through a concrete example with 3 async functions to see how the solution works:

Input functions:

• fn1: resolves with value 10 after 100ms
• fn2: resolves with value 20 after 50ms
• fn3: resolves with value 30 after 150ms

Step-by-step execution:

1. Initialization (t=0ms):

   • Create wrapper promise
   • Set cnt = 0
   • Create ans = [undefined, undefined, undefined] (array of length 3)

2. Start all functions (t=0ms):

   • Loop executes immediately:
     • i=0: Call fn1(), attach .then() and .catch() handlers
     • i=1: Call fn2(), attach .then() and .catch() handlers
     • i=2: Call fn3(), attach .then() and .catch() handlers
   • All three functions are now running in parallel

3. First resolution (t=50ms):

   • fn2 resolves with 20 (it's the fastest)
   • Its .then() handler executes with i=1:
     • ans[1] = 20 → ans = [undefined, 20, undefined]
     • cnt = 1
     • Check: cnt (1) !== functions.length (3), so continue waiting

4. Second resolution (t=100ms):

   • fn1 resolves with 10
   • Its .then() handler executes with i=0:
     • ans[0] = 10 → ans = [10, 20, undefined]
     • cnt = 2
     • Check: cnt (2) !== functions.length (3), so continue waiting

5. Final resolution (t=150ms):

   • fn3 resolves with 30
   • Its .then() handler executes with i=2:
     • ans[2] = 30 → ans = [10, 20, 30]
     • cnt = 3
     • Check: cnt (3) === functions.length (3) ✓
     • Call resolve(ans) with [10, 20, 30]

Result: The wrapper promise resolves with [10, 20, 30] - values are in the original order despite fn2 finishing first.

Alternative scenario with rejection:

If fn2 had rejected with error "Network error" at t=50ms:

• Its .catch() handler would execute immediately
• Call reject("Network error")
• The wrapper promise rejects with "Network error"
• fn1 and fn3 continue running but their results are ignored

This demonstrates how the solution maintains order through indexed assignment and implements fail-fast behavior on errors.

Solution Implementation

Time and Space Complexity

Time Complexity: O(n) where n is the number of functions in the input array.

The code iterates through the array of functions once with a for loop, and for each function, it invokes it and attaches .then() and .catch() handlers. The iteration itself takes O(n) time. Each promise is executed asynchronously and in parallel, so the actual execution time depends on the slowest promise to resolve, but the setup and handling of promises is O(n).

Space Complexity: O(n) where n is the number of functions in the input array.

The space complexity includes:

• The ans array which stores the results of all promises: O(n)
• The closure variables (cnt, resolve, reject) which are constant: O(1)
• Each promise's .then() and .catch() handlers create closures that capture the index i and reference to ans, cnt, resolve, and reject: O(n) total for all handlers

Therefore, the overall space complexity is O(n).

Common Pitfalls

1. Using the Loop Variable Directly in Callbacks (JavaScript/TypeScript)

Pitfall: A classic mistake is capturing the loop variable incorrectly in the promise handlers:

// WRONG - This will not preserve the correct order
for (var i = 0; i < functions.length; i++) {
    functions[i]()
        .then(res => {
            ans[i] = res;  // Bug: 'i' will be functions.length for all callbacks
            cnt++;
            if (cnt === functions.length) {
                resolve(ans);
            }
        })
        .catch(reject);
}

Why it fails: When using var, the variable i is function-scoped, not block-scoped. By the time the promises resolve, the loop has completed and i equals functions.length for all callbacks, causing all results to be stored at an invalid index.

Solution: Use let for block scoping or create a closure:

// Solution 1: Use 'let' for block scoping
for (let i = 0; i < functions.length; i++) {
    // 'i' is now block-scoped and captured correctly
}

// Solution 2: Create an IIFE closure
for (var i = 0; i < functions.length; i++) {
    (function(index) {
        functions[index]()
            .then(res => {
                ans[index] = res;
                // ...
            })
    })(i);
}

2. Not Handling Empty Arrays

Pitfall: Forgetting to handle the edge case when the input array is empty:

// This works but could be more explicit
if (cnt === functions.length) {  // When length is 0, this never triggers
    resolve(ans);
}

Solution: Add explicit handling for empty arrays:

if (functions.length === 0) {
    resolve([]);
    return;
}

3. Sequential Execution Instead of Parallel (Python)

Pitfall: Accidentally awaiting each coroutine in sequence:

# WRONG - This executes sequentially
results = []
for func in functions:
    result = await func()  # Waits for each one to complete before starting the next
    results.append(result)

Solution: Create all coroutines first, then await them together:

# Correct - Executes in parallel
coroutines = [func() for func in functions]
results = await asyncio.gather(*coroutines)

4. Not Preserving Order When Using Manual Tracking

Pitfall: Appending results as they arrive instead of placing them at their original index:

// WRONG - Order is not preserved
functions[i]()
    .then(res => {
        ans.push(res);  // Results will be in completion order, not original order
        cnt++;
        if (cnt === functions.length) {
            resolve(ans);
        }
    })

Solution: Always use the index to place results:

// Correct - Preserves original order
ans[i] = res;  // Place at specific index

5. Memory Leaks with Unhandled Rejections

Pitfall: When implementing manual cancellation in Python, forgetting to properly clean up tasks:

# Potential issue - tasks might not be properly cancelled
for index, task in tasks:
    try:
        result = await task
    except Exception as error:
        # Other tasks continue running in the background
        raise error

Solution: Ensure all pending tasks are cancelled on failure:

except Exception as error:
    # Cancel all remaining tasks
    for _, remaining_task in tasks:
        if not remaining_task.done():
            remaining_task.cancel()
    raise error