Design Cancellable Function - Practice Coding Problems

Design Cancellable Function - Problem

JavaScript Hard

In modern JavaScript applications, you often need to handle long-running asynchronous operations that users might want to cancel before completion. Think downloading large files, processing data, or making multiple API calls in sequence.

Your task is to implement a cancellable function that provides cooperative cancellation for generator-based async workflows. This function should:

Accept a generator object that yields promises
Return an array with a cancel function and a promise
Handle promise resolution/rejection and pass values back to the generator
Support cancellation by throwing "Cancelled" string (not Error object) to the generator
Resolve with the final return value or handle cancellation gracefully

Example usage:

function* tasks() {
  const val = yield new Promise(resolve => resolve(2 + 2));
  yield new Promise(resolve => setTimeout(resolve, 100));
  return val + 1;
}
const [cancel, promise] = cancellable(tasks());
setTimeout(cancel, 50);  // Cancel after 50ms
promise.catch(console.log); // logs "Cancelled" at t=50ms

If cancel() wasn't called, the promise would resolve to 5 after 100ms.

Input & Output

basic_cancellation.js — Basic Cancellation

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

› Output: Promise rejects with "Cancelled"

💡 Note: The generator is cancelled after 50ms, before the 100ms timeout completes. The promise rejects with the string "Cancelled".

successful_completion.js — No Cancellation

$ Input: function* tasks() { const val = yield new Promise(resolve => resolve(3)); yield new Promise(resolve => setTimeout(resolve, 50)); return val * 2; } const [cancel, promise] = cancellable(tasks()); // No cancel call

› Output: Promise resolves with 6

💡 Note: Without cancellation, the generator completes normally. First promise resolves with 3, second completes after 50ms, then returns 3 * 2 = 6.

error_handling.js — Generator Error

$ Input: function* tasks() { yield new Promise((resolve, reject) => reject(new Error("Network error"))); return "Should not reach here"; } const [cancel, promise] = cancellable(tasks());

› Output: Promise rejects with Error("Network error")

💡 Note: When a yielded promise rejects, the error is thrown back to the generator. If not caught, the main promise rejects with that error.

Visualization

Tap to expand

Understanding the Visualization

Initialize

Set up the generator execution context and cancellation signal system

Execute Step

Start processing current generator step, yielding a promise

Race Condition

Race the promise resolution against cancellation signal using Promise.race()

Handle Outcome

If cancelled, throw 'Cancelled' to generator; if resolved, pass value to generator.next()

Continue/Complete

Either continue to next step or complete execution based on generator state

Key Takeaway

🎯 Key Insight: The optimal solution races promise resolution against cancellation signals, enabling immediate response while maintaining proper generator lifecycle management through cooperative cancellation patterns.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Where n is the number of generator steps, each processed once with optimal cancellation

✓ Linear Growth

Space Complexity

O(1)

Constant space for cancellation state and current execution context

✓ Linear Space

Constraints

Generator function only yields promises (as stated in problem)
Cancellation error must be the string "Cancelled" (not Error object)
Must handle promise resolution and rejection properly
Must support cancellation at any point during execution
Must properly clean up resources and handle generator lifecycle

Asked in

G Google 45 f Meta 38 N Netflix 32 ⊞ Microsoft 28

The optimal solution uses event-driven cancellation with Promise.race() to immediately respond to cancellation signals while properly managing the generator lifecycle. Key aspects include using generator.next() for normal progression, generator.throw() for error injection, and racing promise resolution against cancellation events for immediate response.

Common Approaches

Approach	Time	Space	Notes
✓ Basic Generator Execution with Polling	O(n)	O(1)	Simple approach that manually steps through generator with basic cancellation flag
Event-Driven Cancellation (Optimal)	O(n)	O(1)	Proper async/await implementation with immediate cancellation handling and generator lifecycle management

Basic Generator Execution with Polling — Algorithm Steps

Create a cancellation flag and toggle function
Manually iterate through generator using .next()
For each yielded promise, wait for resolution
Check cancellation flag after each step
Throw cancellation error if flag is set

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create cancellation flag and start generator

Process Step

Execute current generator step and await promise

Check Cancel

Check if cancellation was requested after promise resolves

Continue/Stop

Either continue to next step or throw cancellation error

Code -

solution.c — C

#include <pthread.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int cancelled;
    pthread_mutex_t mutex;
    void* (*generator)(void*);
    void* arg;
    void* result;
    char* error;
} cancellable_t;

void* run_generator(void* arg) {
    cancellable_t* c = (cancellable_t*)arg;
    
    pthread_mutex_lock(&c->mutex);
    if (c->cancelled) {
        c->error = strdup("Cancelled");
        pthread_mutex_unlock(&c->mutex);
        return NULL;
    }
    pthread_mutex_unlock(&c->mutex);
    
    c->result = c->generator(c->arg);
    
    pthread_mutex_lock(&c->mutex);
    if (c->cancelled) {
        c->error = strdup("Cancelled");
        c->result = NULL;
    }
    pthread_mutex_unlock(&c->mutex);
    
    return NULL;
}

cancellable_t* cancellable(void* (*generator)(void*), void* arg) {
    cancellable_t* c = malloc(sizeof(cancellable_t));
    c->cancelled = 0;
    pthread_mutex_init(&c->mutex, NULL);
    c->generator = generator;
    c->arg = arg;
    c->result = NULL;
    c->error = NULL;
    
    return c;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Where n is the number of generator steps, each step is processed once

✓ Linear Growth

Space Complexity

O(1)

Only stores the current state and cancellation flag

✓ Linear Space

Constraints

Generator function only yields promises (as stated in problem)
Cancellation error must be the string "Cancelled" (not Error object)
Must handle promise resolution and rejection properly
Must support cancellation at any point during execution
Must properly clean up resources and handle generator lifecycle

28.5K Views

Medium Frequency

~35 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Basic Generator Execution with Polling — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler