Timeout Cancellation solution and explanation

import threading

class TimeoutFunction:
    def __init__(self, fn, t):
        self.fn = fn
        self.t = t
        self.timer = None

    def start(self):
        self.timer = threading.Timer(self.t / 1000, self.fn)
        self.timer.start()

    def cancel(self):
        if self.timer:
            self.timer.cancel()

# Example usage
fn = lambda: print(10)
timeout_fn = TimeoutFunction(fn, 20)
timeout_fn.start()

# Simulate cancel call
timeout_fn.cancel()  # Should cancel the execution

import java.util.Timer;
import java.util.TimerTask;

public class TimeoutFunction {
    public static Runnable cancellable(Runnable fn, int t) {
        Timer timer = new Timer();
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                fn.run();
                timer.cancel();
            }
        };
        timer.schedule(task, t);

        return () -> {
            task.cancel();
            timer.cancel();
        };
    }

    public static void main(String[] args) {
        Runnable fn = () -> System.out.println(10);
        Runnable cancelFn = cancellable(fn, 20);

        // Simulate cancel call
delayCall(10, cancelFn);  // Should cancel the execution
    }

    private static void delayCall(int delay, Runnable callback) {
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                callback.run();
            }
        }, delay);
    }
}

/* Similar to C, C++ requires external libraries or platform-specific APIs for handling async behavior akin to JavaScript setTimeout. Common solutions involve threads or async libraries. */

function cancellable(fn, args, t) {
  let timeoutId = setTimeout(() => {
    fn(...args);
  }, t);
  
  return () => clearTimeout(timeoutId);
}

// Example usage
const fn = (x) => console.log(x * 5);
const cancelFn = cancellable(fn, [2], 20);

// Simulate cancel call
setTimeout(cancelFn, 10);  // Should cancel the execution

/* In C, we typically don't use timeouts like JavaScript. However, if you're using a multi-threaded program, you can achieve similar behavior with thread sleeping and cancellation. C standard library does not provide portable setTimeout/clearTimeout functions. */

using System;
using System.Threading;

public class TimeoutFunction
{
    private Timer _timer;

    public TimeoutFunction(Action fn, int t)
    {
        _timer = new Timer(_ => fn(), null, t, Timeout.Infinite);
    }

    public void Cancel()
    {
        _timer?.Dispose();
    }
}

// Example usage
public class Program
{
    public static void Main()
    {
        Action fn = () => Console.WriteLine(10);
        TimeoutFunction timeoutFunction = new TimeoutFunction(fn, 20);

        // Simulate cancel call
        timeoutFunction.Cancel();
    }
}

import asyncio

async def cancellable(fn, args, t):
    task = asyncio.ensure_future(asyncio.sleep(t / 1000))

    async def cancel_task():
        if not task.done():
            task.cancel()
            print("Cancelled")

    try:
        await task
        fn(*args)
    except asyncio.CancelledError:
        pass
    return cancel_task

async def main():
    async def myFunction(x):
        print(x * 5)

    cancel_fn = await cancellable(myFunction, [2], 20)

    # Simulate cancel call
    await asyncio.sleep(0.01)  # Less than 20ms, hence should cancel the execution
    await cancel_fn()

asyncio.run(main())

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

public class PromiseTimeout {
    public static CompletableFuture<Void> cancellable(Runnable fn, int t) {
        CompletableFuture<Void> promise = new CompletableFuture<>();

        ScheduledExecutorService scheduledExecutor = Executors.newScheduledThreadPool(1);

        scheduledExecutor.schedule(() -> {
            if (!promise.isDone()) {
                fn.run();
                promise.complete(null);
            }
        }, t, TimeUnit.MILLISECONDS);

        return promise;   // Caller should complete this promise to cancel
    }

    public static void main(String[] args) throws Exception {
        Runnable fn = () -> System.out.println(10);
        CompletableFuture<Void> future = cancellable(fn, 500);

        // Simulate cancel call after 200 ms
        Thread.sleep(200);
        future.complete(null);  // Cancels the execution of fn if not already done
    }
}

/* Again, in C++, achieving a Promise-like handling for timeouts requires either using the C++ Standard Library's future and promise features, or a third-party async library. *

function cancellableWithPromise(fn, args, t) {
  let cancelFn;

  const promise = new Promise((resolve) => {
    const timeoutId = setTimeout(() => {
      resolve(fn(...args));
    }, t);

    cancelFn = () => {
      clearTimeout(timeoutId);
      resolve('Cancelled');
    };
  });

  return { promise, cancelFn };
}

// Example usage
const fn = (x) => console.log(x * 5);
const { promise, cancelFn } = cancellableWithPromise(fn, [2], 20);

// Simulate cancel call
setTimeout(() => {
  cancelFn();
  promise.then((result) => console.log(result));
}, 10);

/* In C, you might implement this using threads and synchronizations like semaphores or condition variables to emulate Promise-like async tasks. Normally, C programs would not use this style directly. */

using System;
using System.Threading;
using System.Threading.Tasks;

public class PromiseTimeout
{
    public static async Task<Func<Task>> Cancellable(Action fn, int t)
    {
        var cts = new CancellationTokenSource();

        Task.Delay(t, cts.Token).ContinueWith(_ =>
        {
            if (!cts.Token.IsCancellationRequested)
            {
                fn();
            }
        }, TaskScheduler.Current);

        return async () => 
        {
            cts.Cancel();
            await Task.CompletedTask;
        };
    }

    public static async Task Main(string[] args)
    {
        Action fn = () => Console.WriteLine(10);
        var cancel = await Cancellable(fn, 2000); // Trying with a delay-longer-than-task to show cancellation

        // Simulate cancel call
        Thread.Sleep(1000); // Less than 2000ms, hence should cancel
        await cancel();
    }
}

function cancellable(fn: Function, args: any[], t: number): Function {
    const timer = setTimeout(() => fn(...args), t);
    return () => {
        clearTimeout(timer);
    };
}

/**
 *  const result = []
 *
 *  const fn = (x) => x * 5
 *  const args = [2], t = 20, cancelT = 50
 *
 *  const start = performance.now()
 *
 *  const log = (...argsArr) => {
 *      const diff = Math.floor(performance.now() - start);
 *      result.push({"time": diff, "returned": fn(...argsArr))
 *  }
 *
 *  const cancel = cancellable(log, args, t);
 *
 *  const maxT = Math.max(t, cancelT)
 *
 *  setTimeout(() => {
 *     cancel()
 *  }, cancelT)
 *
 *  setTimeout(() => {
 *     console.log(result) // [{"time":20,"returned":10}]
 *  }, maxT + 15)
 */