static Set<Thread> evalWithTimeout_inTime = synchroSet();
static Set<Thread> evalWithTimeout_allThreads = newWeakHashSet();

static new ThreadLocal<S> evalWithTimeout_threadName;

static <A> Either<A, Thread> evalWithTimeout(double timeoutSeconds, IF0<A> r) {
  ret (Either) evalWithTimeout(timeoutSeconds, (O) r);
}

// Either calculation result or Thread with timed-out computation
// Tries to interrupt thread after timeout
// Errors are rethrown.
static Either<O, Thread> evalWithTimeout(int timeoutMS, O r) {
  ret evalWithTimeout(toSeconds(timeoutMS), r);
}

// timeoutSeconds may be infinity()
static Either<O, Thread> evalWithTimeout(double timeoutSeconds, O r) {
  final new Flag done;
  final new Flag doneWaiting;
  final new Var var;
  final new Var<Throwable> error;
  
  // copy redirected print handler to new thread
  var printer = print_byThread()!;
  
  Thread t = newThread(getAndClearThreadLocal(evalWithTimeout_threadName), r {
    try {
      temp tempSetTL(print_byThread(), printer);
      
      try {
        var.set(callF(r));
      } finally {
        evalWithTimeout_allThreads.remove(currentThread());
      }
    } catch e {
      error.set(e);
      if (doneWaiting.isUp())
        printStackTrace_inPossiblyCancelledThread(e);
    } finally {
      done.raise();
    }
  });
  
  beforeDelegatingToThread(t);
  try {
    startThread(t);
    
    evalWithTimeout_inTime.add(t);
    evalWithTimeout_allThreads.add(t);
    try {
      done.waitUntilUp(timeoutSeconds);
      doneWaiting.raise();
    } finally {
      evalWithTimeout_inTime.remove(t);
    }
      
    // timeout! cancel/interrupt and return thread object
    if (!done.isUp()) {
      print("Cancelling thread (timeout)");
      cancelAndInterruptThread(t);
      ret either2(t);
    }
    
    // thread ended with error
    if (error! != null) rethrow(error!);
    
    // thread ended naturally
    ret either1(var!);
  } finally {
    afterDelegatingToThread(t);
  }
}