cyclops.control

Interface LazyEither<LT,RT>

Type Parameters:

LT - Left type

RT - Right type

All Superinterfaces:

BiTransformable<LT,RT>, Convert<Higher<Higher<DataWitness.either,LT>,RT>>, Either<LT,RT>, Filters<RT>, Higher<Higher<DataWitness.either,LT>,RT>, Higher2<DataWitness.either,LT,RT>, io.kindedj.Hk<Higher<DataWitness.either,LT>,RT>, java.lang.Iterable<RT>, OrElseValue<RT,Either<LT,RT>>, org.reactivestreams.Publisher<RT>, Sealed2<LT,RT>, SealedOr<RT>, java.io.Serializable, To<Either<LT,RT>>, Transformable<RT>, Unit<RT>, Value<RT>

All Known Implementing Classes:

LazyEither.CompletableEither, LazyEither.Lazy, LazyEither.Left, LazyEither.Right

public interface LazyEither<LT,RT>
extends Either<LT,RT>

A totally Lazy Either implementation with tail call optimization for transform and flatMap operators. LazyEither can operate reactively (i.e. suppports data arriving asynchronsouly the monadic chain of computations will only be executed once data arrives). 'Right' (or right type) biased disjunct union. No 'projections' are provided, swap() and secondaryXXXX alternative methods can be used instead. Either is used to represent values that can be one of two states (for example a validation result, lazy everything is ok - or we have an error). It can be used to avoid a common design anti-pattern where an Object has two fields one of which is always null (or worse, both are defined as Optionals).

  

     public class Member{
           LazyEither team;
     }

     Rather than

     public class Member{

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LazyEither.CompletableEither<ORG,RT>
static class	LazyEither.Lazy<ST,PT>
static class	LazyEither.Left<ST,PT>
static class	LazyEither.Right<ST,PT>

Method Summary

Modifier and Type	Method and Description
static <LT1,RT> LazyEither<LT1,RT>	accumulate(Monoid<RT> reducer, java.lang.Iterable<LazyEither<LT1,RT>> xors) Accumulate the results only from those Either3 which have a Right type present, using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) com.oath.cyclops.Monoids .
static <LT,RT> LazyEither<LT,RT>	always(java.util.function.Supplier<Either<LT,RT>> lazy)
static <X,LT extends X,M extends X,RT extends X,R> java.util.function.Function<java.util.function.Function<? super X,R>,R>	applyAny(LazyEither<LT,RT> either)
default int	arity()
static <RT> LazyEither<java.lang.Throwable,RT>	async(java.util.concurrent.Executor ex, java.util.function.Supplier<RT> s)
default <R1,R2> LazyEither<R1,R2>	bimap(java.util.function.Function<? super LT,? extends R1> secondary, java.util.function.Function<? super RT,? extends R2> primary) Transform this BiTransformable, changing two value types at once.
default LazyEither<LT,RT>	bipeek(java.util.function.Consumer<? super LT> c1, java.util.function.Consumer<? super RT> c2) Peek at two data types simulatanously (typically to perform a side-effect with each data point)
default <T2,R> LazyEither<LT,R>	combine(Either<? extends LT,? extends T2> app, java.util.function.BinaryOperator<LT> semigroup, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn) Accumulate left values with the provided BinaryOperator / Semigroup Semigroups Right accumulation only occurs if all phases are right
default <T2,R> LazyEither<LT,R>	combine(LazyEither<? extends LT,? extends T2> app, java.util.function.BinaryOperator<LT> semigroup, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn) Accumulate left values with the provided BinaryOperator / Semigroup Semigroups Right accumulation only occurs if all phases are right
default <T2,R> LazyEither<LazySeq<LT>,R>	combineToLazySeq(Either<LT,? extends T2> app, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn) Accumulate lefts into a LazySeq (extended Persistent List) and Right with the supplied combiner function Right accumulation only occurs if all phases are right
default <T2,R> LazyEither<LazySeq<LT>,R>	combineToList(LazyEither<LT,? extends T2> app, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn) Accumulate secondarys into a LazySeq (extended Persistent List) and Right with the supplied combiner function Right accumulation only occurs if all phases are right
static <X,LT extends X,M extends X,RT extends X> java.util.function.Consumer<java.util.function.Consumer<? super X>>	consumeAny(LazyEither<LT,RT> either) Static method useful as a method reference for fluent consumption of any value type stored in this Either (will capture the lowest common type)
static <RT> LazyEither.CompletableEither<RT,RT>	either() Create a reactive CompletableEither
Maybe<RT>	filter(java.util.function.Predicate<? super RT> test) Keep only elements for which the supplied predicates hold e.g.
default LazyEither<LT,RT>	filter(java.util.function.Predicate<? super RT> test, java.util.function.Function<? super RT,? extends LT> rightToLeft)
<RT1> LazyEither<LT,RT1>	flatMap(java.util.function.Function<? super RT,? extends Either<? extends LT,? extends RT1>> mapper)
<LT1> LazyEither<LT1,RT>	flatMapLeft(java.util.function.Function<? super LT,? extends Either<LT1,RT>> mapper) Perform a flatMap operation on the Left type
LazyEither<LT,RT>	flatMapLeftToRight(java.util.function.Function<? super LT,? extends Either<LT,RT>> fn) A flatMap operation that keeps the Left and Right types the same
<R> R	fold(java.util.function.Function<? super LT,? extends R> secondary, java.util.function.Function<? super RT,? extends R> primary) Visitor pattern for this Ior.
static <X,PT extends X,ST extends X,R> R	foldAny(LazyEither<ST,PT> either, java.util.function.Function<? super X,? extends R> fn)
default <R1,R> Either<LT,R>	forEach2(java.util.function.Function<? super RT,? extends Either<LT,R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends R> yieldingFunction)
default <T2,R1,R2,R> Either<LT,R>	forEach3(java.util.function.Function<? super RT,? extends Either<LT,R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends Either<LT,R2>> value2, Function3<? super RT,? super R1,? super R2,? extends R> yieldingFunction)
default <T2,R1,R2,R3,R> LazyEither<LT,R>	forEach4(java.util.function.Function<? super RT,? extends Either<LT,R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends Either<LT,R2>> value2, Function3<? super RT,? super R1,? super R2,? extends Either<LT,R3>> value3, Function4<? super RT,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
static <ST,PT> LazyEither<ST,PT>	fromEither(Either<ST,PT> xor)
static <T> LazyEither<java.lang.Throwable,T>	fromFuture(Future<T> future)
static <ST,T> LazyEither<ST,T>	fromIterable(java.lang.Iterable<T> iterable, T alt) Construct a Right Either from the supplied Iterable
static <LT,RT> LazyEither<LT,RT>	fromLazy(Eval<LazyEither<LT,RT>> lazy)
static <T> LazyEither<java.lang.Throwable,T>	fromPublisher(org.reactivestreams.Publisher<T> pub) Lazily construct a Right Either from the supplied publisher
Option<RT>	get()
Option<LT>	getLeft()
boolean	isLeft()
default boolean	isPresent()
boolean	isRight()
static <LT,RT> LazyEither<LT,RT>	later(java.util.function.Supplier<Either<LT,RT>> lazy)
default LazyEither<LazySeq<LT>,RT>	lazySeq()
static <ST,PT> LazyEither<ST,PT>	left(ST value) Create an instance of the left type.
static <LT,B,RT> LazyEither<LT,RT>	leftEval(Eval<LT> left)
ReactiveSeq<LT>	leftToStream()
<R> LazyEither<LT,R>	map(java.util.function.Function<? super RT,? extends R> fn) Transform this functor using the supplied transformation function
<R> LazyEither<R,RT>	mapLeft(java.util.function.Function<? super LT,? extends R> fn) Always transform the Left type of this Either if it is present using the provided transformation function
LazyEither<LT,RT>	mapLeftToRight(java.util.function.Function<? super LT,? extends RT> fn) If this Either contains the Left type, transform it's value so that it contains the Right type
static <ST,PT> LazyEither<ST,PT>	narrow(LazyEither<? extends ST,? extends PT> broad)
static <ST,T> LazyEither<ST,T>	narrowK(Higher<Higher<DataWitness.either,ST>,T> xor)
static <ST,T> LazyEither<ST,T>	narrowK2(Higher2<DataWitness.either,ST,T> xor)
default LazyEither<LT,Either<LT,RT>>	nest()
LazyEither<LT,RT>	peek(java.util.function.Consumer<? super RT> action) Peek at the current value of this Transformable, without transforming it
LazyEither<LT,RT>	peekLeft(java.util.function.Consumer<? super LT> action) Peek at the Left type value if present
static <ST,PT> LazyEither<ST,PT>	right(PT value) Create an instance of the right type.
static <LT,B,RT> LazyEither<LT,RT>	rightEval(Eval<RT> right)
static <L,T> LazyEither<L,ReactiveSeq<T>>	sequence(ReactiveSeq<? extends LazyEither<L,T>> stream)
static <LT1,PT> LazyEither<ReactiveSeq<LT1>,PT>	sequenceLeft(java.lang.Iterable<LazyEither<LT1,PT>> xors)
static <LT1,PT> LazyEither<LT1,ReactiveSeq<PT>>	sequenceRight(java.lang.Iterable<LazyEither<LT1,PT>> xors) Turn an IterableX of Eithers into a single Either with Lists of values.
LazyEither<RT,LT>	swap() Swap types so operations directly affect the current (pre-swap) Left type
static <L,T,R> LazyEither<L,R>	tailRec(T initial, java.util.function.Function<? super T,? extends LazyEither<L,? extends Either<T,R>>> fn)
default Either<LT,RT>	toEither()
default <ST2> Either<ST2,RT>	toEither(ST2 secondary) Convert to an Xor where the left value will be used if no right value is present
default Trampoline<LazyEither<LT,RT>>	toEitherTrampoline()
Ior<LT,RT>	toIor()
default Trampoline<Either<LT,RT>>	toTrampoline()
default Trampoline<RT>	toTrampoline(RT defaultValue)
default Trampoline<RT>	toTrampoline(java.util.function.Supplier<RT> defaultValue)
static <L,T,R> LazyEither<L,ReactiveSeq<R>>	traverse(java.util.function.Function<? super T,? extends R> fn, ReactiveSeq<LazyEither<L,T>> stream)
static <LT1,PT,R> LazyEither<ReactiveSeq<R>,PT>	traverseLeft(java.lang.Iterable<LazyEither<LT1,PT>> xors, java.util.function.Function<? super LT1,? extends R> fn)
static <LT1,PT,R> LazyEither<LT1,ReactiveSeq<R>>	traverseRight(java.lang.Iterable<LazyEither<LT1,PT>> xors, java.util.function.Function<? super PT,? extends R> fn) TraverseOps a Collection of Either producting an Either3 with a Seq, applying the transformation function to every element in the list
default <T> LazyEither<LT,T>	unit(T unit)
static <X,LT extends X,RT extends X> X	visitAny(java.util.function.Consumer<? super X> c, LazyEither<LT,RT> either)
static <X,PT extends X,ST extends X,R> R	visitAny(LazyEither<ST,PT> either, java.util.function.Function<? super X,? extends R> fn) Deprecated.
default <T2,R> LazyEither<LT,R>	zip(Either<LT,? extends T2> app, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)
default <T2,R> LazyEither<LT,R>	zip(Ior<LT,? extends T2> app, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)

Methods inherited from interface cyclops.control.Either

accumulateLeft, accumulateLeft, accumulateLeft, accumulateRight, accumulateRight, accumulateRight, applyAny, combineToVector, consumeAny, filterNot, foldAny, fromIterable, leftOrElse, nestedEval, notNull, ofType, recover, recover, recoverWith, sequence, sequenceLeft, sequenceRight, tailRec, traverse, visitAny, visitAny, widen

Methods inherited from interface com.oath.cyclops.types.foldable.To

to

Methods inherited from interface com.oath.cyclops.types.OrElseValue

orElseUse, orElseUse

Methods inherited from interface com.oath.cyclops.types.Value

asSupplier, collect, fold, forEach, generate, iterate, iterator, mkString, nonEmptyList, nonEmptyListGet, orElse, orElseGet, print, print, printErr, printOut, stream, subscribe, toLazyEither, toLeft, toMaybe, toOption, toOptional, toRight, toTry, toTry, toTry

Methods inherited from interface com.oath.cyclops.matching.SealedOr

fold

Methods inherited from interface java.lang.Iterable

spliterator

Methods inherited from interface com.oath.cyclops.hkt.Higher

applyHKT_, applyHKT, applyHKT

Methods inherited from interface com.oath.cyclops.hkt.Convert

convert

Method Detail

narrowK2

static <ST,T> LazyEither<ST,T> narrowK2(Higher2<DataWitness.either,ST,T> xor)

Specified by:

narrowK2 in interface Either<LT,RT>

narrowK

static <ST,T> LazyEither<ST,T> narrowK(Higher<Higher<DataWitness.either,ST>,T> xor)

Specified by:

narrowK in interface Either<LT,RT>

tailRec

static <L,T,R> LazyEither<L,R> tailRec(T initial,
                                       java.util.function.Function<? super T,? extends LazyEither<L,? extends Either<T,R>>> fn)

arity

default int arity()

Specified by:

arity in interface Either<LT,RT>

async

static <RT> LazyEither<java.lang.Throwable,RT> async(java.util.concurrent.Executor ex,
                                                     java.util.function.Supplier<RT> s)

either

static <RT> LazyEither.CompletableEither<RT,RT> either()

Create a reactive CompletableEither

  
      ___Example 1___

      CompletableEither<Integer,Integer> completable = Either.lazy();
            Either<Throwable,Integer> mapped = completable.map(i->i*2)
                                                          .flatMap(i->Eval.later(()->i+1));

            completable.complete(5);

            mapped.printOut();
            //11

            ___Example 2___

            CompletableEither<Integer,Integer> completable = Either.lazy();
            Either<Throwable,Integer> mapped = completable.map(i->i*2)
                                                          .flatMap(i->Eval.later(()->i+1));


            completable.complete(null);

            //Either:Left[NoSuchElementException]

            ___Example 3___

            CompletableEither<Integer,Integer> completable = Either.lazy();
            Either<Throwable,Integer> mapped = completable.map(i->i*2)
                                                          .flatMap(i->Eval.later(()->i+1));

            completable.complete(new IllegalStateException());

            //Either:Left[IllegalStateElementException]
     
 

Type Parameters:

RT -

Returns:

toEither

default Either<LT,RT> toEither()

fromEither

static <ST,PT> LazyEither<ST,PT> fromEither(Either<ST,PT> xor)

fromLazy

static <LT,RT> LazyEither<LT,RT> fromLazy(Eval<LazyEither<LT,RT>> lazy)

later

static <LT,RT> LazyEither<LT,RT> later(java.util.function.Supplier<Either<LT,RT>> lazy)

always

static <LT,RT> LazyEither<LT,RT> always(java.util.function.Supplier<Either<LT,RT>> lazy)

fromFuture

static <T> LazyEither<java.lang.Throwable,T> fromFuture(Future<T> future)

sequenceRight

static <LT1,PT> LazyEither<LT1,ReactiveSeq<PT>> sequenceRight(java.lang.Iterable<LazyEither<LT1,PT>> xors)

Turn an IterableX of Eithers into a single Either with Lists of values.

 

 Either<String,Integer> just  = Either.right(10);
       Either<String,Integer> none = Either.left("none");


 Either<Seq<String>,Seq<Integer>> xors =Either.sequence(Seq.of(just,none,Either.right(1)));
       //Eitehr.right(Seq.of(10,1)));

 

Parameters:

xors - Either to sequence

Returns:

Either Sequenced

sequenceLeft

static <LT1,PT> LazyEither<ReactiveSeq<LT1>,PT> sequenceLeft(java.lang.Iterable<LazyEither<LT1,PT>> xors)

sequence

static <L,T> LazyEither<L,ReactiveSeq<T>> sequence(ReactiveSeq<? extends LazyEither<L,T>> stream)

traverse

static <L,T,R> LazyEither<L,ReactiveSeq<R>> traverse(java.util.function.Function<? super T,? extends R> fn,
                                                     ReactiveSeq<LazyEither<L,T>> stream)

traverseRight

static <LT1,PT,R> LazyEither<LT1,ReactiveSeq<R>> traverseRight(java.lang.Iterable<LazyEither<LT1,PT>> xors,
                                                               java.util.function.Function<? super PT,? extends R> fn)

TraverseOps a Collection of Either producting an Either3 with a Seq, applying the transformation function to every element in the list

Parameters:

xors - Eithers to sequence and transform

fn - Transformation function

Returns:

An Either with a transformed list

traverseLeft

static <LT1,PT,R> LazyEither<ReactiveSeq<R>,PT> traverseLeft(java.lang.Iterable<LazyEither<LT1,PT>> xors,
                                                             java.util.function.Function<? super LT1,? extends R> fn)

accumulate

static <LT1,RT> LazyEither<LT1,RT> accumulate(Monoid<RT> reducer,
                                              java.lang.Iterable<LazyEither<LT1,RT>> xors)

Accumulate the results only from those Either3 which have a Right type present, using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) com.oath.cyclops.Monoids .

 
 Either3<String,String,Integer> just  = Either3.right(10);
       Either3<String,String,Integer> none = Either3.left("none");

  Either3<Seq<String>,Seq<String>,Integer> xors = Either3.accumulateRight(Monoids.intSum,Seq.of(just,none,Either3.right(1)));
        //Either3.right(11);

 
 

Parameters:

xors - Collection of Eithers to accumulate right values

reducer - Reducer to accumulate results

Returns:

Either populated with the accumulate right operation

rightEval

static <LT,B,RT> LazyEither<LT,RT> rightEval(Eval<RT> right)

leftEval

static <LT,B,RT> LazyEither<LT,RT> leftEval(Eval<LT> left)

consumeAny

static <X,LT extends X,M extends X,RT extends X> java.util.function.Consumer<java.util.function.Consumer<? super X>> consumeAny(LazyEither<LT,RT> either)

Static method useful as a method reference for fluent consumption of any value type stored in this Either (will capture the lowest common type)

 

   myEither.to(Either::consumeAny)
                 .accept(System.out::println);
 
 

Parameters:

either - Either to consume value for

Returns:

Consumer we can applyHKT to consume value

applyAny

static <X,LT extends X,M extends X,RT extends X,R> java.util.function.Function<java.util.function.Function<? super X,R>,R> applyAny(LazyEither<LT,RT> either)

visitAny

@Deprecated
static <X,PT extends X,ST extends X,R> R visitAny(LazyEither<ST,PT> either,
                                                              java.util.function.Function<? super X,? extends R> fn)

Deprecated.

foldAny

static <X,PT extends X,ST extends X,R> R foldAny(LazyEither<ST,PT> either,
                                                 java.util.function.Function<? super X,? extends R> fn)

visitAny

static <X,LT extends X,RT extends X> X visitAny(java.util.function.Consumer<? super X> c,
                                                LazyEither<LT,RT> either)

toTrampoline

default Trampoline<RT> toTrampoline(java.util.function.Supplier<RT> defaultValue)

toTrampoline

default Trampoline<RT> toTrampoline(RT defaultValue)

forEach4

default <T2,R1,R2,R3,R> LazyEither<LT,R> forEach4(java.util.function.Function<? super RT,? extends Either<LT,R1>> value1,
                                                  java.util.function.BiFunction<? super RT,? super R1,? extends Either<LT,R2>> value2,
                                                  Function3<? super RT,? super R1,? super R2,? extends Either<LT,R3>> value3,
                                                  Function4<? super RT,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Specified by:

forEach4 in interface Either<LT,RT>

forEach3

default <T2,R1,R2,R> Either<LT,R> forEach3(java.util.function.Function<? super RT,? extends Either<LT,R1>> value1,
                                           java.util.function.BiFunction<? super RT,? super R1,? extends Either<LT,R2>> value2,
                                           Function3<? super RT,? super R1,? super R2,? extends R> yieldingFunction)

Specified by:

forEach3 in interface Either<LT,RT>

forEach2

default <R1,R> Either<LT,R> forEach2(java.util.function.Function<? super RT,? extends Either<LT,R1>> value1,
                                     java.util.function.BiFunction<? super RT,? super R1,? extends R> yieldingFunction)

Specified by:

forEach2 in interface Either<LT,RT>

combineToLazySeq

default <T2,R> LazyEither<LazySeq<LT>,R> combineToLazySeq(Either<LT,? extends T2> app,
                                                          java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)

Description copied from interface: Either

Accumulate lefts into a LazySeq (extended Persistent List) and Right with the supplied combiner function Right accumulation only occurs if all phases are right

Specified by:

combineToLazySeq in interface Either<LT,RT>

Parameters:

app - Value to combine with

fn - Combiner function for right values

Returns:

Combined Either

combine

default <T2,R> LazyEither<LT,R> combine(Either<? extends LT,? extends T2> app,
                                        java.util.function.BinaryOperator<LT> semigroup,
                                        java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)

Description copied from interface: Either

Accumulate left values with the provided BinaryOperator / Semigroup Semigroups Right accumulation only occurs if all phases are right

 
  Either<String,String> fail1 =  Either.left("failed1");
        Either<LazySeq<String>,String> result = fail1.list().combine(Either.left("failed2").list(), SemigroupK.collectionConcat(),(a,b)->a+b);

        //Left of [LazySeq.of("failed1","failed2")))]
 
 

Specified by:

combine in interface Either<LT,RT>

Parameters:

app - Value to combine with

semigroup - to combine left types

fn - To combine right types

Returns:

Combined Either

fromPublisher

static <T> LazyEither<java.lang.Throwable,T> fromPublisher(org.reactivestreams.Publisher<T> pub)

Lazily construct a Right Either from the supplied publisher

 
   ReactiveSeq<Integer> stream =  ReactiveSeq.of(1,2,3);

         Either<Throwable,Integer> future = Either.fromPublisher(stream);

         //Either[1]

 
 

Specified by:

fromPublisher in interface Either<LT,RT>

Parameters:

pub - Publisher to construct an Either from

Returns:

Either constructed from the supplied Publisher

fromIterable

static <ST,T> LazyEither<ST,T> fromIterable(java.lang.Iterable<T> iterable,
                                            T alt)

Construct a Right Either from the supplied Iterable

 
   List<Integer> list =  Arrays.asList(1,2,3);

         Either<Throwable,Integer> future = Either.fromIterable(list);

         //Either[1]

 
 

Parameters:

iterable - Iterable to construct an Either from

Returns:

Either constructed from the supplied Iterable

left

static <ST,PT> LazyEither<ST,PT> left(ST value)

Create an instance of the left type. Most methods are biased to the right type, so you will need to use swap() or secondaryXXXX to manipulate the wrapped value

 
   Either.<Integer,Integer>left(10).map(i->i+1);
   //Either.left[10]

    Either.<Integer,Integer>left(10).swap().map(i->i+1);
    //Either.right[11]
 
 

Specified by:

left in interface Either<LT,RT>

Parameters:

value - to wrap

Returns:

Left instance of Either

right

static <ST,PT> LazyEither<ST,PT> right(PT value)

Create an instance of the right type. Most methods are biased to the right type, which means, for example, that the transform method operates on the right type but does nothing on left Eithers

 
   Either.<Integer,Integer>right(10).map(i->i+1);
   //Either.right[11]


 
 

Specified by:

right in interface Either<LT,RT>

Parameters:

value - To construct an Either from

Returns:

Right type instanceof Either

toTrampoline

default Trampoline<Either<LT,RT>> toTrampoline()

Specified by:

toTrampoline in interface Either<LT,RT>

toEitherTrampoline

default Trampoline<LazyEither<LT,RT>> toEitherTrampoline()

nest

default LazyEither<LT,Either<LT,RT>> nest()

Specified by:

nest in interface Either<LT,RT>

zip

default <T2,R> LazyEither<LT,R> zip(Ior<LT,? extends T2> app,
                                    java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)

Specified by:

zip in interface Either<LT,RT>

zip

default <T2,R> LazyEither<LT,R> zip(Either<LT,? extends T2> app,
                                    java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)

Specified by:

zip in interface Either<LT,RT>

unit

default <T> LazyEither<LT,T> unit(T unit)

Specified by:

unit in interface Either<LT,RT>

Specified by:

unit in interface Unit<RT>

filter

Maybe<RT> filter(java.util.function.Predicate<? super RT> test)

Description copied from interface: Filters

Keep only elements for which the supplied predicates hold e.g.

 

     of(1,2,3).filter(i->i>2);

     //[3]

 
 

Specified by:

filter in interface Either<LT,RT>

Specified by:

filter in interface Filters<RT>

Parameters:

test - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

filter

default LazyEither<LT,RT> filter(java.util.function.Predicate<? super RT> test,
                                 java.util.function.Function<? super RT,? extends LT> rightToLeft)

Specified by:

filter in interface Either<LT,RT>

mapLeftToRight

LazyEither<LT,RT> mapLeftToRight(java.util.function.Function<? super LT,? extends RT> fn)

If this Either contains the Left type, transform it's value so that it contains the Right type

Specified by:

mapLeftToRight in interface Either<LT,RT>

Parameters:

fn - Function to transform left type to right

Returns:

Either with left type mapped to right

mapLeft

<R> LazyEither<R,RT> mapLeft(java.util.function.Function<? super LT,? extends R> fn)

Always transform the Left type of this Either if it is present using the provided transformation function

Specified by:

mapLeft in interface Either<LT,RT>

Parameters:

fn - Transformation function for Left types

Returns:

Either with Left type transformed

map

<R> LazyEither<LT,R> map(java.util.function.Function<? super RT,? extends R> fn)

Description copied from interface: Transformable

Transform this functor using the supplied transformation function

 


    of(1,2,3).map(i->i*2)

    //[2,4,6]

 
 

Specified by:

map in interface Either<LT,RT>

Specified by:

map in interface Transformable<RT>

Parameters:

fn - Transformation function

Returns:

Transformed Transformable

peekLeft

LazyEither<LT,RT> peekLeft(java.util.function.Consumer<? super LT> action)

Peek at the Left type value if present

Specified by:

peekLeft in interface Either<LT,RT>

Parameters:

action - Consumer to peek at the Left type value

Returns:

Either with the same values as before

peek

LazyEither<LT,RT> peek(java.util.function.Consumer<? super RT> action)

Description copied from interface: Transformable

Peek at the current value of this Transformable, without transforming it

 


    of(1,2,3).map(System.out::println)

    1
    2
    3

 
 

Specified by:

peek in interface Either<LT,RT>

Specified by:

peek in interface Transformable<RT>

Parameters:

action - Consumer that recieves each element from this Transformable

Returns:

Transformable that will peek at each value

swap

LazyEither<RT,LT> swap()

Swap types so operations directly affect the current (pre-swap) Left type

  

    Either.left("hello")
       .map(v->v+" world")
    //Either.seconary["hello"]

    Either.left("hello")
       .swap()
       .map(v->v+" world")
       .swap()
    //Either.seconary["hello world"]
  
  

Specified by:

swap in interface Either<LT,RT>

Returns:

Swap the right and left types, allowing operations directly on what was the Left type

toIor

Ior<LT,RT> toIor()

Specified by:

toIor in interface Either<LT,RT>

isPresent

default boolean isPresent()

Specified by:

isPresent in interface Either<LT,RT>

Specified by:

isPresent in interface Value<RT>

toEither

default <ST2> Either<ST2,RT> toEither(ST2 secondary)

Description copied from interface: Value

Convert to an Xor where the left value will be used if no right value is present

Specified by:

toEither in interface Either<LT,RT>

Specified by:

toEither in interface Value<RT>

Parameters:

secondary - Value to use in case no right value is present

Returns:

Right Either with same value as this Value, or a Left Either with the provided Value if this Value is zero

fold

<R> R fold(java.util.function.Function<? super LT,? extends R> secondary,
           java.util.function.Function<? super RT,? extends R> primary)

Visitor pattern for this Ior. Execute the left function if this Either contains an element of the left type Execute the right function if this Either contains an element of the right type

 
  Either.right(10)
     .visit(left->"no", right->"yes")
  //Either["yes"]

        Either.left(90)
           .visit(left->"no", right->"yes")
        //Either["no"]



 
 

Specified by:

fold in interface Either<LT,RT>

Specified by:

fold in interface Sealed2<LT,RT>

Parameters:

secondary - Function to execute if this is a Left Either

primary - Function to execute if this is a Right Ior

Returns:

Result of executing the appropriate function

bimap

default <R1,R2> LazyEither<R1,R2> bimap(java.util.function.Function<? super LT,? extends R1> secondary,
                                        java.util.function.Function<? super RT,? extends R2> primary)

Description copied from interface: BiTransformable

Transform this BiTransformable, changing two value types at once.

 
     MapX<String,Integer> map = MapXs.of("hello",2);
     MapX<String,Integer> transformedMap = map.bimap(s->s+" world",i->i*4);
     //["hello world",8]
 
 

Specified by:

bimap in interface BiTransformable<LT,RT>

Specified by:

bimap in interface Either<LT,RT>

Parameters:

secondary - transformation function for the first type

primary - transformation function for the second type

Returns:

New BiTransformable containing transformed data

bipeek

default LazyEither<LT,RT> bipeek(java.util.function.Consumer<? super LT> c1,
                                 java.util.function.Consumer<? super RT> c2)

Description copied from interface: BiTransformable

Peek at two data types simulatanously (typically to perform a side-effect with each data point)

 
     MapX<String,Integer> map = MapXs.of("hello",2);
     map.bipeek(s->System.out.pritnln("key = " + s),System.out::println);
 
 

Specified by:

bipeek in interface BiTransformable<LT,RT>

Specified by:

bipeek in interface Either<LT,RT>

Parameters:

c1 - consumer for the first type

c2 - consumer for the second type

Returns:

New BiTransformable with the same data

get

Option<RT> get()

Specified by:

get in interface Either<LT,RT>

getLeft

Option<LT> getLeft()

Specified by:

getLeft in interface Either<LT,RT>

Returns:

The Left Value if present, otherwise null

leftToStream

ReactiveSeq<LT> leftToStream()

Specified by:

leftToStream in interface Either<LT,RT>

Returns:

A Stream containing the left value if present, otherwise an zero Stream

flatMap

<RT1> LazyEither<LT,RT1> flatMap(java.util.function.Function<? super RT,? extends Either<? extends LT,? extends RT1>> mapper)

Specified by:

flatMap in interface Either<LT,RT>

flatMapLeft

<LT1> LazyEither<LT1,RT> flatMapLeft(java.util.function.Function<? super LT,? extends Either<LT1,RT>> mapper)

Perform a flatMap operation on the Left type

Specified by:

flatMapLeft in interface Either<LT,RT>

Parameters:

mapper - Flattening transformation function

Returns:

Either containing the value inside the result of the transformation function as the Left value, if the Left type was present

flatMapLeftToRight

LazyEither<LT,RT> flatMapLeftToRight(java.util.function.Function<? super LT,? extends Either<LT,RT>> fn)

A flatMap operation that keeps the Left and Right types the same

Specified by:

flatMapLeftToRight in interface Either<LT,RT>

Parameters:

fn - Transformation function

Returns:

Either

isRight

boolean isRight()

Specified by:

isRight in interface Either<LT,RT>

Returns:

True if this is a right Either

isLeft

boolean isLeft()

Specified by:

isLeft in interface Either<LT,RT>

Returns:

True if this is a left Either

lazySeq

default LazyEither<LazySeq<LT>,RT> lazySeq()

Specified by:

lazySeq in interface Either<LT,RT>

Returns:

An Either with the left type converted to a persistent list, for use with accumulating app function

combineToList

default <T2,R> LazyEither<LazySeq<LT>,R> combineToList(LazyEither<LT,? extends T2> app,
                                                       java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)

Accumulate secondarys into a LazySeq (extended Persistent List) and Right with the supplied combiner function Right accumulation only occurs if all phases are right

Parameters:

app - Value to combine with

fn - Combiner function for right values

Returns:

Combined Either

combine

default <T2,R> LazyEither<LT,R> combine(LazyEither<? extends LT,? extends T2> app,
                                        java.util.function.BinaryOperator<LT> semigroup,
                                        java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)

Accumulate left values with the provided BinaryOperator / Semigroup Semigroups Right accumulation only occurs if all phases are right

 
  Either<String,String> fail1 =  Either.left("failed1");
        Either<LazySeq<String>,String> result = fail1.list().combine(Either.left("failed2").list(), SemigroupK.collectionConcat(),(a,b)->a+b);

        //Left of [LazySeq.of("failed1","failed2")))]
 
 

Parameters:

app - Value to combine with

semigroup - to combine left types

fn - To combine right types

Returns:

Combined Either

narrow

static <ST,PT> LazyEither<ST,PT> narrow(LazyEither<? extends ST,? extends PT> broad)