Problem Description

This problem asks you to create a wrapper function that adds a timeout feature to any asynchronous function. You need to implement a timeLimit function that takes two parameters:

• fn: an asynchronous function that returns a Promise
• t: a time limit in milliseconds

The timeLimit function should return a new function that behaves as follows:

1. If the original function completes within the time limit: The new function should resolve with the same result as the original function.

2. If the original function takes longer than the time limit: The new function should reject with the string "Time Limit Exceeded".

The solution uses Promise.race() to create a race condition between two promises:

• The original function call fn(...args)
• A timer promise that automatically rejects after t milliseconds with the message "Time Limit Exceeded"

Whichever promise settles first (either completes or rejects) determines the outcome. If the original function finishes before the timer expires, its result is returned. If the timer expires first, the timeout error is thrown.

For example, if you have a function that takes 150ms to complete but set a time limit of 100ms, the wrapped function will reject with "Time Limit Exceeded" after 100ms, even though the original function is still running.

Intuition

When we need to limit the execution time of an asynchronous function, we're essentially creating a competition between two events: the completion of the original function and the expiration of a timer. This naturally leads us to think about racing promises against each other.

The key insight is that JavaScript's Promise.race() method perfectly fits this scenario. It takes an array of promises and returns a new promise that resolves or rejects as soon as the first promise in the array settles. This is exactly what we need - we want to know which happens first: the function completing or the timeout occurring.

To implement this, we need to create two competing promises:

1. The first promise is simply the original function call: fn(...args)
2. The second promise is a timer that will automatically reject after t milliseconds

For the timer promise, we use setTimeout() wrapped in a new Promise. The promise constructor takes a resolver and rejector function. We only need the rejector here since we want to throw an error when time runs out. After t milliseconds, we call reject('Time Limit Exceeded').

By putting these two promises in Promise.race(), we get the exact behavior we want:

• If fn(...args) completes first, its result (whether resolved or rejected) becomes the final result
• If the timer expires first, the rejection with 'Time Limit Exceeded' becomes the final result

The wrapper function needs to be async and return the result of Promise.race() to maintain the asynchronous nature of the original function while adding the timeout behavior.

Solution Approach

The implementation creates a higher-order function that wraps any asynchronous function with timeout functionality. Here's how the solution works step by step:

1. Function Signature: The timeLimit function accepts two parameters:

   • fn: The original asynchronous function of type Fn (which accepts any parameters and returns a Promise)
   • t: The timeout duration in milliseconds

2. Return a New Function: The timeLimit function returns a new async function that accepts the same arguments as the original function using the rest parameter syntax ...args.

3. Create Racing Promises: Inside the returned function, we use Promise.race() with an array of two promises:

   Promise.race([
       fn(...args),
       new Promise((_, reject) => setTimeout(() => reject('Time Limit Exceeded'), t))
   ])

4. First Promise - Original Function: fn(...args) calls the original function with all provided arguments. This promise will resolve or reject based on the original function's behavior.

5. Second Promise - Timeout Timer: We create a new Promise that:

   • Ignores the resolve parameter (using _ as a placeholder)
   • Sets up a timer using setTimeout() that waits for t milliseconds
   • When the timer expires, it calls reject('Time Limit Exceeded')

6. Race Condition Resolution: Promise.race() will:

   • Return the result of whichever promise settles first
   • If the original function completes before the timeout, its result is returned
   • If the timeout occurs first, the promise rejects with the timeout error message

The beauty of this approach is that it doesn't require canceling the original function or managing complex state. The Promise.race() pattern elegantly handles the timeout logic, and the original function continues running in the background even if the timeout occurs first (though its result will be ignored).

Example Walkthrough

Let's walk through a concrete example to understand how the timeLimit function works.

Suppose we have an async function that simulates a network request taking 150ms:

async function fetchData(id) {
    await new Promise(resolve => setTimeout(resolve, 150));
    return { data: `Result for ${id}` };
}

Now let's create two wrapped versions with different time limits:

Case 1: Time limit is longer than execution time (200ms limit)

const fastEnough = timeLimit(fetchData, 200);

When we call fastEnough(123):

1. Two promises start racing:
   • Promise A: fetchData(123) - will complete after 150ms
   • Promise B: Timer promise - will reject after 200ms
2. At 150ms: Promise A completes with { data: "Result for 123" }
3. Promise.race() immediately resolves with this result
4. The timer promise (Promise B) is still pending but ignored
5. Result: The function successfully returns { data: "Result for 123" }

