Java Future类代码示例

import io.vavr.concurrent.Future; //导入依赖的package包/类
private void sendTweet(final String text) {
    final Future<Status> updateResult = Future(
            () -> this.twitterHandler.getTwitter().updateStatus(text)
    );

    Stream(tweetTextArea, sendButton).forEach(ctr -> ctr.setDisable(true));

    updateResult.onComplete(res -> {
        res.onFailure(err ->
                Stages.stageOf(
                        "Couldn't send tweet !",
                        new ExceptionHandler(err).asPane()
                ).thenAccept(Stages::scheduleDisplaying));
        res.onSuccess(status ->
                stageManager.getSingle(Views.TWEET_VIEW).peek(Stages::scheduleHiding)
        );
    });
}
 

import io.vavr.concurrent.Future; //导入依赖的package包/类
public static <T, R> Future<R> tailRec(T initial, Function<? super T, ? extends Future<  ? extends io.vavr.control.Either<T, R>>> fn) {
    Future<? extends io.vavr.control.Either<T, R>> next[] = new Future[1];
    next[0] = Future.of(()->io.vavr.control.Either.left(initial));
    boolean cont = true;
    do {

        try{
            next[0].get();
        }catch(Throwable t){
            cont= false;
        }
        if(cont) {
            cont =  next[0].get().fold(s -> {
                next[0] = fn.apply(s);
                return true;
            }, pr -> false);
        }
    } while (cont);
    return next[0].map(e->e.get());
}
 

import io.vavr.concurrent.Future; //导入依赖的package包/类
/**
 * Convert the HigherKindedType definition for a Future into
 *
 * @param completableFuture Type Constructor to convert back into narrowed type
 * @return Future from Higher Kinded Type
 */
public static <T> Future<T> narrow(final Higher<future, T> completableFuture) {
    if (completableFuture instanceof Future) {
        return (Future)completableFuture;

    }
    // this code should be unreachable due to HKT type checker
    final Box<T> type = (Box<T>) completableFuture;
    final Future<T> stage = type.narrow();
    return stage;

}
 

import io.vavr.concurrent.Future; //导入依赖的package包/类
@Override
public <T, R> AnyM<future, R> ap(AnyM<future,? extends Function<? super T,? extends R>> fn, AnyM<future, T> apply) {
    Future<T> f = future(apply);
    Future<? extends Function<? super T, ? extends R>> fnF = future(fn);
    Future<R> res = FromCyclops.future(ToCyclops.future(fnF).combine(ToCyclops.future(f), (a, b) -> a.apply(b)));
    return Vavr.future(res);

}
 

import io.vavr.concurrent.Future; //导入依赖的package包/类
@Test
public void monadZeroFilter(){

    FutureKind<String> opt = Futures.Instances.unit()
                                 .unit("hello")
                                 .applyHKT(h-> Futures.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
                                 .convert(FutureKind::narrowK);

    assertThat(opt.get(),equalTo(Future.successful("hello").get()));
}
 

import io.vavr.concurrent.Future; //导入依赖的package包/类
@Test
public void  foldLeft(){
    int sum  = Futures.Instances.foldable()
                    .foldLeft(0, (a,b)->a+b, FutureKind.widen(Future.successful(4)));

    assertThat(sum,equalTo(4));
}
 

import io.vavr.concurrent.Future; //导入依赖的package包/类
@Test
public void futureTest() {
    assertThat(Vavr.future(Future.of(() -> "hello world"))
                        .map(String::toUpperCase)
                        .to(ANY_M_LIST_FUNCTION),
               equalTo(Arrays.asList("HELLO WORLD")));
}
 

import io.vavr.concurrent.Future; //导入依赖的package包/类
@Test
public void monadPlusNonEmpty(){

    Monoid<FutureKind<Integer>> m = Monoid.of(FutureKind.widen(cyclops.async.Future.future()), (a, b)->a.isCompleted() ? b : a);
    FutureKind<Integer> opt = Futures.Instances.<Integer>monadPlusK(m)
                                  .plus(FutureKind.widen(Future.successful(5)), FutureKind.widen(Future.successful(10)))
                                  .convert(FutureKind::narrowK);
    assertThat(opt.get(),equalTo(Future.successful(10).get()));
}
 

import io.vavr.concurrent.Future; //导入依赖的package包/类
@Test
public void futureFlatMapTest() {
    assertThat(Vavr.future(Future.of(() -> "hello world"))
                        .map(String::toUpperCase)
                        .to(ANY_M_LIST_FUNCTION),
               equalTo(Arrays.asList("HELLO WORLD")));
}
 

import io.vavr.concurrent.Future; //导入依赖的package包/类
@Test
public void monad(){

    FutureKind<Integer> opt = Futures.Instances.unit()
                                 .unit("hello")
                                 .applyHKT(h-> Futures.Instances.monad().flatMap((String v) -> Futures.Instances.unit().unit(v.length()), h))
                                 .convert(FutureKind::narrowK);

    assertThat(opt.get(),equalTo(Future.successful("hello".length()).get()));
}
 

import io.vavr.concurrent.Future; //导入依赖的package包/类
public static <T> Higher<future,T> widenK(final Future<T> completableList) {

        return new FutureKind.Box<>(
                completableList);
    }
 

import io.vavr.concurrent.Future; //导入依赖的package包/类
default <R> FutureKind<R> fold(Function<? super Future<? super T>,? extends Future<R>> op){
    return widen(op.apply(this));
}
 

import io.vavr.concurrent.Future; //导入依赖的package包/类
public static <T> FutureKind<T> failed(Throwable exception){
    return widen(Future.failed(exception));
}
 

import io.vavr.concurrent.Future; //导入依赖的package包/类
@Override
public AnyMValue<future, Boolean> save(String data){
    return anyM(Future.ofSupplier(ex,()->true));
}
 

import io.vavr.concurrent.Future; //导入依赖的package包/类
public static <T> Nested<Witness.future,future,T> cyclopsFuture(cyclops.async.Future<Future<T>> nested){
    cyclops.async.Future<Higher<future,T>> x = nested.map(FutureKind::widenK);

    return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
}