cyclops.companion.vavr.Arrays Maven / Gradle / Ivy

Go to download
package cyclops.companion.vavr;


import com.aol.cyclops.vavr.hkt.*;
import cyclops.companion.CompletableFutures;
import cyclops.companion.Optionals;
import cyclops.control.Eval;
import cyclops.control.Maybe;
import cyclops.control.Reader;
import cyclops.control.Xor;
import cyclops.conversion.vavr.FromCyclopsReact;
import cyclops.monads.*;
import cyclops.monads.VavrWitness.*;
import com.aol.cyclops2.hkt.Higher;
import com.aol.cyclops2.types.anyM.AnyMSeq;
import cyclops.function.Fn3;
import cyclops.function.Fn4;
import cyclops.function.Monoid;

import cyclops.monads.VavrWitness.either;
import cyclops.monads.VavrWitness.future;
import cyclops.monads.VavrWitness.list;
import cyclops.monads.VavrWitness.tryType;
import cyclops.monads.Witness.*;
import cyclops.stream.ReactiveSeq;
import cyclops.typeclasses.*;
import cyclops.typeclasses.comonad.Comonad;
import cyclops.typeclasses.foldable.Foldable;
import cyclops.typeclasses.foldable.Unfoldable;
import cyclops.typeclasses.functor.Functor;
import cyclops.typeclasses.instances.General;
import cyclops.typeclasses.monad.*;
import io.vavr.Lazy;
import io.vavr.collection.*;
import io.vavr.concurrent.Future;
import io.vavr.control.Either;
import io.vavr.control.Option;
import io.vavr.control.Try;
import lombok.experimental.UtilityClass;
import org.jooq.lambda.tuple.Tuple2;

import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.function.Function;

import static com.aol.cyclops.vavr.hkt.ArrayKind.widen;


public class Arrays {

    public static   Coproduct coproduct(Array list, InstanceDefinitions def1){
        return Coproduct.of(Xor.primary(widen(list)),def1, Instances.definitions());
    }
    public static   Coproduct coproduct(InstanceDefinitions def1,T... values){
        return coproduct(Array.of(values),def1);
    }
    public static  ,T> XorM xorM(Array type){
        return XorM.right(anyM(type));
    }
   
    public static  AnyMSeq anyM(Array option) {
        return AnyM.ofSeq(option, array.INSTANCE);
    }
    /**
     * Perform a For Comprehension over a Array, accepting 3 generating functions.
     * This results in a four level nested internal iteration over the provided Publishers.
     *
     *       * {@code
     *
     *   import static cyclops.Arrays.forEach4;
     *
    forEach4(IntArray.range(1,10).boxed(),
    a-> Array.iterate(a,i->i+1).limit(10),
    (a,b) -> Array.of(a+b),
    (a,b,c) -> Array.just(a+b+c),
    Tuple::tuple)
     *
     * }
     * 
     *
     * @param value1 top level Array
     * @param value2 Nested Array
     * @param value3 Nested Array
     * @param value4 Nested Array
     * @param yieldingFunction  Generates a result per combination
     * @return Array with an element per combination of nested publishers generated by the yielding function
     */
    public static  Array forEach4(Array value1,
                                                               Function> value2,
                                                               BiFunction> value3,
                                                               Fn3> value4,
                                                               Fn4 yieldingFunction) {


        return value1.flatMap(in -> {

            Array a = value2.apply(in);
            return a.flatMap(ina -> {
                Array b = value3.apply(in,ina);
                return b.flatMap(inb -> {
                    Array c = value4.apply(in,ina,inb);
                    return c.map(in2 -> yieldingFunction.apply(in, ina, inb, in2));
                });

            });

        });

    }

    /**
     * Perform a For Comprehension over a Array, accepting 3 generating function.
     * This results in a four level nested internal iteration over the provided Publishers.
     *      * {@code
     *
     *  import static com.aol.cyclops2.reactor.Arrayes.forEach4;
     *
     *  forEach4(IntArray.range(1,10).boxed(),
    a-> Array.iterate(a,i->i+1).limit(10),
    (a,b) -> Array.just(a+b),
    (a,b,c) -> Array.just(a+b+c),
    (a,b,c,d) -> a+b+c+d <100,
    Tuple::tuple);
     *
     * }
     * 
     *
     * @param value1 top level Array
     * @param value2 Nested Array
     * @param value3 Nested Array
     * @param value4 Nested Array
     * @param filterFunction A filtering function, keeps values where the predicate holds
     * @param yieldingFunction Generates a result per combination
     * @return Array with an element per combination of nested publishers generated by the yielding function
     */
    public static  Array forEach4(Array value1,
                                                                 Function> value2,
                                                                 BiFunction> value3,
                                                                 Fn3> value4,
                                                                 Fn4 filterFunction,
                                                                 Fn4 yieldingFunction) {


        return value1.flatMap(in -> {

            Array a = value2.apply(in);
            return a.flatMap(ina -> {
                Array b = value3.apply(in,ina);
                return b.flatMap(inb -> {
                    Array c = value4.apply(in,ina,inb);
                    return c.filter(in2->filterFunction.apply(in,ina,inb,in2))
                            .map(in2 -> yieldingFunction.apply(in, ina, inb, in2));
                });

            });

        });
    }

    /**
     * Perform a For Comprehension over a Array, accepting 2 generating function.
     * This results in a three level nested internal iteration over the provided Publishers.
     *
     *      * {@code
     *
     * import static Arrays.forEach3;
     *
     * forEach(IntArray.range(1,10).boxed(),
    a-> Array.iterate(a,i->i+1).limit(10),
    (a,b) -> Array.of(a+b),
    Tuple::tuple);
     *
     * }
     * 
     *
     *
     * @param value1 top level Array
     * @param value2 Nested Array
     * @param value3 Nested Array
     * @param yieldingFunction Generates a result per combination
     * @return Array with an element per combination of nested publishers generated by the yielding function
     */
    public static  Array forEach3(Array value1,
                                                         Function> value2,
                                                         BiFunction> value3,
                                                         Fn3 yieldingFunction) {

        return value1.flatMap(in -> {

            Array a = value2.apply(in);
            return a.flatMap(ina -> {
                Array b = value3.apply(in,ina);
                return b.map(in2 -> yieldingFunction.apply(in, ina, in2));
            });


        });


    }

    /**
     * Perform a For Comprehension over a Array, accepting 2 generating function.
     * This results in a three level nested internal iteration over the provided Publishers.
     *      * {@code
     *
     * import static Arrays.forEach;
     *
     * forEach(IntArray.range(1,10).boxed(),
    a-> Array.iterate(a,i->i+1).limit(10),
    (a,b) -> Array.of(a+b),
    (a,b,c) ->a+b+c<10,
    Tuple::tuple)
    .toArrayX();
     * }
     * 
     *
     * @param value1 top level Array
     * @param value2 Nested publisher
     * @param value3 Nested publisher
     * @param filterFunction A filtering function, keeps values where the predicate holds
     * @param yieldingFunction Generates a result per combination
     * @return
     */
    public static  Array forEach3(Array value1,
                                                         Function> value2,
                                                         BiFunction> value3,
                                                         Fn3 filterFunction,
                                                         Fn3 yieldingFunction) {


        return value1.flatMap(in -> {

            Array a = value2.apply(in);
            return a.flatMap(ina -> {
                Array b = value3.apply(in,ina);
                return b.filter(in2->filterFunction.apply(in,ina,in2))
                        .map(in2 -> yieldingFunction.apply(in, ina, in2));
            });



        });
    }

    /**
     * Perform a For Comprehension over a Array, accepting an additonal generating function.
     * This results in a two level nested internal iteration over the provided Publishers.
     *
     *      * {@code
     *
     *  import static Arrays.forEach2;
     *  forEach(IntArray.range(1, 10).boxed(),
     *          i -> Array.range(i, 10), Tuple::tuple)
    .forEach(System.out::println);

    //(1, 1)
    (1, 2)
    (1, 3)
    (1, 4)
    ...
     *
     * }
     *
     * @param value1 top level Array
     * @param value2 Nested publisher
     * @param yieldingFunction Generates a result per combination
     * @return
     */
    public static  Array forEach2(Array value1,
                                                Function> value2,
                                                BiFunction yieldingFunction) {


        return value1.flatMap(in -> {

            Array a = value2.apply(in);
            return a.map(in2 -> yieldingFunction.apply(in,  in2));
        });

    }

    /**
     *
     *      * {@code
     *
     *   import static Arrays.forEach2;
     *
     *   forEach(IntArray.range(1, 10).boxed(),
     *           i -> Array.range(i, 10),
     *           (a,b) -> a>2 && b<10,
     *           Tuple::tuple)
    .forEach(System.out::println);

    //(3, 3)
    (3, 4)
    (3, 5)
    (3, 6)
    (3, 7)
    (3, 8)
    (3, 9)
    ...

     *
     * }
     *
     *
     * @param value1 top level Array
     * @param value2 Nested publisher
     * @param filterFunction A filtering function, keeps values where the predicate holds
     * @param yieldingFunction Generates a result per combination
     * @return
     */
    public static  Array forEach2(Array value1,
                                                Function> value2,
                                                BiFunction filterFunction,
                                                BiFunction yieldingFunction) {


        return value1.flatMap(in -> {

            Array a = value2.apply(in);
            return a.filter(in2->filterFunction.apply(in,in2))
                    .map(in2 -> yieldingFunction.apply(in,  in2));
        });
    }
    public static  Active allTypeclasses(Array array){
        return Active.of(widen(array), Instances.definitions());
    }
    public static  Nested mapM(Array array, Function> fn, InstanceDefinitions defs){
        Array> e = array.map(fn);
        ArrayKind> lk = widen(e);
        return Nested.of(lk, Arrays.Instances.definitions(), defs);
    }
    /**
     * Companion class for creating Type Class instances for working with Arrays*
     */
    @UtilityClass
    public static class Instances {
        public static InstanceDefinitions definitions() {
            return new InstanceDefinitions() {

                @Override
                public  Functor functor() {
                    return Instances.functor();
                }

                @Override
                public  Pure unit() {
                    return Instances.unit();
                }

                @Override
                public  Applicative applicative() {
                    return Instances.zippingApplicative();
                }

                @Override
                public  Monad monad() {
                    return Instances.monad();
                }

                @Override
                public  Maybe> monadZero() {
                    return Maybe.just(Instances.monadZero());
                }

                @Override
                public  Maybe> monadPlus() {
                    return Maybe.just(Instances.monadPlus());
                }

                @Override
                public  Maybe> monadPlus(Monoid> m) {
                    return Maybe.just(Instances.monadPlus(m));
                }

                @Override
                public  Maybe> traverse() {
                    return Maybe.just(Instances.traverse());
                }

                @Override
                public  Maybe> foldable() {
                    return Maybe.just(Instances.foldable());
                }

                @Override
                public  Maybe> comonad() {
                    return Maybe.none();
                }

                @Override
                public  Maybe> unfoldable() {
                    return Maybe.just(Instances.unfoldable());
                }
            };

        }
        /**
         *
         * Transform a list, mulitplying every element by 2
         *
         *          * {@code
         *  ArrayKind list = Arrays.functor().map(i->i*2, ArrayKind.widen(Arrays.asArray(1,2,3));
         *
         *  //[2,4,6]
         *
         *
         * }
         * 
         *
         * An example fluent api working with Arrays
         *          * {@code
         *   ArrayKind list = Arrays.unit()
        .unit("hello")
        .then(h->Arrays.functor().map((String v) ->v.length(), h))
        .convert(ArrayKind::narrowK);
         *
         * }
         * 
         *
         *
         * @return A functor for Arrays
         */
        public static Functor functor(){
            BiFunction,Function,ArrayKind> map = Instances::map;
            return General.functor(map);
        }
        /**
         *          * {@code
         * ArrayKind list = Arrays.unit()
        .unit("hello")
        .convert(ArrayKind::narrowK);

        //Arrays.asArray("hello"))
         *
         * }
         * 
         *
         *
         * @return A factory for Arrays
         */
        public static  Pure unit(){
            return General.unit(ArrayKind::of);
        }
        /**
         *
         *          * {@code
         * import static com.aol.cyclops.hkt.jdk.ArrayKind.widen;
         * import static com.aol.cyclops.util.function.Lambda.l1;
         * import static java.util.Arrays.asArray;
         *
        Arrays.zippingApplicative()
        .ap(widen(asArray(l1(this::multiplyByTwo))),widen(asArray(1,2,3)));
         *
         * //[2,4,6]
         * }
         * 
         *
         *
         * Example fluent API
         *          * {@code
         * ArrayKind> listFn =Arrays.unit()
         *                                                  .unit(Lambda.l1((Integer i) ->i*2))
         *                                                  .convert(ArrayKind::narrowK);

        ArrayKind list = Arrays.unit()
        .unit("hello")
        .then(h->Arrays.functor().map((String v) ->v.length(), h))
        .then(h->Arrays.zippingApplicative().ap(listFn, h))
        .convert(ArrayKind::narrowK);

        //Arrays.asArray("hello".length()*2))
         *
         * }
         * 
         *
         *
         * @return A zipper for Arrays
         */
        public static  Applicative zippingApplicative(){
            BiFunction>,ArrayKind,ArrayKind> ap = Instances::ap;
            return General.applicative(functor(), unit(), ap);
        }
        /**
         *
         *          * {@code
         * import static com.aol.cyclops.hkt.jdk.ArrayKind.widen;
         * ArrayKind list  = Arrays.monad()
        .flatMap(i->widen(ArrayX.range(0,i)), widen(Arrays.asArray(1,2,3)))
        .convert(ArrayKind::narrowK);
         * }
         * 
         *
         * Example fluent API
         *          * {@code
         *    ArrayKind list = Arrays.unit()
        .unit("hello")
        .then(h->Arrays.monad().flatMap((String v) ->Arrays.unit().unit(v.length()), h))
        .convert(ArrayKind::narrowK);

        //Arrays.asArray("hello".length())
         *
         * }
         * 
         *
         * @return Type class with monad functions for Arrays
         */
        public static  Monad monad(){

            BiFunction,Function>,Higher> flatMap = Instances::flatMap;
            return General.monad(zippingApplicative(), flatMap);
        }
        /**
         *
         *          * {@code
         *  ArrayKind list = Arrays.unit()
        .unit("hello")
        .then(h->Arrays.monadZero().filter((String t)->t.startsWith("he"), h))
        .convert(ArrayKind::narrowK);

        //Arrays.asArray("hello"));
         *
         * }
         * 
         *
         *
         * @return A filterable monad (with default value)
         */
        public static  MonadZero monadZero(){

            return General.monadZero(monad(), widen(Array.empty()));
        }
        /**
         *          * {@code
         *  ArrayKind list = Arrays.monadPlus()
        .plus(ArrayKind.widen(Arrays.asArray()), ArrayKind.widen(Arrays.asArray(10)))
        .convert(ArrayKind::narrowK);
        //Arrays.asArray(10))
         *
         * }
         * 
         * @return Type class for combining Arrays by concatenation
         */
        public static  MonadPlus monadPlus(){
            Monoid> m = Monoid.of(widen(Array.empty()), Instances::concat);
            Monoid> m2= (Monoid)m;
            return General.monadPlus(monadZero(),m2);
        }
        /**
         *
         *          * {@code
         *  Monoid> m = Monoid.of(ArrayKind.widen(Arrays.asArray()), (a,b)->a.isEmpty() ? b : a);
        ArrayKind list = Arrays.monadPlus(m)
        .plus(ArrayKind.widen(Arrays.asArray(5)), ArrayKind.widen(Arrays.asArray(10)))
        .convert(ArrayKind::narrowK);
        //Arrays.asArray(5))
         *
         * }
         * 
         *
         * @param m Monoid to use for combining Arrays
         * @return Type class for combining Arrays
         */
        public static  MonadPlus monadPlus(Monoid> m){
            Monoid> m2= (Monoid)m;
            return General.monadPlus(monadZero(),m2);
        }
        public static  MonadPlus monadPlusK(Monoid> m){
            Monoid> m2= (Monoid)m;
            return General.monadPlus(monadZero(),m2);
        }
        public static Unfoldable unfoldable(){
            return new Unfoldable() {
                @Override
                public  Higher unfold(T b, Function>> fn) {
                    return widen(ReactiveSeq.unfold(b,fn).collect(Array.collector()));

                }
            };
        }
        /**
         * @return Type class for traversables with traverse / sequence operations
         */
        public static  Traverse traverse(){

            BiFunction,ArrayKind>,Higher>> sequenceFn = (ap, list) -> {

                Higher> identity = ap.unit(widen(Array.empty()));

                BiFunction>,Higher,Higher>> combineToArray =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> widen(ArrayKind.narrow(a).append(b))),
                        acc,next);

                BinaryOperator>> combineArrays = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> widen(ArrayKind.narrow(l1).appendAll(l2.narrow()))),a,b); ;

                return ReactiveSeq.fromIterable(ArrayKind.narrow(list))
                        .reduce(identity,
                                combineToArray,
                                combineArrays);


            };
            BiFunction,Higher>,Higher>> sequenceNarrow  =
                    (a,b) -> ArrayKind.widen2(sequenceFn.apply(a, ArrayKind.narrowK(b)));
            return General.traverse(zippingApplicative(), sequenceNarrow);
        }

        /**
         *
         *          * {@code
         * int sum  = Arrays.foldable()
        .foldLeft(0, (a,b)->a+b, ArrayKind.widen(Arrays.asArray(1,2,3,4)));

        //10
         *
         * }
         * 
         *
         *
         * @return Type class for folding / reduction operations
         */
        public static  Foldable foldable(){
            BiFunction,Higher,T> foldRightFn =  (m, l)-> ReactiveSeq.fromIterable(ArrayKind.narrow(l)).foldRight(m);
            BiFunction,Higher,T> foldLeftFn = (m, l)-> ReactiveSeq.fromIterable(ArrayKind.narrow(l)).reduce(m);
            return General.foldable(foldRightFn, foldLeftFn);
        }

        private static   ArrayKind concat(ArrayKind l1, ArrayKind l2){

            return widen(l1.appendAll(ArrayKind.narrow(l2)));

        }

        private static  ArrayKind ap(ArrayKind> lt, ArrayKind list){
            return widen(FromCyclopsReact.fromStream(ReactiveSeq.fromIterable(lt.narrow()).zip(list.narrow(), (a, b)->a.apply(b))).toArray());
        }
        private static  Higher flatMap(Higher lt, Function> fn){
            return widen(ArrayKind.narrow(lt).flatMap(fn.andThen(ArrayKind::narrow)));
        }
        private static  ArrayKind map(ArrayKind lt, Function fn){
            return widen(ArrayKind.narrow(lt).map(in->fn.apply(in)));
        }
    }

    public static interface ArrayNested{


        public static  Nested option(Array> type){
            return Nested.of(widen(type.map(OptionKind::widen)),Instances.definitions(),Options.Instances.definitions());
        }
        public static  Nested arrayTry(Array> type){
            return Nested.of(widen(type.map(TryKind::widen)),Instances.definitions(),Trys.Instances.definitions());
        }
        public static  Nested future(Array> type){
            return Nested.of(widen(type.map(FutureKind::widen)),Instances.definitions(),Futures.Instances.definitions());
        }
        public static  Nested lazy(Array> nested){
            return Nested.of(widen(nested.map(LazyKind::widen)),Instances.definitions(),Lazys.Instances.definitions());
        }
        public static  Nested, R> either(Array> nested){
            return Nested.of(widen(nested.map(EitherKind::widen)),Instances.definitions(),Eithers.Instances.definitions());
        }
        public static  Nested queue(Array> nested){
            return Nested.of(widen(nested.map(QueueKind::widen)), Instances.definitions(),Queues.Instances.definitions());
        }
        public static  Nested stream(Array> nested){
            return Nested.of(widen(nested.map(StreamKind::widen)),Instances.definitions(),Streams.Instances.definitions());
        }
        public static  Nested list(Array> nested){
            return Nested.of(widen(nested.map(ListKind::widen)), Instances.definitions(),Lists.Instances.definitions());
        }
        public static  Nested array(Array> nested){
            return Nested.of(widen(nested.map(ArrayKind::widen)),Instances.definitions(),Arrays.Instances.definitions());
        }
        public static  Nested vector(Array> nested){
            return Nested.of(widen(nested.map(VectorKind::widen)),Instances.definitions(),Vectors.Instances.definitions());
        }
        public static  Nested set(Array> nested){
            return Nested.of(widen(nested.map(HashSetKind::widen)),Instances.definitions(), HashSets.Instances.definitions());
        }

        public static  Nested reactiveSeq(Array> nested){
            ArrayKind> x = widen(nested);
            ArrayKind> y = (ArrayKind)x;
            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
        }

        public static  Nested maybe(Array> nested){
            ArrayKind> x = widen(nested);
            ArrayKind> y = (ArrayKind)x;
            return Nested.of(y,Instances.definitions(),Maybe.Instances.definitions());
        }
        public static  Nested eval(Array> nested){
            ArrayKind> x = widen(nested);
            ArrayKind> y = (ArrayKind)x;
            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
        }
        public static  Nested cyclopsFuture(Array> nested){
            ArrayKind> x = widen(nested);
            ArrayKind> y = (ArrayKind)x;
            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
        }
        public static  Nested, P> xor(Array> nested){
            ArrayKind> x = widen(nested);
            ArrayKind, P>> y = (ArrayKind)x;
            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
        }
        public static  Nested, T> reader(Array> nested){
            ArrayKind> x = widen(nested);
            ArrayKind, T>> y = (ArrayKind)x;
            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
        }
        public static  Nested, P> cyclopsTry(Array> nested){
            ArrayKind> x = widen(nested);
            ArrayKind, P>> y = (ArrayKind)x;
            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
        }
        public static  Nested optional(Array> nested){
            ArrayKind> x = widen(nested);
            ArrayKind> y = (ArrayKind)x;
            return Nested.of(y,Instances.definitions(), Optionals.Instances.definitions());
        }
        public static  Nested completableFuture(Array> nested){
            ArrayKind> x = widen(nested);
            ArrayKind> y = (ArrayKind)x;
            return Nested.of(y,Instances.definitions(), CompletableFutures.Instances.definitions());
        }
        public static  Nested javaStream(Array> nested){
            ArrayKind> x = widen(nested);
            ArrayKind> y = (ArrayKind)x;
            return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
        }



    }
    public static interface NestedArray{
        public static  Nested reactiveSeq(ReactiveSeq> nested){
            ReactiveSeq> x = nested.map(ArrayKind::widenK);
            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
        }

        public static  Nested maybe(Maybe> nested){
            Maybe> x = nested.map(ArrayKind::widenK);

            return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
        }
        public static  Nested eval(Eval> nested){
            Eval> x = nested.map(ArrayKind::widenK);

            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
        }
        public static  Nested cyclopsFuture(cyclops.async.Future> nested){
            cyclops.async.Future> x = nested.map(ArrayKind::widenK);

            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
        }
        public static  Nested,array, P> xor(Xor> nested){
            Xor> x = nested.map(ArrayKind::widenK);

            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
        }
        public static  Nested,array, T> reader(Reader> nested){

            Reader>  x = nested.map(ArrayKind::widenK);

            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
        }
        public static  Nested,array, P> cyclopsTry(cyclops.control.Try, S> nested){
            cyclops.control.Try, S> x = nested.map(ArrayKind::widenK);

            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
        }
        public static  Nested optional(Optional> nested){
            Optional> x = nested.map(ArrayKind::widenK);

            return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
        }
        public static  Nested completableFuture(CompletableFuture> nested){
            CompletableFuture> x = nested.thenApply(ArrayKind::widenK);

            return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
        }
        public static  Nested javaStream(java.util.stream.Stream> nested){
            java.util.stream.Stream> x = nested.map(ArrayKind::widenK);

            return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
        }
    }



}