Construct an FutureT from an AnyM that wraps a monad containing  Futures

@param monads AnyM that contains a monad wrapping an Future
@return FutureT
436072
public static <W extends WitnessType<W>,A> CompletableFutureT<W,A> of(final AnyM<W,CompletableFuture<A>> monads) {
        return new CompletableFutureT<>(
                                 monads);
    }
1009525
public <R> Future<R> flatMapCf(final Function<? super T, ? extends CompletionStage<? extends R>> mapper) {
        return Future.<R> of(future.<R> thenCompose(t -> (CompletionStage<R>) mapper.apply(t)));
    }
66358
public Future<Map<Integer, String>> getSummonerNames(Integer... ids) {
        return new ApiFuture<>(() -> handler.getSummonerNames(ids));
    }
1335327
public static <T> T get(Future<T> future) {
    return get(future, 30, TimeUnit.SECONDS);
  }
349912
public static <T> ContinuableFuture<T> anyOf(final Collection<? extends Future<? extends T>> cfs) {
        return anyOf2(cfs);
    }
144857
static <RESULT, ERR> OrFuture<RESULT, Every<ERR>> withPromise(ExecutionContext<?> executionContext,
                                                                Consumer<? super OrPromise<RESULT, Every<ERR>>> consumer) {
    OrPromise<RESULT, Every<ERR>> promise = executionContext.promise();
    consumer.accept(promise);
    return promise.future();
  }
1199350
public static <T> Future<T> asyncRun(Callable<T> callable)
	{
		RunnableCallableFuture<T> future = new RunnableCallableFuture<T>(callable);

		future.asyncRun();

		return future;
	}
1184323
private Formula constructClause(final LinkedHashSet<Literal> literals) {
    if (literals.isEmpty())
      return this.falsum();
    if (literals.size() == 1)
      return literals.iterator().next();
    Map<LinkedHashSet<? extends Formula>, Or> opOrMap = this.orsN;
    switch (literals.size()) {
      case 2:
        opOrMap = this.ors2;
        break;
      case 3:
        opOrMap = this.ors3;
        break;
      case 4:
        opOrMap = this.ors4;
        break;
      default:
        break;
    }
    Or tempOr = opOrMap.get(literals);
    if (tempOr != null)
      return tempOr;
    tempOr = new Or(literals, this, true);
    opOrMap.put(literals, tempOr);
    return tempOr;
  }
122406
public static <T> IPromise<IPromise<T>[]> all(IPromise<T>... futures) {
        Promise res = new Promise();
        awaitSettle(futures, res);
        return res;
    }
315123
@Nonnull
	public final LTernaryOperator<T> build() {

		final LTernaryOperator<T> eventuallyFinal = this.eventually;

		LTernaryOperator<T> retval;

		final Case<LTriPredicate<T, T, T>, LTernaryOperator<T>>[] casesArray = cases.toArray(new Case[cases.size()]);
		retval = LTernaryOperator.<T> ternaryOp((a1, a2, a3) -> {
			try {
				for (Case<LTriPredicate<T, T, T>, LTernaryOperator<T>> aCase : casesArray) {
					if (aCase.casePredicate().test(a1, a2, a3)) {
						return aCase.caseFunction().apply(a1, a2, a3);
					}
				}

				return eventuallyFinal.apply(a1, a2, a3);
			} catch (Error e) { // NOSONAR
					throw e;
				} catch (Throwable e) { // NOSONAR
					throw Handler.handleOrPropagate(e, handling);
				}
			});

		if (consumer != null) {
			consumer.accept(retval);
		}
		return retval;
	}
592656
@Override
    public <U> MonadicBinding<U> flatMap(
            Function<? super T, ? extends ObservableValue<U>> f) {
        return EasyBind.flatMap(delegate, f);
    }
927241
public <B> MonoT<W,B> flatMapT(final Function<? super T, MonoT<W,B>> f) {
        MonoT<W, B> r = of(run.map(future -> Mono.from(future.flatMap(a -> {
            Mono<B> m = f.apply(a).run.stream()
                    .toList()
                    .get(0);
            return m;
        }))));
        return r;
    }
1168234
@SafeVarargs
    public static <T> ContinuableFuture<List<T>> allOf(final Future<? extends T>... cfs) {
        return allOf2(Arrays.asList(cfs));
    }
437028
public static <T> ContinuableFuture<List<T>> allOf(final Collection<? extends Future<? extends T>> cfs) {
        return allOf2(cfs);
    }
1365478
public static <A> Will<A> forFuture(Future<A> future) {
        return forListenableFuture(JdkFutureAdapters.listenInPoolThread(future));
    }
1133770
@SuppressWarnings("unchecked")
    public <R> FutureStream<R> from(final Collection<R> collection) {
        return fromStream(collection.stream());
    }
309494
@SafeVarargs
    public static <T> ContinuableFuture<T> anyOf(final Future<? extends T>... cfs) {
        return anyOf2(Arrays.asList(cfs));
    }