cyclops.control.lazy

Interface Either<LT,RT>

Type Parameters:

LT - Left type

RT - Right type

All Superinterfaces:

BiTransformable<LT,RT>, Convert<Higher<Higher<Witness.xor,LT>,RT>>, Convertable<RT>, Filters<RT>, Fn0<RT>, Folds<RT>, Higher<Higher<Witness.xor,LT>,RT>, Higher2<Witness.xor,LT,RT>, java.lang.Iterable<RT>, MonadicValue<RT>, java.util.function.Predicate<RT>, org.reactivestreams.Publisher<RT>, java.util.function.Supplier<RT>, To<Xor<LT,RT>>, Transformable<RT>, Unit<RT>, Value<RT>, Visitable<RT>, Xor<LT,RT>, Zippable<RT>

All Known Implementing Classes:

Either.CompletableEither, Either.Lazy, Either.Left, Either.Right

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

A totally Lazy Either implementation with tail call optimization for map and flatMap operators. Either can operate reactively (i.e. suppports data arriving asynchronsouly the monadic chain of computations will only be executed once data arrives). 'Right' (or primary 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{
           Either team;
     }

     Rather than

     public class Member{

Nested Class Summary

Nested Classes

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

Nested classes/interfaces inherited from interface cyclops.control.Xor

Xor.Instances, Xor.Primary<ST,PT>, Xor.Secondary<ST,PT>

Nested classes/interfaces inherited from interface com.aol.cyclops2.types.Value

Value.ValueImpl<T>

Nested classes/interfaces inherited from interface com.aol.cyclops2.types.foldable.Convertable

Convertable.SupplierToConvertable<T>

Nested classes/interfaces inherited from interface cyclops.function.Fn0

Fn0.FunctionalOperations<R>, Fn0.SupplierKind<R>

Method Summary

Modifier and Type	Method and Description
static <LT1,RT> Either<ListX<LT1>,RT>	accumulate(Monoid<RT> reducer, CollectionX<Either<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.aol.cyclops2.Monoids .
default AnyM<Witness.either,RT>	anyMEither()
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(Either<LT,RT> either)
static <RT> Either<java.lang.Throwable,RT>	async(java.util.concurrent.Executor ex, java.util.function.Supplier<RT> s)
default <U1,U2> Either<U1,U2>	bicast(java.lang.Class<U1> type1, java.lang.Class<U2> type2) Cast two data types simulatanously.
default <R1,R2> Either<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 Either<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 <R1,R2> Either<R1,R2>	bitrampoline(java.util.function.Function<? super LT,? extends Trampoline<? extends R1>> mapper1, java.util.function.Function<? super RT,? extends Trampoline<? extends R2>> mapper2) Perform a tail-call optimized recursive transformation operation across two data points simultaneously
default <U> Either<LT,U>	cast(java.lang.Class<? extends U> type) Cast all elements in a reactiveStream to a given type, possibly throwing a ClassCastException.
default <R> Either<LT,R>	coflatMap(java.util.function.Function<? super MonadicValue<RT>,R> mapper) Perform a coflatMap operation.
default <T2,R> Either<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 secondary values with the provided BinaryOperator / Semigroup Semigroups Right accumulation only occurs if all phases are primary
<T2,R> Either<LT,R>	combine(Value<? extends T2> app, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn) Lazily combine this ApplicativeFunctor with the supplied value via the supplied BiFunction Example
default <T2,R> Either<LT,R>	combine(Xor<? extends LT,? extends T2> app, java.util.function.BinaryOperator<LT> semigroup, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn) Accumulate secondary values with the provided BinaryOperator / Semigroup Semigroups Primary accumulation only occurs if all phases are primary
default Either<LT,RT>	combineEager(Monoid<RT> monoid, MonadicValue<? extends RT> v2) Eagerly combine two MonadicValues using the supplied monoid (@see ApplicativeFunctor for type appropraite i.e.
default <T2,R> Either<LinkedListX<LT>,R>	combineToList(Either<LT,? extends T2> app, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn) Accumulate secondarys into a LinkedListX (extended Persistent List) and Right with the supplied combiner function Right accumulation only occurs if all phases are primary
default <T2,R> Either<LinkedListX<LT>,R>	combineToList(Xor<LT,? extends T2> app, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn) Accumulate secondarys into a LinkedListX (extended Persistent List) and Primary with the supplied combiner function Primary accumulation only occurs if all phases are primary
static <X,LT extends X,M extends X,RT extends X> java.util.function.Consumer<java.util.function.Consumer<? super X>>	consumeAny(Either<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> Either.CompletableEither<RT,RT>	either() Create a reactiveBuffer CompletableEither
Either<LT,RT>	filter(java.util.function.Predicate<? super RT> test) Keep only elements for which the supplied predicates hold e.g.
default Either<LT,RT>	filterNot(java.util.function.Predicate<? super RT> fn) Remove any elements for which the predicate holds (inverse operation to filter) e.g.
<RT1> Either<LT,RT1>	flatMap(java.util.function.Function<? super RT,? extends MonadicValue<? extends RT1>> mapper) A flattening transformation operation (@see Optional.flatMap(Function)
default <R> Either<LT,R>	flatMapI(java.util.function.Function<? super RT,? extends java.lang.Iterable<? extends R>> mapper) A flattening transformation operation that takes the first value from the returned Iterable.
default <R> Either<LT,R>	flatMapP(java.util.function.Function<? super RT,? extends org.reactivestreams.Publisher<? extends R>> mapper) A flattening transformation operation that takes the first value from the returned Publisher.
default <R> Either<LT,R>	flatMapS(java.util.function.Function<? super RT,? extends java.util.stream.Stream<? extends R>> mapper)
default <R1,R> Either<LT,R>	forEach2(java.util.function.Function<? super RT,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends R> yieldingFunction) Perform a two level nested internal iteration over this MonadicValue and the supplied MonadicValue
default <R1,R> Either<LT,R>	forEach2(java.util.function.Function<? super RT,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super RT,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super RT,? super R1,? extends R> yieldingFunction) Perform a two level nested internal iteration over this MonadicValue and the supplied reactiveStream
default <T2,R1,R2,R> Either<LT,R>	forEach3(java.util.function.Function<? super RT,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends MonadicValue<R2>> value2, Fn3<? super RT,? super R1,? super R2,? extends R> yieldingFunction) Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues
default <T2,R1,R2,R> Either<LT,R>	forEach3(java.util.function.Function<? super RT,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends MonadicValue<R2>> value2, Fn3<? super RT,? super R1,? super R2,java.lang.Boolean> filterFunction, Fn3<? super RT,? super R1,? super R2,? extends R> yieldingFunction) Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues
default <T2,R1,R2,R3,R> Either<LT,R>	forEach4(java.util.function.Function<? super RT,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends MonadicValue<R2>> value2, Fn3<? super RT,? super R1,? super R2,? extends MonadicValue<R3>> value3, Fn4<? super RT,? super R1,? super R2,? super R3,? extends R> yieldingFunction) Perform a four level nested internal iteration over this MonadicValue and the supplied MonadicValues
default <T2,R1,R2,R3,R> Either<LT,R>	forEach4(java.util.function.Function<? super RT,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends MonadicValue<R2>> value2, Fn3<? super RT,? super R1,? super R2,? extends MonadicValue<R3>> value3, Fn4<? super RT,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, Fn4<? super RT,? super R1,? super R2,? super R3,? extends R> yieldingFunction) Perform a four level nested internal iteration over this MonadicValue and the supplied MonadicValues Maybe.of(3) .forEach4(a->Maybe.just(a+10), (a,b)->Maybe.just(a+b), (a,b,c)->Maybe.none(), (a,b,c,d)->a+b+c<100, (a,b,c,d)->a+b+c+d); //Maybe.none
static <T> Either<java.lang.Throwable,T>	fromFuture(Future<T> future)
static <ST,T> Either<ST,T>	fromIterable(java.lang.Iterable<T> iterable) Construct a Right Either from the supplied Iterable
static <LT,RT> Either<LT,RT>	fromLazy(Eval<Either<LT,RT>> lazy)
static <LT1,RT> Either<LT1,RT>	fromMonadicValue(MonadicValue<RT> mv2)
static <T> Either<java.lang.Throwable,T>	fromPublisher(org.reactivestreams.Publisher<T> pub) Lazily construct a Right Either from the supplied publisher
static <ST,PT> Either<ST,PT>	fromXor(Xor<ST,PT> xor)
RT	get()
boolean	isLeft()
default boolean	isPresent()
default boolean	isPrimary()
boolean	isRight()
default boolean	isSecondary()
static <ST,PT> Either<ST,PT>	left(ST value) Create an instance of the secondary type.
static <LT,B,RT> Either<LT,RT>	leftEval(Eval<LT> left)
default Either<LinkedListX<LT>,RT>	list()
<R> Either<LT,R>	map(java.util.function.Function<? super RT,? extends R> fn) Transform this functor using the supplied transformation function
default <R1,R2> Either<R1,R2>	mapBoth(java.util.function.Function<? super LT,? extends R1> secondary, java.util.function.Function<? super RT,? extends R2> primary) Deprecated.
static <ST,PT> Either<ST,PT>	narrow(Either<? extends ST,? extends PT> broad)
default Either<LT,MonadicValue<RT>>	nest() cojoin pattern.
default Either<LT,RT>	notNull() Filter elements retaining only values which are not null
default <U> Either<LT,U>	ofType(java.lang.Class<? extends U> type) Keep only those elements in a reactiveStream that are of a given type.
void	peek(java.util.function.Consumer<? super LT> stAction, java.util.function.Consumer<? super RT> ptAction) Deprecated.
Either<LT,RT>	peek(java.util.function.Consumer<? super RT> action) Peek at the current value of this Transformable, without transforming it
default <R> Either<LT,R>	retry(java.util.function.Function<? super RT,? extends R> fn) Retry a transformation if it fails.
default <R> Either<LT,R>	retry(java.util.function.Function<? super RT,? extends R> fn, int retries, long delay, java.util.concurrent.TimeUnit timeUnit) Retry a transformation if it fails.
static <ST,PT> Either<ST,PT>	right(PT value) Create an instance of the primary type.
static <LT,B,RT> Either<LT,RT>	rightEval(Eval<RT> right)
<LT1> Either<LT1,RT>	secondaryFlatMap(java.util.function.Function<? super LT,? extends Xor<LT1,RT>> mapper) Perform a flatMap operation on the Left type
LT	secondaryGet()
<R> Either<R,RT>	secondaryMap(java.util.function.Function<? super LT,? extends R> fn) Always map the Left type of this Either if it is present using the provided transformation function
Either<LT,RT>	secondaryPeek(java.util.function.Consumer<? super LT> action) Peek at the Left type value if present
java.util.Optional<LT>	secondaryToOptional()
Either<LT,RT>	secondaryToPrimayFlatMap(java.util.function.Function<? super LT,? extends Xor<LT,RT>> fn) A flatMap operation that keeps the Left and Right types the same
Either<LT,RT>	secondaryToPrimayMap(java.util.function.Function<? super LT,? extends RT> fn) If this Either contains the Left type, map it's value so that it contains the Right type
ReactiveSeq<LT>	secondaryToStream()
Value<LT>	secondaryValue()
static <LT1,PT> Either<ListX<LT1>,ListX<PT>>	sequenceLeft(CollectionX<Either<LT1,PT>> xors)
static <LT1,PT> Either<ListX<LT1>,ListX<PT>>	sequenceRight(CollectionX<Either<LT1,PT>> xors) Turn a toX of Eithers into a singleUnsafe Either with Lists of values.
Either<RT,LT>	swap() Swap types so operations directly affect the current (pre-swap) Left type
default Trampoline<Either<LT,RT>>	toEitherTrampoline()
Ior<LT,RT>	toIor() Return an Ior that can be this object or a Ior.primary or Ior.secondary
default java.util.Optional<RT>	toOptional()
default Trampoline<Xor<LT,RT>>	toTrampoline()
default Trampoline<RT>	toTrampoline(RT defaultValue)
default Trampoline<RT>	toTrampoline(java.util.function.Supplier<RT> defaultValue)
default Xor<LT,RT>	toXor()
default <ST2> Xor<ST2,RT>	toXor(ST2 secondary) Convert to an Xor where the secondary value will be used if no primary value is present
default <R> Either<LT,R>	trampoline(java.util.function.Function<? super RT,? extends Trampoline<? extends R>> mapper) Performs a map operation that can call a recursive method without running out of stack space
static <LT1,PT,R> Either<ListX<R>,ListX<PT>>	traverseLeft(CollectionX<Either<LT1,PT>> xors, java.util.function.Function<? super LT1,? extends R> fn)
static <LT1,PT,R> Either<ListX<LT1>,ListX<R>>	traverseRight(CollectionX<Either<LT1,PT>> xors, java.util.function.Function<? super PT,? extends R> fn) TraverseOps a Collection of Either producting an Either3 with a ListX, applying the transformation function to every element in the list
default <T> Either<LT,T>	unit(T unit)
<R> R	visit(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,LT extends X,RT extends X> X	visitAny(java.util.function.Consumer<? super X> c, Either<LT,RT> either)
static <X,PT extends X,ST extends X,R> R	visitAny(Either<ST,PT> either, java.util.function.Function<? super X,? extends R> fn)
default Either<LT,RT>	zip(java.util.function.BinaryOperator<Zippable<RT>> combiner, Zippable<RT> app) Combine two applicatives together using the provided BinaryOperator (Semigroup, Monoid and Reducer all extend BinaryOperator - checkout SemigroupK and Monoids for a large number of canned combinations).
default <T2,R> Either<LT,R>	zip(java.lang.Iterable<? extends T2> app, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn) Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
default <U> Either<LT,org.jooq.lambda.tuple.Tuple2<RT,U>>	zip(java.lang.Iterable<? extends U> other) Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2
default <S,U> Either<LT,org.jooq.lambda.tuple.Tuple3<RT,S,U>>	zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third) zip 3 Streams into one
default <S,U,R> Either<LT,R>	zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third, Fn3<? super RT,? super S,? super U,? extends R> fn3)
default <T2,T3,T4> Either<LT,org.jooq.lambda.tuple.Tuple4<RT,T2,T3,T4>>	zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth) zip 4 Streams into 1
default <T2,T3,T4,R> Either<LT,R>	zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth, Fn4<? super RT,? super T2,? super T3,? super T4,? extends R> fn)
default <T2,R> Either<LT,R>	zipP(org.reactivestreams.Publisher<? extends T2> app, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn) Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
default <U> Either<LT,org.jooq.lambda.tuple.Tuple2<RT,U>>	zipP(org.reactivestreams.Publisher<? extends U> other)
default <U> Either<LT,org.jooq.lambda.tuple.Tuple2<RT,U>>	zipS(java.util.stream.Stream<? extends U> other) Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2
default <U,R> Either<LT,R>	zipS(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super RT,? super U,? extends R> zipper) Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
default <R> Either<LT,R>	zipWith(java.lang.Iterable<java.util.function.Function<? super RT,? extends R>> fn)
default <R> Either<LT,R>	zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super RT,? extends R>> fn)
default <R> Either<LT,R>	zipWithS(java.util.stream.Stream<java.util.function.Function<? super RT,? extends R>> fn)

Methods inherited from interface cyclops.control.Xor

accumulatePrimary, accumulatePrimary, accumulatePrimary, accumulateSecondary, accumulateSecondary, accumulateSecondary, allTypeclasses, anyM, applyAny, arity, consumeAny, coproduct, kindCokleisli, kindKleisli, liftM, mapM, narrowK, narrowK2, nested, nestedEval, primary, product, secondary, sequencePrimary, sequenceSecondary, visitAny, visitAny, widen

Methods inherited from interface com.aol.cyclops2.types.foldable.To

to

Methods inherited from interface com.aol.cyclops2.types.Value

apply, generate, iterate, iterator, mkString, newSubscriber, of, stream, subscribe, test, toEither, toEval, toEvalAlways, toEvalLater, toEvalNow, toLeft, toMaybe, toMaybeEager, toRight, toTry, toTry, toTry

Methods inherited from interface com.aol.cyclops2.types.foldable.Folds

endsWith, endsWithIterable, findAny, findFirst, firstValue, foldLeft, foldLeft, foldLeft, foldLeft, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, join, join, join, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleUnsafe, startsWith, startsWithIterable, takeOne, xMatch

Methods inherited from interface com.aol.cyclops2.types.foldable.Convertable

collect, fromSupplier, orElse, orElseGet, orElseThrow, toCompletableFuture, toCompletableFutureAsync, toFuture, toFutureAsync, toStream, visit

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Methods inherited from interface cyclops.function.Fn0

andThen, fnTo, functionOps, future, lift, lift, liftF, liftOpt, liftTry, memoize, memoize, memoizeAsync, memoizeAsync, run, suspend, λ, λv

Methods inherited from interface java.util.function.Predicate

and, isEqual, negate, or

Methods inherited from interface com.aol.cyclops2.hkt.Higher

applyHKT_, applyHKT, applyHKT

Methods inherited from interface com.aol.cyclops2.hkt.Convert

convert

Method Detail

fromMonadicValue

static <LT1,RT> Either<LT1,RT> fromMonadicValue(MonadicValue<RT> mv2)

async

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

either

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

Create a reactiveBuffer 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:

fromXor

static <ST,PT> Either<ST,PT> fromXor(Xor<ST,PT> xor)

fromLazy

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

fromFuture

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

sequenceRight

static <LT1,PT> Either<ListX<LT1>,ListX<PT>> sequenceRight(CollectionX<Either<LT1,PT>> xors)

Turn a toX of Eithers into a singleUnsafe Either with Lists of values.

 

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


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

 

Parameters:

Either - Either to sequence

Returns:

Either Sequenced

sequenceLeft

static <LT1,PT> Either<ListX<LT1>,ListX<PT>> sequenceLeft(CollectionX<Either<LT1,PT>> xors)

traverseRight

static <LT1,PT,R> Either<ListX<LT1>,ListX<R>> traverseRight(CollectionX<Either<LT1,PT>> xors,
                                                            java.util.function.Function<? super PT,? extends R> fn)

TraverseOps a Collection of Either producting an Either3 with a ListX, 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> Either<ListX<R>,ListX<PT>> traverseLeft(CollectionX<Either<LT1,PT>> xors,
                                                          java.util.function.Function<? super LT1,? extends R> fn)

accumulate

static <LT1,RT> Either<ListX<LT1>,RT> accumulate(Monoid<RT> reducer,
                                                 CollectionX<Either<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.aol.cyclops2.Monoids .

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

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

 
 

Parameters:

xors - Collection of Eithers to accumulate primary values

reducer - Reducer to accumulate results

Returns:

Either populated with the accumulate primary operation

rightEval

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

leftEval

static <LT,B,RT> Either<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(Either<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(Either<LT,RT> either)

visitAny

static <X,PT extends X,ST extends X,R> R visitAny(Either<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,
                                                Either<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> Either<LT,R> forEach4(java.util.function.Function<? super RT,? extends MonadicValue<R1>> value1,
                                              java.util.function.BiFunction<? super RT,? super R1,? extends MonadicValue<R2>> value2,
                                              Fn3<? super RT,? super R1,? super R2,? extends MonadicValue<R3>> value3,
                                              Fn4<? super RT,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Description copied from interface: MonadicValue

Perform a four level nested internal iteration over this MonadicValue and the supplied MonadicValues

  
  Maybe.of(3)
       .forEach4(a->Maybe.just(a+10),
                 (a,b)->Maybe.just(a+b),
                 (a,b,c)->Maybe.none(),
                 (a,b,c,d)->a+b+c+d);
                                  
  
  //Maybe.none
 
 

Specified by:

forEach4 in interface MonadicValue<RT>

Specified by:

forEach4 in interface Xor<LT,RT>

Parameters:

value1 - Nested MonadicValue to iterate over

value2 - Nested MonadicValue to iterate over

value3 - Nested MonadicValue to iterate over

yieldingFunction - Function with pointers to the current element from both MonadicValue that generates the new elements

Returns:

MonadicValue with elements generated via nested iteration

forEach4

default <T2,R1,R2,R3,R> Either<LT,R> forEach4(java.util.function.Function<? super RT,? extends MonadicValue<R1>> value1,
                                              java.util.function.BiFunction<? super RT,? super R1,? extends MonadicValue<R2>> value2,
                                              Fn3<? super RT,? super R1,? super R2,? extends MonadicValue<R3>> value3,
                                              Fn4<? super RT,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
                                              Fn4<? super RT,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Description copied from interface: MonadicValue

Perform a four level nested internal iteration over this MonadicValue and the supplied MonadicValues Maybe.of(3) .forEach4(a->Maybe.just(a+10), (a,b)->Maybe.just(a+b), (a,b,c)->Maybe.none(), (a,b,c,d)->a+b+c<100, (a,b,c,d)->a+b+c+d); //Maybe.none

Specified by:

forEach4 in interface MonadicValue<RT>

Specified by:

forEach4 in interface Xor<LT,RT>

Parameters:

value1 - Nested MonadicValue to iterate over

value2 - Nested MonadicValue to iterate over

value3 - Nested MonadicValue to iterate over

filterFunction - Filter to applyHKT over elements before passing non-filtered values to the yielding function

yieldingFunction - Function with pointers to the current element from both MonadicValue that generates the new elements

Returns:

MonadicValue with elements generated via nested iteration

forEach3

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

Description copied from interface: MonadicValue

Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues

  
  Maybe.of(3)
       .forEach3(a->Maybe.just(a+10),
                 (a,b)->Maybe.just(a+b),
                 (a,b,c)->a+b+c<100,
                 (a,b,c)->a+b+c);
                                  
  
  //Maybe[32]
 
 

Specified by:

forEach3 in interface MonadicValue<RT>

Specified by:

forEach3 in interface Xor<LT,RT>

Parameters:

value1 - Nested MonadicValue to iterate over

value2 - Nested MonadicValue to iterate over

yieldingFunction - Function with pointers to the current element from both MonadicValue that generates the new elements

Returns:

MonadicValue with elements generated via nested iteration

forEach3

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

Description copied from interface: MonadicValue

Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues

  
  Maybe.of(3)
       .forEach3(a->Maybe.just(a+10),
                 (a,b)->Maybe.just(a+b),
                 (a,b,c)->a+b+c<100,
                 (a,b,c)->a+b+c);
                                  
  
  //Maybe[32]
 
 

Specified by:

forEach3 in interface MonadicValue<RT>

Specified by:

forEach3 in interface Xor<LT,RT>

Parameters:

value1 - Nested MonadicValue to iterate over

value2 - Nested MonadicValue to iterate over

filterFunction - Filter to applyHKT over elements before passing non-filtered values to the yielding function

yieldingFunction - Function with pointers to the current element from both MonadicValue that generates the new elements

Returns:

MonadicValue with elements generated via nested iteration

forEach2

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

Description copied from interface: MonadicValue

Perform a two level nested internal iteration over this MonadicValue and the supplied MonadicValue

  
  Maybe.of(3)
       .forEach2(a->Maybe.none(),
                 (a,b)->a+b);
                                  
 
  //Maybe.none()
 
 

Specified by:

forEach2 in interface MonadicValue<RT>

Specified by:

forEach2 in interface Xor<LT,RT>

Parameters:

value1 - Nested Monadic Type to iterate over

yieldingFunction - Function with pointers to the current element from both monad types that generates the new elements

Returns:

MonadicValue with elements generated via nested iteration

forEach2

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

Description copied from interface: MonadicValue

Perform a two level nested internal iteration over this MonadicValue and the supplied reactiveStream

  
  Maybe.of(3)
       .forEach2(a->Maybe.none(),
                 a->b-> a<3 && b>10,
                 (a,b)->a+b);
                                  
 
  //Maybe.none()
 
 

Specified by:

forEach2 in interface MonadicValue<RT>

Specified by:

forEach2 in interface Xor<LT,RT>

filterFunction - Filter to applyHKT over elements before passing non-filtered values to the yielding function

yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements

Returns:

MonadicValue with elements generated via nested iteration

combineToList

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

Description copied from interface: Xor

Accumulate secondarys into a LinkedListX (extended Persistent List) and Primary with the supplied combiner function Primary accumulation only occurs if all phases are primary

Specified by:

combineToList in interface Xor<LT,RT>

Parameters:

app - Value to combine with

fn - Combiner function for primary values

Returns:

Combined Xor

combine

default <T2,R> Either<LT,R> combine(Xor<? 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: Xor

Accumulate secondary values with the provided BinaryOperator / Semigroup Semigroups Primary accumulation only occurs if all phases are primary

 
  Xor<String,String> fail1 =  Xor.secondary("failed1");
        Xor<LinkedListX<String>,String> result = fail1.list().combine(Xor.secondary("failed2").list(), SemigroupK.collectionConcat(),(a,b)->a+b);

        //Secondary of [LinkedListX.of("failed1","failed2")))]
 
 

Specified by:

combine in interface Xor<LT,RT>

Parameters:

app - Value to combine with

semigroup - to combine secondary types

fn - To combine primary types

Returns:

Combined Xor

fromPublisher

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

Lazily construct a Right Either from the supplied publisher

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

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

         //Either[1]

 
 

Specified by:

fromPublisher in interface Xor<LT,RT>

Parameters:

pub - Publisher to construct an Either from

Returns:

Either constructed from the supplied Publisher

fromIterable

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

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]

 
 

Specified by:

fromIterable in interface Xor<LT,RT>

Parameters:

iterable - Iterable to construct an Either from

Returns:

Either constructed from the supplied Iterable

left

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

Create an instance of the secondary type. Most methods are biased to the primary 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]
 
 

Parameters:

value - to wrap

Returns:

Left instance of Either

right

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

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

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


 
 

Parameters:

value - To construct an Either from

Returns:

Right type instanceof Either

anyMEither

default AnyM<Witness.either,RT> anyMEither()

zip

default Either<LT,RT> zip(java.util.function.BinaryOperator<Zippable<RT>> combiner,
                          Zippable<RT> app)

Description copied from interface: Zippable

Combine two applicatives together using the provided BinaryOperator (Semigroup, Monoid and Reducer all extend BinaryOperator - checkout SemigroupK and Monoids for a large number of canned combinations). If this Applicative is a scalar value the provided value is combined with that value, otherwise the value is combined pair wise with all value in a non-scalar datastructure

Specified by:

zip in interface Xor<LT,RT>

Specified by:

zip in interface Zippable<RT>

Returns:

See Also:

Semigroup, Semigroups, Monoid, To lift any Semigroup (or monoid) up to handling Applicatives use the combineApplicatives operator in SemigroupK {@see com.aol.cyclops2.SemigroupK#combineApplicatives(BiFunction) } or Monoids { {@see com.aol.cyclops2.Monoids#combineApplicatives(java.util.function.Function, com.aol.cyclops2.function.Monoid) }

 {@code


  BinaryOperator> sumMaybes = SemigroupK.combineScalarFunctors(SemigroupK.intSum);
        Maybe.just(1).zip(sumMaybes, Maybe.just(5))
       //Maybe.just(6));
 }
 

flatMapI

default <R> Either<LT,R> flatMapI(java.util.function.Function<? super RT,? extends java.lang.Iterable<? extends R>> mapper)

Description copied from interface: MonadicValue

A flattening transformation operation that takes the first value from the returned Iterable.

  
   Maybe.just(1).map(i->i+2).flatMapI(i->Arrays.asList(()->i*3,20);
   //Maybe[9]
 
 

Specified by:

flatMapI in interface MonadicValue<RT>

Specified by:

flatMapI in interface Xor<LT,RT>

Parameters:

mapper - transformation function

Returns:

MonadicValue

flatMapP

default <R> Either<LT,R> flatMapP(java.util.function.Function<? super RT,? extends org.reactivestreams.Publisher<? extends R>> mapper)

Description copied from interface: MonadicValue

A flattening transformation operation that takes the first value from the returned Publisher.

  
   Future.ofResult(1).map(i->i+2).flatMapP(i->Flux.just(()->i*3,20);
   //Future[9]
 
 

Specified by:

flatMapP in interface MonadicValue<RT>

Specified by:

flatMapP in interface Xor<LT,RT>

Parameters:

mapper - transformation function

Returns:

MonadicValue

coflatMap

default <R> Either<LT,R> coflatMap(java.util.function.Function<? super MonadicValue<RT>,R> mapper)

Description copied from interface: MonadicValue

Perform a coflatMap operation. The mapping function accepts this MonadicValue and returns a singleUnsafe value to be wrapped inside a Monad.

  
   Maybe.none().coflatMap(m -> m.isPresent() ? m.get() : 10);
   //Maybe[10]
 
 

Specified by:

coflatMap in interface MonadicValue<RT>

Specified by:

coflatMap in interface Xor<LT,RT>

Parameters:

mapper - Mapping / transformation function

Returns:

MonadicValue wrapping return value from transformation function applied to the value inside this MonadicValue

toTrampoline

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

Specified by:

toTrampoline in interface Xor<LT,RT>

toEitherTrampoline

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

nest

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

Description copied from interface: MonadicValue

cojoin pattern. Nests this Monad inside another.

Specified by:

nest in interface MonadicValue<RT>

Specified by:

nest in interface Xor<LT,RT>

Returns:

Nested Monad

combineEager

default Either<LT,RT> combineEager(Monoid<RT> monoid,
                                   MonadicValue<? extends RT> v2)

Description copied from interface: MonadicValue

Eagerly combine two MonadicValues using the supplied monoid (@see ApplicativeFunctor for type appropraite i.e. maybe / async alternatives)

  
 
  Monoid<Integer> add = Monoid.of(1,SemigroupK.intSum);
  Maybe.of(10).combineEager(add,Maybe.none());
  //Maybe[10]
  
  Maybe.none().combineEager(add,Maybe.of(10));
  //Maybe[10]
  
  Maybe.none().combineEager(add,Maybe.none());
  //Maybe.none()
  
  Maybe.of(10).combineEager(add,Maybe.of(10));
  //Maybe[20]
  
  Monoid<Integer> firstNonNull = Monoid.of(null , SemigroupK.firstNonNull());
  Maybe.of(10).combineEager(firstNonNull,Maybe.of(10));
  //Maybe[10]
 

Specified by:

combineEager in interface MonadicValue<RT>

Specified by:

combineEager in interface Xor<LT,RT>

Returns:

unit

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

Specified by:

unit in interface MonadicValue<RT>

Specified by:

unit in interface Unit<RT>

Specified by:

unit in interface Xor<LT,RT>

toOptional

default java.util.Optional<RT> toOptional()

Specified by:

toOptional in interface Convertable<RT>

Specified by:

toOptional in interface Xor<LT,RT>

Returns:

Optional that wraps contained value, Optional.zero if value is null

filter

Either<LT,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 Filters<RT>

Specified by:

filter in interface MonadicValue<RT>

Specified by:

filter in interface Xor<LT,RT>

Parameters:

test - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

secondaryToPrimayMap

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

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

Specified by:

secondaryToPrimayMap in interface Xor<LT,RT>

Parameters:

fn - Function to map secondary type to primary

Returns:

Either with secondary type mapped to primary

secondaryMap

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

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

Specified by:

secondaryMap in interface Xor<LT,RT>

Parameters:

fn - Transformation function for Left types

Returns:

Either with Left type transformed

map

<R> Either<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 MonadicValue<RT>

Specified by:

map in interface Transformable<RT>

Specified by:

map in interface Xor<LT,RT>

Parameters:

fn - Transformation function

Returns:

Transformed Transformable

secondaryPeek

Either<LT,RT> secondaryPeek(java.util.function.Consumer<? super LT> action)

Peek at the Left type value if present

Specified by:

secondaryPeek in interface Xor<LT,RT>

Parameters:

action - Consumer to peek at the Left type value

Returns:

Either with the same values as before

peek

Either<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 Transformable<RT>

Specified by:

peek in interface Xor<LT,RT>

Parameters:

action - Consumer that recieves each element from this Transformable

Returns:

Transformable that will peek at each value

zipWith

default <R> Either<LT,R> zipWith(java.lang.Iterable<java.util.function.Function<? super RT,? extends R>> fn)

Specified by:

zipWith in interface Xor<LT,RT>

Specified by:

zipWith in interface Zippable<RT>

zipWithS

default <R> Either<LT,R> zipWithS(java.util.stream.Stream<java.util.function.Function<? super RT,? extends R>> fn)

Specified by:

zipWithS in interface Xor<LT,RT>

Specified by:

zipWithS in interface Zippable<RT>

zipWithP

default <R> Either<LT,R> zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super RT,? extends R>> fn)

Specified by:

zipWithP in interface Xor<LT,RT>

Specified by:

zipWithP in interface Zippable<RT>

retry

default <R> Either<LT,R> retry(java.util.function.Function<? super RT,? extends R> fn)

Description copied from interface: Transformable

Retry a transformation if it fails. Default settings are to retry up to 7 times, with an doubling backoff period starting @ 2 seconds delay before retry.

 
 given(serviceMock.applyHKT(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");


 		String result = ReactiveSeq.of( 1,  2, 3)
 				.retry(serviceMock)
 				.firstValue();

 		//result = 42
 
 

Specified by:

retry in interface Transformable<RT>

Specified by:

retry in interface Xor<LT,RT>

Parameters:

fn - Function to retry if fails

zipP

default <U> Either<LT,org.jooq.lambda.tuple.Tuple2<RT,U>> zipP(org.reactivestreams.Publisher<? extends U> other)

Specified by:

zipP in interface Xor<LT,RT>

Specified by:

zipP in interface Zippable<RT>

retry

default <R> Either<LT,R> retry(java.util.function.Function<? super RT,? extends R> fn,
                               int retries,
                               long delay,
                               java.util.concurrent.TimeUnit timeUnit)

Description copied from interface: Transformable

Retry a transformation if it fails. Retries up to retries times, with an doubling backoff period starting @ delay TimeUnits delay before retry.

 
 given(serviceMock.applyHKT(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");


 		String result = ReactiveSeq.of( 1,  2, 3)
 				.retry(serviceMock, 7, 2, TimeUnit.SECONDS)
 				.firstValue();

 		//result = 42
 
 

Specified by:

retry in interface Transformable<RT>

Specified by:

retry in interface Xor<LT,RT>

Parameters:

fn - Function to retry if fails

retries - Number of retries

delay - Delay in TimeUnits

timeUnit - TimeUnit to use for delay

zip3

default <S,U> Either<LT,org.jooq.lambda.tuple.Tuple3<RT,S,U>> zip3(java.lang.Iterable<? extends S> second,
                                                                   java.lang.Iterable<? extends U> third)

Description copied from interface: Zippable

zip 3 Streams into one

 
  List<Tuple3<Integer, Integer, Character>> list = of(1, 2, 3, 4, 5, 6).zip3(of(100, 200, 300, 400), of('a', 'b', 'c')).collect(CyclopsCollectors.toList());

  // [[1,100,'a'],[2,200,'b'],[3,300,'c']]
 

 

Specified by:

zip3 in interface Xor<LT,RT>

Specified by:

zip3 in interface Zippable<RT>

zip3

default <S,U,R> Either<LT,R> zip3(java.lang.Iterable<? extends S> second,
                                  java.lang.Iterable<? extends U> third,
                                  Fn3<? super RT,? super S,? super U,? extends R> fn3)

Specified by:

zip3 in interface Xor<LT,RT>

Specified by:

zip3 in interface Zippable<RT>

zip4

default <T2,T3,T4> Either<LT,org.jooq.lambda.tuple.Tuple4<RT,T2,T3,T4>> zip4(java.lang.Iterable<? extends T2> second,
                                                                             java.lang.Iterable<? extends T3> third,
                                                                             java.lang.Iterable<? extends T4> fourth)

Description copied from interface: Zippable

zip 4 Streams into 1

 
  List<Tuple4<Integer, Integer, Character, String>> list = of(1, 2, 3, 4, 5, 6).zip4(of(100, 200, 300, 400), of('a', 'b', 'c'), of("hello", "world"))
          .collect(CyclopsCollectors.toList());

 
 // [[1,100,'a',"hello"],[2,200,'b',"world"]]
 

Specified by:

zip4 in interface Xor<LT,RT>

Specified by:

zip4 in interface Zippable<RT>

zip4

default <T2,T3,T4,R> Either<LT,R> zip4(java.lang.Iterable<? extends T2> second,
                                       java.lang.Iterable<? extends T3> third,
                                       java.lang.Iterable<? extends T4> fourth,
                                       Fn4<? super RT,? super T2,? super T3,? super T4,? extends R> fn)

Specified by:

zip4 in interface Xor<LT,RT>

Specified by:

zip4 in interface Zippable<RT>

flatMapS

default <R> Either<LT,R> flatMapS(java.util.function.Function<? super RT,? extends java.util.stream.Stream<? extends R>> mapper)

Specified by:

flatMapS in interface MonadicValue<RT>

Specified by:

flatMapS in interface Xor<LT,RT>

swap

Either<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 Xor<LT,RT>

Returns:

Swap the primary and secondary types, allowing operations directly on what was the Left type

toIor

Ior<LT,RT> toIor()

Description copied from interface: Value

Return an Ior that can be this object or a Ior.primary or Ior.secondary

Specified by:

toIor in interface Value<RT>

Specified by:

toIor in interface Xor<LT,RT>

Returns:

new Ior

isPresent

default boolean isPresent()

Specified by:

isPresent in interface Convertable<RT>

Specified by:

isPresent in interface Xor<LT,RT>

Returns:

True if value exists and is non-null

toXor

default Xor<LT,RT> toXor()

Specified by:

toXor in interface Value<RT>

Specified by:

toXor in interface Xor<LT,RT>

Returns:

Primary Xor that has the same value as this Value

toXor

default <ST2> Xor<ST2,RT> toXor(ST2 secondary)

Description copied from interface: Value

Convert to an Xor where the secondary value will be used if no primary value is present

Specified by:

toXor in interface Value<RT>

Specified by:

toXor in interface Xor<LT,RT>

Parameters:

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

Returns:

Primary Xor with same value as this Value, or a Secondary Xor with the provided Value if this Value is zero

isSecondary

default boolean isSecondary()

Specified by:

isSecondary in interface Xor<LT,RT>

Returns:

True if this is a secondary Xor

isPrimary

default boolean isPrimary()

Specified by:

isPrimary in interface Xor<LT,RT>

Returns:

True if this is a primary Xor

visit

<R> R visit(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 secondary function if this Either contains an element of the secondary type Execute the primary function if this Either contains an element of the primary type

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

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



 
 

Specified by:

visit in interface Xor<LT,RT>

Parameters:

secondary - Function to execute if this is a Left Either

primary - Function to execute if this is a Right Ior

both - Function to execute if this Ior contains both types

Returns:

Result of executing the appropriate function

mapBoth

@Deprecated
default <R1,R2> Either<R1,R2> mapBoth(java.util.function.Function<? super LT,? extends R1> secondary,
                                                  java.util.function.Function<? super RT,? extends R2> primary)

Deprecated.

bimap

default <R1,R2> Either<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 Xor<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 Either<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 Xor<LT,RT>

Parameters:

c1 - consumer for the first type

c2 - consumer for the second type

Returns:

New BiTransformable with the same data

bicast

default <U1,U2> Either<U1,U2> bicast(java.lang.Class<U1> type1,
                                     java.lang.Class<U2> type2)

Description copied from interface: BiTransformable

Cast two data types simulatanously.

 
     MapX<Animal,Food> map = MapXs.of(cow,grass);
     MapX<Mamaml,Vegitation> herbervoreMammals = map.bicast(Mammal.class,Vegitation.class);
 
 

Specified by:

bicast in interface BiTransformable<LT,RT>

Specified by:

bicast in interface Xor<LT,RT>

Returns:

bitrampoline

default <R1,R2> Either<R1,R2> bitrampoline(java.util.function.Function<? super LT,? extends Trampoline<? extends R1>> mapper1,
                                           java.util.function.Function<? super RT,? extends Trampoline<? extends R2>> mapper2)

Description copied from interface: BiTransformable

Perform a tail-call optimized recursive transformation operation across two data points simultaneously

Specified by:

bitrampoline in interface BiTransformable<LT,RT>

Specified by:

bitrampoline in interface Xor<LT,RT>

Parameters:

mapper1 - transformation function for the first type

mapper2 - transformation function for the second type

Returns:

New BiTransformable containing transformed data

get

RT get()

Specified by:

get in interface Convertable<RT>

Specified by:

get in interface java.util.function.Supplier<RT>

Specified by:

get in interface Xor<LT,RT>

Returns:

Contained value, maybe null

secondaryValue

Value<LT> secondaryValue()

Specified by:

secondaryValue in interface Xor<LT,RT>

Returns:

A Value containing the secondary Value if present

secondaryGet

LT secondaryGet()

Specified by:

secondaryGet in interface Xor<LT,RT>

Returns:

The Left Value if present, otherwise null

secondaryToOptional

java.util.Optional<LT> secondaryToOptional()

Specified by:

secondaryToOptional in interface Xor<LT,RT>

Returns:

The Left value wrapped in an Optional if present, otherwise an zero Optional

secondaryToStream

ReactiveSeq<LT> secondaryToStream()

Specified by:

secondaryToStream in interface Xor<LT,RT>

Returns:

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

flatMap

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

Description copied from interface: MonadicValue

A flattening transformation operation (@see Optional.flatMap(Function)

  
   Eval.now(1).map(i->i+2).flatMap(i->Eval.later(()->i*3);
   //Eval[9]
 
 

Specified by:

flatMap in interface MonadicValue<RT>

Specified by:

flatMap in interface Xor<LT,RT>

Parameters:

mapper - transformation function

Returns:

MonadicValue

secondaryFlatMap

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

Perform a flatMap operation on the Left type

Specified by:

secondaryFlatMap in interface Xor<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

secondaryToPrimayFlatMap

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

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

Specified by:

secondaryToPrimayFlatMap in interface Xor<LT,RT>

Parameters:

fn - Transformation function

Returns:

Either

peek

@Deprecated
void peek(java.util.function.Consumer<? super LT> stAction,
                      java.util.function.Consumer<? super RT> ptAction)

Deprecated.

Specified by:

peek in interface Xor<LT,RT>

isRight

boolean isRight()

Returns:

True if this is a primary Either

isLeft

boolean isLeft()

Returns:

True if this is a secondary Either

combine

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

Description copied from interface: MonadicValue

Lazily combine this ApplicativeFunctor with the supplied value via the supplied BiFunction Example

 
   Maybe<Integer> some = Maybe.just(10);
   just.combine(Eval.now(20), this::add);
   //Some[30]

   Maybe<Integer> none = Maybe.none();
   none.combine(Eval.now(20), this::add);
   //None

 
 

Specified by:

combine in interface MonadicValue<RT>

Specified by:

combine in interface Xor<LT,RT>

Parameters:

app - Value to combine with this one.

fn - BiFunction to combine them

Returns:

New Applicativefunctor that represents the combined values

list

default Either<LinkedListX<LT>,RT> list()

Specified by:

list in interface Xor<LT,RT>

Returns:

An Either with the secondary type converted to a persistent list, for use with accumulating app function Either#combine(Either,BiFunction)

combineToList

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

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

Parameters:

app - Value to combine with

fn - Combiner function for primary values

Returns:

Combined Either

combine

default <T2,R> Either<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 secondary values with the provided BinaryOperator / Semigroup Semigroups Right accumulation only occurs if all phases are primary

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

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

Parameters:

app - Value to combine with

semigroup - to combine secondary types

fn - To combine primary types

Returns:

Combined Either

zip

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

Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Iterable using the supplied combining function

Specified by:

zip in interface MonadicValue<RT>

Specified by:

zip in interface Xor<LT,RT>

Specified by:

zip in interface Zippable<RT>

Parameters:

app - to zip with

fn - Zip function

Returns:

Combined zippable

zipP

default <T2,R> Either<LT,R> zipP(org.reactivestreams.Publisher<? extends T2> app,
                                 java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)

Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function

Specified by:

zipP in interface MonadicValue<RT>

Specified by:

zipP in interface Xor<LT,RT>

Specified by:

zipP in interface Zippable<RT>

Parameters:

app - to combine with

fn - Zip / combining function

Returns:

Combined zippable

zipS

default <U,R> Either<LT,R> zipS(java.util.stream.Stream<? extends U> other,
                                java.util.function.BiFunction<? super RT,? super U,? extends R> zipper)

Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Stream, using the supplied combining function

Specified by:

zipS in interface Xor<LT,RT>

Specified by:

zipS in interface Zippable<RT>

Parameters:

other - Stream to combine with

zipper - Zip / combining function

Returns:

Combined zippable

zipS

default <U> Either<LT,org.jooq.lambda.tuple.Tuple2<RT,U>> zipS(java.util.stream.Stream<? extends U> other)

Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2

Specified by:

zipS in interface Xor<LT,RT>

Specified by:

zipS in interface Zippable<RT>

Parameters:

other - Stream to combine with

Returns:

Combined Zippable

zip

default <U> Either<LT,org.jooq.lambda.tuple.Tuple2<RT,U>> zip(java.lang.Iterable<? extends U> other)

Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2

Specified by:

zip in interface Xor<LT,RT>

Specified by:

zip in interface Zippable<RT>

Parameters:

other - Iterable to combine with

Returns:

ofType

default <U> Either<LT,U> ofType(java.lang.Class<? extends U> type)

Description copied from interface: Filters

Keep only those elements in a reactiveStream that are of a given type.

  
 
 // (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)
 
 
 

Specified by:

ofType in interface Filters<RT>

Specified by:

ofType in interface Xor<LT,RT>

filterNot

default Either<LT,RT> filterNot(java.util.function.Predicate<? super RT> fn)

Description copied from interface: Filters

Remove any elements for which the predicate holds (inverse operation to filter) e.g.

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

Specified by:

filterNot in interface Filters<RT>

Specified by:

filterNot in interface Xor<LT,RT>

Parameters:

fn - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

notNull

default Either<LT,RT> notNull()

Description copied from interface: Filters

Filter elements retaining only values which are not null

  
 
   of(1,2,null,4).nonNull();
 
   //[1,2,4]
   
 
 

Specified by:

notNull in interface Filters<RT>

Specified by:

notNull in interface Xor<LT,RT>

Returns:

Filters with nulls removed

cast

default <U> Either<LT,U> cast(java.lang.Class<? extends U> type)

Description copied from interface: Transformable

Cast all elements in a reactiveStream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)

Specified by:

cast in interface Transformable<RT>

Specified by:

cast in interface Xor<LT,RT>

trampoline

default <R> Either<LT,R> trampoline(java.util.function.Function<? super RT,? extends Trampoline<? extends R>> mapper)

Description copied from interface: Transformable

Performs a map operation that can call a recursive method without running out of stack space

 
 ReactiveSeq.of(10,20,30,40)
    			 .trampoline(i-> fibonacci(i))
    			 .forEach(System.out::println);

    	Trampoline<Long> fibonacci(int i){
    		return fibonacci(i,1,0);
    	}
    	Trampoline<Long> fibonacci(int n, long a, long b) {
        	return n == 0 ? Trampoline.done(b) : Trampoline.more( ()->fibonacci(n-1, a+b, a));
    	}

 55
    	6765
    	832040
    	102334155


 ReactiveSeq.of(10_000,200_000,3_000_000,40_000_000)
    			 .trampoline(i-> fibonacci(i))
    			 .forEach(System.out::println);


 completes successfully
 
 

Specified by:

trampoline in interface Transformable<RT>

Specified by:

trampoline in interface Xor<LT,RT>

Parameters:

mapper - TCO Transformation function

Returns:

Transformable transformed by the supplied transformation function

narrow

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