Class Tailrec

future-java/src/main/java/io/trane/future/Tailrec.java:56–125

`Tailrec` e ensures that recursive futures are stack-safe. Given the optimization that this library implements to avoid thread context switch, compositions are not stack-safe by default. It is necessary to wrap recursive computations with a `Tailrec` call: ```java public Future factorial(

 * increase the risk of a `StackOverflowException`.
 */
public final class Tailrec {

  private static final int DEFAULT_BATCH_SIZE = Optional
      .ofNullable(System.getProperty("io.trane.future.defaultBatchSize")).map(Integer::parseInt).orElse(512);

  private static final ThreadLocal<Tailrec> local = new ThreadLocal<Tailrec>() {
    @Override
    public Tailrec initialValue() {
      return new Tailrec();
    }
  };

  private ArrayList<Runnable> tasks = null;
  private int syncPermits = 0;

  private boolean running = false;

  private final boolean runSync() {
    return syncPermits-- > 0;
  }

  private final void submit(final Runnable r, final int batchSize) {
    syncPermits = batchSize;
    tasks = new ArrayList<>(1);
    tasks.add(r);
    if (!running) {
      run();
      syncPermits = 0;
    }
  }

  private final void run() {
    running = true;
    while (tasks != null) {
      final ArrayList<Runnable> pending = tasks;
      tasks = null;
      for (int i = 0; i < pending.size(); i++)
        pending.get(i).run();
    }
    running = false;
  }

  /**
   * Runs the recursive future using the default batch size.
   * 
   * @param sup  the supplier to be called on each recursion.
   * @return     the stack-safe recursive future.
   */
  public static final <T> Future<T> apply(final Supplier<Future<T>> sup) {
    return apply(DEFAULT_BATCH_SIZE, sup);
  }

  /**
   * Runs the recursive future using the custom batch size.
   * 
   * @param batchSize  the custom batch size.
   * @param sup        the supplier to be called on each recursion.
   * @return           the stack-safe recursive future.