Problem Description

This problem asks you to create a function that executes another function repeatedly at fixed intervals until cancelled.

You need to implement a cancellable function that takes three parameters:

• fn: a function to be executed
• args: an array of arguments to pass to fn
• t: the time interval in milliseconds between each execution

The cancellable function should:

1. Call fn with the provided args immediately (at time 0)
2. Continue calling fn with the same args every t milliseconds
3. Return a cancel function that, when invoked, stops all future executions of fn

The key requirements are:

• The first execution happens immediately when cancellable is called
• Subsequent executions happen at intervals of t milliseconds (at times t, 2t, 3t, etc.)
• The returned cancel function stops the interval when called
• After cancellation, no more executions of fn should occur

For example, if fn is (x) => x * 2, args is [4], t is 20ms, and the cancel function is called at 110ms:

• fn(4) executes at 0ms, returning 8
• fn(4) executes at 20ms, returning 8
• fn(4) executes at 40ms, returning 8
• fn(4) executes at 60ms, returning 8
• fn(4) executes at 80ms, returning 8
• fn(4) executes at 100ms, returning 8
• Cancel is called at 110ms, preventing the execution at 120ms

The solution uses setInterval to handle the repeated executions and clearInterval in the returned cancel function to stop them.

Intuition

When we need to execute a function repeatedly at regular intervals, JavaScript provides the built-in setInterval function which is perfectly suited for this task. However, there's a subtle requirement in this problem - the function must execute immediately at time 0, not after waiting for the first interval.

The natural approach would be to just use setInterval(fn, t), but this would wait t milliseconds before the first execution. To handle the immediate execution requirement, we need to call fn(...args) once before setting up the interval.

For the cancellation mechanism, setInterval returns a timer ID that can be used with clearInterval to stop the repeated execution. This maps directly to our need for a cancel function. We can capture this timer ID and return a function that calls clearInterval with it.

The solution structure becomes clear:

1. Execute fn(...args) immediately to satisfy the time 0 execution
2. Set up setInterval(() => fn(...args), t) to handle all subsequent executions at intervals of t
3. Store the interval ID returned by setInterval
4. Return a function that calls clearInterval with the stored ID

This approach elegantly handles all the requirements - immediate first execution, repeated executions at fixed intervals, and a clean cancellation mechanism. The closure created by the returned function naturally maintains access to the interval ID, allowing it to cancel the interval when called.

Solution Approach

The implementation follows a straightforward approach using JavaScript's timer functions:

1. Immediate Execution: First, we call fn(...args) directly to ensure the function executes at time 0. The spread operator ...args unpacks the array of arguments to pass them individually to the function.

2. Setting Up Repeated Execution: We use setInterval(() => fn(...args), t) to create a timer that executes the function every t milliseconds. The arrow function () => fn(...args) creates a closure that captures both fn and args, ensuring they're available for each execution.

3. Storing the Timer ID: The setInterval function returns a unique timer ID, which we store in the time variable. This ID is crucial for cancellation later.

4. Returning the Cancel Function: We return an arrow function () => clearInterval(time) that, when called, will stop the interval. This function forms a closure over the time variable, maintaining access to the timer ID even after the cancellable function has finished executing.

The complete implementation:

function cancellable(fn: Function, args: any[], t: number): Function {
    fn(...args);                           // Execute immediately at time 0
    const time = setInterval(() => fn(...args), t);  // Set up repeated execution
    return () => clearInterval(time);      // Return cancel function
}

This solution leverages JavaScript's closure mechanism - the returned cancel function maintains a reference to the time variable from its parent scope, allowing it to clear the correct interval when invoked. The pattern of returning a cleanup function is common in JavaScript for managing resources and side effects.

Example Walkthrough

Let's walk through a simple example where we want to repeatedly log a counter value.

Setup:

• fn = (x) => console.log(x * 2)
• args = [3]
• t = 30 (milliseconds)
• Cancel will be called at 95ms

Step-by-step execution:

1. Time 0ms: When cancellable(fn, [3], 30) is called:

   • fn(...args) executes immediately → fn(3) → logs 6
   • setInterval(() => fn(3), 30) is set up and returns timer ID (let's say ID = 123)
   • Returns cancel function that captures timer ID 123

2. Time 30ms: First interval triggers:

   • The interval callback () => fn(...args) executes
   • fn(3) runs → logs 6

3. Time 60ms: Second interval triggers:

   • The interval callback executes again
   • fn(3) runs → logs 6

4. Time 90ms: Third interval triggers:

   • The interval callback executes
   • fn(3) runs → logs 6

5. Time 95ms: Cancel function is called:

   • clearInterval(123) executes
   • The interval is cleared, preventing future executions

6. Time 120ms: No execution occurs (interval was cancelled)

Output timeline:

0ms:  6 (immediate execution)
30ms: 6 (first interval)
60ms: 6 (second interval)  
90ms: 6 (third interval)
95ms: [cancel called]
120ms: (nothing - execution stopped)

The key insight is that we get both the immediate execution at time 0 (from the direct fn(...args) call) and the repeated executions (from setInterval), with clean cancellation when needed.

Solution Implementation

Time and Space Complexity

Time Complexity: O(1) for the cancellable function itself. The function executes in constant time as it only performs three operations: calling fn once, setting up an interval, and returning a cancel function. However, the total time complexity over the lifetime of the interval is O(n) where n = floor(cancelT / t) represents the number of times fn is executed before cancellation.

Space Complexity: O(1). The function allocates constant space for:

• The time variable to store the interval ID
• The returned cancel function closure which captures the time variable
• The interval timer in the JavaScript event loop

The space complexity doesn't depend on the size of args since they're passed by reference and not copied. The function fn and its arguments are not duplicated in memory.

Common Pitfalls

1. Forgetting the Initial Immediate Execution

A frequent mistake is only setting up the interval without executing the function immediately at time 0. This would cause the first execution to happen at time t instead of time 0.

Incorrect Implementation:

def cancellable(fn, args, t):
    interval_seconds = t / 1000.0
  
    # Missing immediate execution!
    def run_periodically():
        fn(*args)
        # ... rest of the code
  
    timer = threading.Timer(interval_seconds, run_periodically)
    timer.start()
    # First execution happens at time t, not 0

Solution: Always call fn(*args) immediately before setting up the periodic execution.

2. Memory Leaks from Uncancelled Timers

Failing to properly clean up timers can lead to memory leaks and threads continuing to run even after they should have stopped. This is especially problematic when creating multiple cancellable functions without cancelling previous ones.

Problematic Pattern:

def cancellable(fn, args, t):
    should_continue = [True]
  
    def run_periodically():
        if should_continue[0]:
            fn(*args)
            # Creating new timer without storing reference
            threading.Timer(t/1000.0, run_periodically).start()
            # Can't cancel these timers later!
  
    def cancel():
        should_continue[0] = False
        # Timers still exist in memory and may execute

Solution: Store references to all created timers and explicitly cancel them in the cancel function.

3. Race Conditions in Cancellation

The cancellation might happen while a function execution is in progress or just about to start, leading to unexpected behavior or one extra execution after cancellation.

Potential Issue:

def cancel():
    should_continue[0] = False  # Set flag
    # But a timer might fire between these two lines!
    for timer in timers:
        timer.cancel()  # Too late, function already executing

Solution: Use thread-safe mechanisms and cancel timers before setting flags:

def cancel():
    # Cancel timers first to prevent new executions
    for item in should_continue[1:]:
        if isinstance(item, threading.Timer):
            item.cancel()
    # Then set the flag
    should_continue[0] = False

4. Incorrect Time Unit Conversion

JavaScript uses milliseconds for setInterval, but Python's threading.Timer uses seconds. Forgetting to convert can cause functions to execute 1000x too frequently or too slowly.

Wrong:

timer = threading.Timer(t, run_periodically)  # t is in milliseconds!

Correct:

timer = threading.Timer(t / 1000.0, run_periodically)  # Convert to seconds

5. Non-Daemon Threads Preventing Program Exit

Creating non-daemon timer threads can prevent the Python program from exiting naturally, causing it to hang.

Problematic:

timer = threading.Timer(interval_seconds, run_periodically)
timer.start()  # Non-daemon thread keeps program alive

Solution:

timer = threading.Timer(interval_seconds, run_periodically)
timer.daemon = True  # Thread will terminate when main program exits
timer.start()