Case 2: Time limit is shorter than execution time (100ms limit)

const tooSlow = timeLimit(fetchData, 100);

When we call tooSlow(456):

1. Two promises start racing:
   • Promise A: fetchData(456) - will complete after 150ms
   • Promise B: Timer promise - will reject after 100ms
2. At 100ms: Promise B rejects with "Time Limit Exceeded"
3. Promise.race() immediately rejects with this error
4. The original function (Promise A) continues running but its result is ignored
5. Result: The function rejects with "Time Limit Exceeded"

Here's the complete flow visualized with timeline:

Time (ms):  0 -------- 100 ------- 150 ------- 200
            |           |          |           |
Case 1:     Start       |          ✓ Success   | Timer expires (ignored)
                        |          Returns data |
                        |                       |
Case 2:     Start       ✗ Timeout  | Original   |
                        Rejects    completes    |
                                  (ignored)      |

This example demonstrates how Promise.race() creates the exact behavior we need - returning whichever outcome happens first, whether it's the function completing or the timeout occurring.

Solution Implementation

Time and Space Complexity

Time Complexity: O(1)

The timeLimit function itself performs a constant amount of work regardless of input size. It creates and returns a new function that sets up a Promise.race between the original function call and a timeout. The setup operations (creating promises, setting timeout) all execute in constant time. The actual execution time depends on the wrapped function fn, but the overhead introduced by the wrapper is constant.

Space Complexity: O(1)

The space complexity is constant with respect to the wrapper implementation. The function allocates:

• A fixed amount of space for the returned async function closure
• Two promises (one for the original function call, one for the timeout)
• A timeout handle in the event loop

These allocations don't scale with any input size parameter. While the wrapped function fn may have its own space complexity, the wrapper itself only adds a constant amount of additional space overhead.

Common Pitfalls

1. Resource Cleanup and Memory Leaks

The original function continues running even after the timeout occurs. This can lead to:

• Unclosed resources (database connections, file handles, network sockets)
• Memory leaks from long-running operations
• Unexpected side effects completing after timeout

Example Problem:

async def problematic_function():
    connection = await create_database_connection()
    await asyncio.sleep(5)  # Long operation
    result = await connection.query("SELECT * FROM users")
    await connection.close()  # Never reached if timeout occurs!
    return result

limited = timeLimit(problematic_function, 1000)  # 1 second timeout
# Connection remains open after timeout!

Solution: Use context managers or try-finally blocks:

async def safe_function():
    connection = None
    try:
        connection = await create_database_connection()
        await asyncio.sleep(5)
        result = await connection.query("SELECT * FROM users")
        return result
    finally:
        if connection:
            await connection.close()

2. Cancellation vs Abandonment

The current implementation doesn't actually cancel the original task - it just abandons it. The original function keeps executing in the background, consuming resources.

Solution: Properly cancel the task:

def timeLimit(fn: Fn, t: int) -> Fn:
    @wraps(fn)
    async def time_limited_function(*args: Any, **kwargs: Any) -> Any:
        timeout_seconds = t / 1000
      
        # Create task to enable cancellation
        task = asyncio.create_task(fn(*args, **kwargs))
      
        try:
            result = await asyncio.wait_for(task, timeout=timeout_seconds)
            return result
        except asyncio.TimeoutError:
            # Cancel the task to prevent it from continuing
            task.cancel()
            try:
                await task
            except asyncio.CancelledError:
                pass
            raise Exception('Time Limit Exceeded')
  
    return time_limited_function

3. Non-Cancellable Operations

Some operations (like synchronous blocking I/O or CPU-bound tasks) cannot be cancelled by asyncio and will continue running despite cancellation attempts.

Example Problem:

async def cpu_intensive():
    # This blocks the event loop and can't be cancelled
    result = complex_synchronous_calculation()
    return result

Solution: Use thread/process pools for blocking operations:

async def cpu_intensive():
    loop = asyncio.get_event_loop()
    # Run in thread pool to make it cancellable
    result = await loop.run_in_executor(None, complex_synchronous_calculation)
    return result

4. Error Message Consistency

Different implementations might use different error types or messages, breaking compatibility when switching between JavaScript/TypeScript and Python versions.

Solution: Define consistent error handling:

class TimeLimitExceeded(Exception):
    def __init__(self):
        super().__init__('Time Limit Exceeded')

# Use consistent error type
raise TimeLimitExceeded()