sclass ConcurrentEvaluator {

  new L functions;

  L results = synchroList();

  ExecutorService executorService;

  O onNewResult; // Runnable or voidfunc(int)

  volatile bool cancelled;

  L<Thread> threads = synchroList();

  int coresToUse; // if 0, use coresToUse()

  void add(O f) { functions.add(f); }

  void addAll(Collection l) { functions.addAll(l); }

  void start() {

    executorService = Executors.newFixedThreadPool(coresToUse != 0 ? coresToUse : coresToUse());

    while (l(results) < l(functions)) results.add(null);

    for _i over functions: {

      final int i = _i;

      executorService.execute(r {

        threads.add(currentThread());

        try {

          results.set(i, pcallF(functions.get(i)));

          ping();

          onNewResult(i);

        } finally {

          threads.remove(currentThread());

        }

      });

    }

  }

  void onNewResult(int i) { if (!cancelled) pcallF(onNewResult, i); }

  L results() { ret cloneList(results); }

  void cancel {

    pcall {

      cancelled = true;

      executorService.shutdownNow();

      cancelThreads(cloneList(threads));

    }

  }

  void cancelAndWait {

    long time = sysNow();

    cancel();

    while (nempty(threads)) sleep(1);

    sysDone("Cancelling evaluators", time, 10);

  }

  bool done() { ret empty(threads); }

  void startWaitCleanUp {

    try {

      start();

      while (!done()) sleepSeconds(1);

    } finally {

      cancel();

    }

  }

}