Interface Future

future-java/src/main/java/io/trane/future/Future.java:99–605

`Future` is an abstraction to deal with asynchronicity without having to use callbacks directly or blocking threads. The primary usage for `Futures` on the JVM is to perform IO operations, which are asynchronous by nature. Although most IO APIs return synchronously, they do that by blocking the cur

 * @param <T> the type of the asynchronous computation result
 */
public interface Future<T> extends InterruptHandler {

  /**
   * A constant void future. Useful to represent completed side effects.
   */
  static final Future<Void> VOID = Future.value((Void) null);

  /**
   * A constant `false` future.
   */
  static final Future<Boolean> FALSE = Future.value(false);

  /**
   * A constant `true` future.
   */
  static final Future<Boolean> TRUE = Future.value(true);

  /**
   * Returns a future that is never satisfied.
   * 
   * @return     the unsatisfied future.
   * @param <T>  the type of the never satisfied future.
   */
  public static <T> Future<T> never() {
    return FutureConstants.NEVER.unsafeCast();
  }

  /**
   * Creates a future with the result of the supplier. Note that the supplier is
   * executed by the current thread. Use FuturePool.async to execute the
   * supplier on a separate thread.
   * 
   * @param s    a supplier that may throw an exception
   * @param <T>  the type of the value returned by the Supplier.
   * @return     a satisfied future if s doesn't throw or else a failed future with
   *             the supplier exception.
   */
  public static <T> Future<T> apply(final Supplier<T> s) {
    try {
      return new ValueFuture<>(s.get());
    } catch (final Throwable ex) {
      return new ExceptionFuture<>(ex);
    }
  }

  /**
   * Applies the provided supplier and flattens the result. This method is useful
   * to apply a supplier safely without having to catch possible synchronous exceptions
   * that the supplier may throw.
   * 
   * @param s     a supplier that may throw an exception
   * @return the  future produced by the supplier or a failed future if the supplier 
   *              throws a synchronous exception (not a failed Future)
   */
  public static <T> Future<T> flatApply(final Supplier<Future<T>> s) {
    try {
      return s.get();
    } catch (final Throwable ex) {