org.smallibs.concurrent.promise.PromiseHelper Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of hpas Show documentation

Functional ADT And Asynchronous library in Java

There is a newer version: 0.11.0

/*
 * HPAS
 * https://github.com/d-plaindoux/hpas
 *
 * Copyright (c) 2016-2017 Didier Plaindoux
 * Licensed under the LGPL2 license.
 */

package org.smallibs.concurrent.promise;

import org.smallibs.concurrent.promise.impl.SolvedPromise;
import org.smallibs.control.Functor;
import org.smallibs.control.Monad;
import org.smallibs.data.Try;
import org.smallibs.type.HK;
import org.smallibs.util.FunctionsWithError;

import java.util.function.Function;

public enum PromiseHelper {
    ;

    public static  Monad> monad(Promise promise) {
        return new Monadic<>(promise);
    }

    public static  Promise success(T t) {
        return new SolvedPromise(Try.success(t));
    }

    public static  Promise failure(Throwable t) {
        return new SolvedPromise(Try.failure(t));
    }

    @SuppressWarnings("unchecked")
    private static > HK> specialize(HK app) {
        return (HK>) app;
    }

    @SuppressWarnings("unchecked")
    private static > HK generalize(HK> app) {
        return (HK) app;
    }

    /**
     * @param 
     */
    private final static class Monadic implements Monad> {
        private final Promise promise;

        Monadic(Promise promise) {
            this.promise = promise;
        }

        @Override
        public > HK map(Function function) {
            return generalize(new Monadic<>(promise.map(FunctionsWithError.fromFunction(function))));
        }

        @Override
        public > HK flatmap(Function> function) {
            final Function> tPromiseFunction = t -> {
                final HK apply = function.apply(t);
                return PromiseHelper.specialize(apply).self();
            };
            return generalize(new Monadic<>(promise.flatmap(tPromiseFunction)));
        }

        @Override
        public  T1 accept(Function>, T1> f) {
            return promise.accept(f);
        }


        @Override
        public > HK apply(Functor, ?> functor) {
            return generalize(new Monadic<>(promise.flatmap(a -> {
                final HK map = functor.map(bFunction -> bFunction.apply(a));
                return specialize(map).self();
            })));
        }

        @Override
        public Promise self() {
            return promise;
        }
    }

}