Design Cancellable Function

Design Cancellable Function - Problem

JavaScript Hard

Sometimes you have a long running task, and you may wish to cancel it before it completes. To help with this goal, write a function cancellable that accepts a generator object and returns an array of two values: a cancel function and a promise.

You may assume the generator function will only yield promises. It is your function's responsibility to pass the values resolved by the promise back to the generator. If the promise rejects, your function should throw that error back to the generator.

If the cancel callback is called before the generator is done, your function should throw an error back to the generator. That error should be the string "Cancelled" (Not an Error object). If the error was caught, the returned promise should resolve with the next value that was yielded or returned. Otherwise, the promise should reject with the thrown error. No more code should be executed.

When the generator is done, the promise your function returned should resolve the value the generator returned. If, however, the generator throws an error, the returned promise should reject with the error.

Input & Output

Example 1 — Cancellation Before Completion

$ Input: function* tasks() { const val = yield new Promise(resolve => resolve(2 + 2)); yield new Promise(resolve => setTimeout(resolve, 100)); return val + 1; }

› Output: Promise rejects with "Cancelled"

💡 Note: Cancel is called at 50ms, before the 100ms timeout completes. The generator receives 'Cancelled' error and the promise rejects.

Example 2 — Normal Completion

$ Input: function* tasks() { const val = yield new Promise(resolve => resolve(3)); return val * 2; }

› Output: Promise resolves with 6

💡 Note: No cancellation occurs, generator completes normally: 3 * 2 = 6

Example 3 — Caught Cancellation

$ Input: function* tasks() { try { yield new Promise(resolve => setTimeout(resolve, 100)); } catch { return 'caught'; } }

› Output: Promise resolves with 'caught'

💡 Note: Cancellation error is caught by try-catch block, returns 'caught' instead of rejecting

Constraints

The generator function will only yield promises
Cancellation error must be the string "Cancelled"
Function must handle both caught and uncaught cancellation errors
Promise resolution must match generator completion state

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 20 a Amazon 15 N Netflix 12

The key insight is using generator.throw() to inject cancellation errors directly into the generator's execution context. The optimal approach uses cooperative cancellation where the generator can catch and handle cancellation gracefully. Time: O(n), Space: O(1)

Common Approaches

✓ Basic Promise Chain

⏱️ Time: O(n) Space: O(1)

Simply iterate through the generator, awaiting each promise, and provide basic cancellation by setting a flag. This approach lacks proper error propagation and doesn't truly stop execution.

Cooperative Cancellation with Error Propagation

⏱️ Time: O(n) Space: O(1)

This approach uses the generator's throw() method to inject cancellation errors directly into the generator execution context. It properly handles both caught and uncaught cancellation errors, providing full control over the generator's lifecycle.

Basic Promise Chain — Algorithm Steps

Iterate through generator yields
Await each promise sequentially
Use a cancelled flag to check status

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Generator

Begin iterating through generator yields

Check Cancel Flag

Simple boolean check for cancellation

Process Promise

Await current promise and continue

Code -

solution.c — C

#include <stdio.h>
#include <string.h>

char* solution(char* generatorFunc) {
    // JavaScript-specific implementation
    return "function";
}

int main() {
    char generatorInput[1000];
    fgets(generatorInput, sizeof(generatorInput), stdin);
    generatorInput[strcspn(generatorInput, "\n")] = 0;
    char* result = solution("");
    printf("function\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Where n is the number of yields in the generator, each processed once

✓ Linear Growth

Space Complexity

O(1)

Only stores references to current promise and cancellation state

✓ Linear Space

12.0K Views

Medium Frequency

~35 min Avg. Time

450 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Basic Promise Chain — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler