com.aol.cyclops.vavr.hkt.EitherKind Maven / Gradle / Ivy

Go to download
package com.aol.cyclops.vavr.hkt;

import com.aol.cyclops2.hkt.Higher;
import com.aol.cyclops2.hkt.Higher2;
import com.aol.cyclops2.types.foldable.To;
import cyclops.companion.vavr.Eithers;
import cyclops.conversion.vavr.ToCyclopsReact;
import cyclops.monads.VavrWitness;
import cyclops.monads.VavrWitness.either;
import cyclops.monads.WitnessType;
import cyclops.monads.transformers.XorT;
import cyclops.typeclasses.Active;
import cyclops.typeclasses.InstanceDefinitions;
import cyclops.typeclasses.Nested;

import io.vavr.CheckedFunction0;

import io.vavr.Tuple2;
import io.vavr.Value;
import io.vavr.collection.*;
import io.vavr.collection.Iterator;
import io.vavr.collection.PriorityQueue;
import io.vavr.collection.Queue;
import io.vavr.collection.SortedMap;
import io.vavr.collection.SortedSet;
import io.vavr.collection.Vector;
import io.vavr.control.Either;
import io.vavr.control.Option;
import io.vavr.control.Try;
import io.vavr.control.Validation;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;

import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.*;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.function.*;
import java.util.stream.Collector;
import java.util.stream.Stream;


public interface EitherKind extends Either,To>,
                                        Higher2 {

    default  EitherKind fold(Function,? extends Either> op){
        return widen(op.apply(this));
    }
    public static  Higher,R> widenK(final Either completableList) {

        return new EitherKind.Box<>(
                completableList);
    }
    public static  EitherKind widen(final Either either) {
        return new Box<>(either);
    }
    public static  EitherKind rightK(final R right) {
        return new Box<>(Either.right(right));
    }
    public static  EitherKind leftK(final L left) {
        return new Box<>(Either.left(left));
    }
    public static  Either narrowK2(final Higher2 xor) {
        return (Either)xor;
    }
    public static  Either narrowK(final Higher, R> either) {
        return (Either)either;
    }
    default Active,R> allTypeclasses(){
        return Active.of(this, Eithers.Instances.definitions());
    }
    default  Nested,W2,R2> mapM(Function> fn, InstanceDefinitions defs){
        return Nested.of(widen(bimap(l->l,r->fn.apply(r))), Eithers.Instances.definitions(), defs);
    }
    default > XorT liftM(W witness) {
        return XorT.of(witness.adapter().unit(ToCyclopsReact.xor(this)));
    }
    public static  Either right(R1 right) {
        return Either.right(right);
    }

    public static  Either left(L1 left) {
        return Either.left(left);
    }

    public static  Either narrow(Either either) {
        return Either.narrow(either);
    }

    @AllArgsConstructor(access = AccessLevel.PRIVATE)
    static final class Box implements EitherKind {

        private final Either boxed;

        public Either narrow() {
            return boxed;
        }

        @Override
        public L getLeft() {
            return boxed.getLeft();
        }

        @Override
        public boolean isLeft() {
            return false;
        }

        @Override
        public boolean isRight() {
            return boxed.isRight();
        }

        @Override
        public R get() {
            return boxed.get();
        }

        @Override
        public String stringPrefix() {
            return boxed.stringPrefix();
        }
    }




}