com.aol.cyclops.sum.types

Interface Either4<LT1,LT2,LT3,RT>

Type Parameters:

LT1 - First type (Left type)

LT2 - Second type

LT3 - Third Type

RT - Right type (operations are performed on this type if present)

All Superinterfaces:

com.aol.cyclops.types.applicative.ApplicativeFunctor<RT>, com.aol.cyclops.types.BiFunctor<LT3,RT>, com.aol.cyclops.types.Combiner<RT>, com.aol.cyclops.types.Convertable<RT>, com.aol.cyclops.types.ConvertableFunctor<RT>, com.aol.cyclops.types.Filterable<RT>, com.aol.cyclops.types.Foldable<RT>, com.aol.cyclops.types.Functor<RT>, java.lang.Iterable<RT>, com.aol.cyclops.types.MonadicValue<RT>, java.util.function.Predicate<RT>, org.reactivestreams.Publisher<RT>, java.util.function.Supplier<RT>, com.aol.cyclops.types.To<Either4<LT1,LT2,LT3,RT>>, com.aol.cyclops.types.Unit<RT>, com.aol.cyclops.types.Value<RT>, com.aol.cyclops.types.Visitable<RT>, com.aol.cyclops.types.Zippable<RT>

All Known Implementing Classes:

Either4.Lazy, Either4.Left1, Either4.Left2, Either4.Left3, Either4.Right

public interface Either4<LT1,LT2,LT3,RT>
extends com.aol.cyclops.types.Functor<RT>, com.aol.cyclops.types.Filterable<RT>, com.aol.cyclops.types.BiFunctor<LT3,RT>, com.aol.cyclops.types.To<Either4<LT1,LT2,LT3,RT>>, com.aol.cyclops.types.MonadicValue<RT>, java.util.function.Supplier<RT>, com.aol.cyclops.types.applicative.ApplicativeFunctor<RT>

A right biased Lazy Either4 type. map / flatMap operators are tail-call optimized Can be one of 4 types Left1 Left2 Left3 Right

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	Either4.Lazy<ST,M,M2,PT>
static class	Either4.Left1<ST,M,M2,PT>
static class	Either4.Left2<ST,M,M2,PT>
static class	Either4.Left3<ST,M,M2,PT>
static class	Either4.Right<ST,M,M2,PT>

Nested classes/interfaces inherited from interface com.aol.cyclops.types.applicative.ApplicativeFunctor

com.aol.cyclops.types.applicative.ApplicativeFunctor.Applicatives, com.aol.cyclops.types.applicative.ApplicativeFunctor.ApplyFunctions<T>

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

com.aol.cyclops.types.Value.ValueImpl<T>

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

com.aol.cyclops.types.Convertable.SupplierToConvertable<T>

Method Summary

Modifier and Type	Method and Description
static <LT1,LT2,LT3,RT> Either4<com.aol.cyclops.data.collections.extensions.standard.ListX<LT1>,com.aol.cyclops.data.collections.extensions.standard.ListX<LT2>,com.aol.cyclops.data.collections.extensions.standard.ListX<LT3>,RT>	accumulate(com.aol.cyclops.Monoid<RT> reducer, com.aol.cyclops.data.collections.extensions.CollectionX<Either4<LT1,LT2,LT3,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) Monoids.
static <LT1,LT2,LT3,T> com.aol.cyclops.types.anyM.AnyMValue<T>	anyM(Either4<LT1,LT2,LT3,T> xor) Create an AnyMValue instance that wraps an Either4
static <ST,LT2,LT3,T> com.aol.cyclops.data.collections.extensions.standard.ListX<com.aol.cyclops.types.anyM.AnyMValue<T>>	anyMList(java.lang.Iterable<Either4<ST,LT2,LT3,T>> anyM) Take an iterable containing Either3s and convert them into a List of AnyMs e.g.
static <X,LT1 extends X,LT2 extends X,LT3 extends X,RT extends X,R> java.util.function.Function<java.util.function.Function<? super X,R>,R>	applyAny(Either4<LT1,LT2,LT3,RT> either)
default <U1,U2> Either4<LT1,LT2,U1,U2>	bicast(java.lang.Class<U1> type1, java.lang.Class<U2> type2)
<R1,R2> Either4<LT1,LT2,R1,R2>	bimap(java.util.function.Function<? super LT3,? extends R1> fn1, java.util.function.Function<? super RT,? extends R2> fn2)
default Either4<LT1,LT2,LT3,RT>	bipeek(java.util.function.Consumer<? super LT3> c1, java.util.function.Consumer<? super RT> c2)
default <R1,R2> Either4<LT1,LT2,R1,R2>	bitrampoline(java.util.function.Function<? super LT3,? extends com.aol.cyclops.control.Trampoline<? extends R1>> mapper1, java.util.function.Function<? super RT,? extends com.aol.cyclops.control.Trampoline<? extends R2>> mapper2)
default <U> Either4<LT1,LT2,LT3,U>	cast(java.lang.Class<? extends U> type)
default <R> Either4<LT1,LT2,LT3,R>	coflatMap(java.util.function.Function<? super com.aol.cyclops.types.MonadicValue<RT>,R> mapper)
default Either4<LT1,LT2,LT3,RT>	combine(java.util.function.BinaryOperator<com.aol.cyclops.types.Combiner<RT>> combiner, com.aol.cyclops.types.Combiner<RT> app)
default <T2,R> Either4<LT1,LT2,LT3,R>	combine(com.aol.cyclops.types.Value<? extends T2> app, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)
default Either4<LT1,LT2,LT3,RT>	combineEager(com.aol.cyclops.Monoid<RT> monoid, com.aol.cyclops.types.MonadicValue<? extends RT> v2)
static <X,LT1 extends X,LT2 extends X,LT3 extends X,RT extends X> java.util.function.Consumer<java.util.function.Consumer<? super X>>	consumeAny(Either4<LT1,LT2,LT3,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)
com.aol.cyclops.control.Maybe<RT>	filter(java.util.function.Predicate<? super RT> test) Filter this Either4 resulting in a Maybe#none if it is not a Right instance or if the predicate does not hold.
default com.aol.cyclops.control.Maybe<RT>	filterNot(java.util.function.Predicate<? super RT> predicate)
<RT1> Either4<LT1,LT2,LT3,RT1>	flatMap(java.util.function.Function<? super RT,? extends com.aol.cyclops.types.MonadicValue<? extends RT1>> mapper) Flattening transformation on this Either4.
default <RT1> Either4<LT1,LT2,LT3,RT1>	flatMapIterable(java.util.function.Function<? super RT,? extends java.lang.Iterable<? extends RT1>> mapper)
default <RT1> Either4<LT1,LT2,LT3,RT1>	flatMapPublisher(java.util.function.Function<? super RT,? extends org.reactivestreams.Publisher<? extends RT1>> mapper)
default <R1,R> Either4<LT1,LT2,LT3,R>	forEach2(java.util.function.Function<? super RT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends R> yieldingFunction)
default <R1,R> Either4<LT1,LT2,LT3,R>	forEach2(java.util.function.Function<? super RT,? extends com.aol.cyclops.types.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)
default <T2,R1,R2,R> Either4<LT1,LT2,LT3,R>	forEach3(java.util.function.Function<? super RT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends com.aol.cyclops.types.MonadicValue<R2>> value2, com.aol.cyclops.util.function.TriFunction<? super RT,? super R1,? super R2,? extends R> yieldingFunction)
default <T2,R1,R2,R> Either4<LT1,LT2,LT3,R>	forEach3(java.util.function.Function<? super RT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends com.aol.cyclops.types.MonadicValue<R2>> value2, com.aol.cyclops.util.function.TriFunction<? super RT,? super R1,? super R2,java.lang.Boolean> filterFunction, com.aol.cyclops.util.function.TriFunction<? super RT,? super R1,? super R2,? extends R> yieldingFunction)
default <T2,R1,R2,R3,R> Either4<LT1,LT2,LT3,R>	forEach4(java.util.function.Function<? super RT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends com.aol.cyclops.types.MonadicValue<R2>> value2, com.aol.cyclops.util.function.TriFunction<? super RT,? super R1,? super R2,? extends com.aol.cyclops.types.MonadicValue<R3>> value3, com.aol.cyclops.util.function.QuadFunction<? super RT,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
default <T2,R1,R2,R3,R> Either4<LT1,LT2,LT3,R>	forEach4(java.util.function.Function<? super RT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends com.aol.cyclops.types.MonadicValue<R2>> value2, com.aol.cyclops.util.function.TriFunction<? super RT,? super R1,? super R2,? extends com.aol.cyclops.types.MonadicValue<R3>> value3, com.aol.cyclops.util.function.QuadFunction<? super RT,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, com.aol.cyclops.util.function.QuadFunction<? super RT,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
static <ST,T,T2,RT> Either4<ST,T,T2,RT>	fromIterable(java.lang.Iterable<RT> iterable) Construct a Right Either4 from the supplied Iterable
static <LT1,LT2,LT3,RT> Either4<LT1,LT2,LT3,RT>	fromMonadicValue(com.aol.cyclops.types.MonadicValue<RT> mv4)
static <T1,T2,T> Either4<java.lang.Throwable,T1,T2,T>	fromPublisher(org.reactivestreams.Publisher<T> pub) Lazily construct a Right Either from the supplied publisher
boolean	isLeft1()
boolean	isLeft2()
boolean	isLeft3()
boolean	isRight()
static <LT,M1,B,RT> Either4<LT,M1,B,RT>	left1(LT left) Construct a Either4#Left1
static <LT,M1,B,RT> Either4<LT,M1,B,RT>	left1Eval(com.aol.cyclops.control.Eval<LT> left) Construct a Either4#Left1 from an Eval
static <LT,M1,B,RT> Either4<LT,M1,B,RT>	left2(M1 middle) Construct a Either4#Second
static <LT,M1,B,RT> Either4<LT,M1,B,RT>	left2Eval(com.aol.cyclops.control.Eval<M1> middle) Construct a Either4#Second from an Eval
static <LT,M1,B,RT> Either4<LT,M1,B,RT>	left3(B middle) Construct a Either4#Third
static <LT,M1,B,RT> Either4<LT,M1,B,RT>	left3Eval(com.aol.cyclops.control.Eval<B> middle) Construct a Either4#Third from an Eval
<R> Either4<LT1,LT2,LT3,R>	map(java.util.function.Function<? super RT,? extends R> fn)
default Either4<LT1,LT2,LT3,com.aol.cyclops.types.MonadicValue<RT>>	nest()
default com.aol.cyclops.control.Maybe<RT>	notNull()
default <U> com.aol.cyclops.control.Maybe<U>	ofType(java.lang.Class<? extends U> type)
default <R> Either4<LT1,LT2,LT3,R>	patternMatch(java.util.function.Function<com.aol.cyclops.control.Matchable.CheckValue1<RT,R>,com.aol.cyclops.control.Matchable.CheckValue1<RT,R>> case1, java.util.function.Supplier<? extends R> otherwise)
default Either4<LT1,LT2,LT3,RT>	peek(java.util.function.Consumer<? super RT> c)
static <LT,M1,B,RT> Either4<LT,M1,B,RT>	right(RT right) Construct a Either4#Right
static <LT,M1,B,RT> Either4<LT,M1,B,RT>	rightEval(com.aol.cyclops.control.Eval<RT> right) Construct a Either4#Right from an Eval
static <LT1,LT2,LT3,PT> Either4<com.aol.cyclops.data.collections.extensions.standard.ListX<LT1>,com.aol.cyclops.data.collections.extensions.standard.ListX<LT2>,com.aol.cyclops.data.collections.extensions.standard.ListX<LT3>,com.aol.cyclops.data.collections.extensions.standard.ListX<PT>>	sequence(com.aol.cyclops.data.collections.extensions.CollectionX<Either4<LT1,LT2,LT3,PT>> xors) Turn a collection of Either3 into a single Either with Lists of values.
Either4<RT,LT2,LT3,LT1>	swap1()
Either4<LT1,RT,LT3,LT2>	swap2()
Either4<LT1,LT2,RT,LT3>	swap3()
default com.aol.cyclops.control.Ior<LT1,RT>	toIor() Return an Ior that can be this object or a Ior.primary or Ior.secondary
default com.aol.cyclops.control.Xor<LT1,RT>	toXor()
default <R> Either4<LT1,LT2,LT3,R>	trampoline(java.util.function.Function<? super RT,? extends com.aol.cyclops.control.Trampoline<? extends R>> mapper)
static <LT1,LT2,LT3,PT,R> Either4<com.aol.cyclops.data.collections.extensions.standard.ListX<LT1>,com.aol.cyclops.data.collections.extensions.standard.ListX<LT2>,com.aol.cyclops.data.collections.extensions.standard.ListX<LT3>,com.aol.cyclops.data.collections.extensions.standard.ListX<R>>	traverse(com.aol.cyclops.data.collections.extensions.CollectionX<Either4<LT1,LT2,LT3,PT>> xors, java.util.function.Function<? super PT,? extends R> fn) Traverse a Collection of Either3 producing an Either4 with a ListX, applying the transformation function to every element in the list
<T> Either4<LT1,LT2,LT3,T>	unit(T unit)
<R> R	visit(java.util.function.Function<? super LT1,? extends R> left1, java.util.function.Function<? super LT2,? extends R> left2, java.util.function.Function<? super LT3,? extends R> left3, java.util.function.Function<? super RT,? extends R> right) Visit the types in this Either4, only one user supplied function is executed depending on the type
static <X,LT1 extends X,LT2 extends X,LT3 extends X,RT extends X> X	visitAny(java.util.function.Consumer<? super X> c, Either4<LT1,LT2,LT3,RT> either)
static <X,LT1 extends X,LT2 extends X,LT3 extends X,RT extends X,R> R	visitAny(Either4<LT1,LT2,LT3,RT> either, java.util.function.Function<? super X,? extends R> fn)
default <T2,R> Either4<LT1,LT2,LT3,R>	zip(java.util.function.BiFunction<? super RT,? super T2,? extends R> fn, org.reactivestreams.Publisher<? extends T2> app)
default <T2,R> Either4<LT1,LT2,LT3,R>	zip(java.lang.Iterable<? extends T2> app, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)
default <U> Either4<LT1,LT2,LT3,org.jooq.lambda.tuple.Tuple2<RT,U>>	zip(java.lang.Iterable<? extends U> other)
default <U> Either4<LT1,LT2,LT3,org.jooq.lambda.tuple.Tuple2<RT,U>>	zip(org.jooq.lambda.Seq<? extends U> other)
default <U,R> Either4<LT1,LT2,LT3,R>	zip(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiFunction<? super RT,? super U,? extends R> zipper)
default <U> Either4<LT1,LT2,LT3,org.jooq.lambda.tuple.Tuple2<RT,U>>	zip(java.util.stream.Stream<? extends U> other)
default <U,R> Either4<LT1,LT2,LT3,R>	zip(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super RT,? super U,? extends R> zipper)

Methods inherited from interface com.aol.cyclops.types.To

to

Methods inherited from interface com.aol.cyclops.types.MonadicValue

anyM

Methods inherited from interface com.aol.cyclops.types.applicative.ApplicativeFunctor

applyFunctions

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

collect, fold, fold, generate, iterate, iterator, mapReduce, mkString, newSubscriber, of, stream, subscribe, test, toDequeX, toEvalAlways, toEvalLater, toEvalNow, toFeatureToggle, toFutureStream, toFutureStream, toLazyImmutable, toList, toListX, toMaybe, toMutable, toPBagX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toTry, toTry, toTry, toXor, unapply

Methods inherited from interface com.aol.cyclops.types.Foldable

endsWith, endsWithIterable, findAny, findFirst, firstValue, foldable, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, join, join, join, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleOptional, startsWith, startsWithIterable, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, validate, xMatch

Methods inherited from interface com.aol.cyclops.types.Convertable

collect, fromSupplier, get, isPresent, orElse, orElseGet, orElseThrow, toAtomicReference, toCompletableFuture, toCompletableFutureAsync, toCompletableFutureAsync, toFutureW, toFutureWAsync, toFutureWAsync, toOptional, toOptionalAtomicReference, toStream, visit

Methods inherited from interface java.util.function.Predicate

and, isEqual, negate, or

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Method Detail

consumeAny

static <X,LT1 extends X,LT2 extends X,LT3 extends X,RT extends X> java.util.function.Consumer<java.util.function.Consumer<? super X>> consumeAny(Either4<LT1,LT2,LT3,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(Either4::consumeAny)
                 .accept(System.out::println);
 
 

Parameters:

either - Either to consume value for

Returns:

Consumer we can apply to consume value

applyAny

static <X,LT1 extends X,LT2 extends X,LT3 extends X,RT extends X,R> java.util.function.Function<java.util.function.Function<? super X,R>,R> applyAny(Either4<LT1,LT2,LT3,RT> either)

visitAny

static <X,LT1 extends X,LT2 extends X,LT3 extends X,RT extends X,R> R visitAny(Either4<LT1,LT2,LT3,RT> either,
                                                                               java.util.function.Function<? super X,? extends R> fn)

visitAny

static <X,LT1 extends X,LT2 extends X,LT3 extends X,RT extends X> X visitAny(java.util.function.Consumer<? super X> c,
                                                                             Either4<LT1,LT2,LT3,RT> either)

fromMonadicValue

static <LT1,LT2,LT3,RT> Either4<LT1,LT2,LT3,RT> fromMonadicValue(com.aol.cyclops.types.MonadicValue<RT> mv4)

anyM

static <LT1,LT2,LT3,T> com.aol.cyclops.types.anyM.AnyMValue<T> anyM(Either4<LT1,LT2,LT3,T> xor)

Create an AnyMValue instance that wraps an Either4

Parameters:

xor - Either4 to wrap inside an AnyM

Returns:

AnyM instance that wraps the provided Either4

anyMList

static <ST,LT2,LT3,T> com.aol.cyclops.data.collections.extensions.standard.ListX<com.aol.cyclops.types.anyM.AnyMValue<T>> anyMList(java.lang.Iterable<Either4<ST,LT2,LT3,T>> anyM)

Take an iterable containing Either3s and convert them into a List of AnyMs e.g. List<AnyM<Integer>> anyMs = anyMList(Arrays.asList(Either4.right(1),Either4.left(10)); //List[AnyM[Either4:right[1],Either4:left[10]]]

Parameters:

anyM - Iterable containing Eithers

Returns:

List of AnyMs

sequence

static <LT1,LT2,LT3,PT> Either4<com.aol.cyclops.data.collections.extensions.standard.ListX<LT1>,com.aol.cyclops.data.collections.extensions.standard.ListX<LT2>,com.aol.cyclops.data.collections.extensions.standard.ListX<LT3>,com.aol.cyclops.data.collections.extensions.standard.ListX<PT>> sequence(com.aol.cyclops.data.collections.extensions.CollectionX<Either4<LT1,LT2,LT3,PT>> xors)

Turn a collection of Either3 into a single Either with Lists of values.

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

Parameters:

Either3 - Either3 to sequence

Returns:

Either3 Sequenced

traverse

static <LT1,LT2,LT3,PT,R> Either4<com.aol.cyclops.data.collections.extensions.standard.ListX<LT1>,com.aol.cyclops.data.collections.extensions.standard.ListX<LT2>,com.aol.cyclops.data.collections.extensions.standard.ListX<LT3>,com.aol.cyclops.data.collections.extensions.standard.ListX<R>> traverse(com.aol.cyclops.data.collections.extensions.CollectionX<Either4<LT1,LT2,LT3,PT>> xors,
                                                                                                                                                                                                                                                                                                          java.util.function.Function<? super PT,? extends R> fn)

Traverse a Collection of Either3 producing an Either4 with a ListX, applying the transformation function to every element in the list

Parameters:

xors - Either4s to sequence and transform

fn - Transformation function

Returns:

An Either4 with a transformed list

accumulate

static <LT1,LT2,LT3,RT> Either4<com.aol.cyclops.data.collections.extensions.standard.ListX<LT1>,com.aol.cyclops.data.collections.extensions.standard.ListX<LT2>,com.aol.cyclops.data.collections.extensions.standard.ListX<LT3>,RT> accumulate(com.aol.cyclops.Monoid<RT> reducer,
                                                                                                                                                                                                                                               com.aol.cyclops.data.collections.extensions.CollectionX<Either4<LT1,LT2,LT3,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) Monoids.

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

Parameters:

xors - Collection of Eithers to accumulate primary values

reducer - Reducer to accumulate results

Returns:

Either4 populated with the accumulate primary operation

fromPublisher

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

Lazily construct a Right Either from the supplied publisher

  
   ReactiveSeq<Integer> stream =  ReactiveSeq.of(1,2,3);
        
         Either4<Throwable,String,String,Integer> either = Either4.fromPublisher(stream);
        
         //Either[1]
 
 
 

Parameters:

pub - Publisher to construct an Either from

Returns:

Either constructed from the supplied Publisher

fromIterable

static <ST,T,T2,RT> Either4<ST,T,T2,RT> fromIterable(java.lang.Iterable<RT> iterable)

Construct a Right Either4 from the supplied Iterable

  
   List<Integer> list =  Arrays.asList(1,2,3);
        
         Either4<Throwable,String,Integer> future = Either4.fromIterable(list);
        
         //Either4[1]
 
 
 

Parameters:

iterable - Iterable to construct an Either from

Returns:

Either constructed from the supplied Iterable

rightEval

static <LT,M1,B,RT> Either4<LT,M1,B,RT> rightEval(com.aol.cyclops.control.Eval<RT> right)

Construct a Either4#Right from an Eval

Parameters:

right - Eval to construct Either4#Right from

Returns:

Either4 right instance

left1Eval

static <LT,M1,B,RT> Either4<LT,M1,B,RT> left1Eval(com.aol.cyclops.control.Eval<LT> left)

Construct a Either4#Left1 from an Eval

Parameters:

left - Eval to construct Either4#Left1 from

Returns:

Either4 Left1 instance

right

static <LT,M1,B,RT> Either4<LT,M1,B,RT> right(RT right)

Construct a Either4#Right

Parameters:

right - Value to store

Returns:

Either4 Right instance

left1

static <LT,M1,B,RT> Either4<LT,M1,B,RT> left1(LT left)

Construct a Either4#Left1

Parameters:

left - Value to store

Returns:

Left1 instance

left2

static <LT,M1,B,RT> Either4<LT,M1,B,RT> left2(M1 middle)

Construct a Either4#Second

Parameters:

middle - Value to store

Returns:

Second instance

left3

static <LT,M1,B,RT> Either4<LT,M1,B,RT> left3(B middle)

Construct a Either4#Third

Parameters:

middle - Value to store

Returns:

Third instance

left2Eval

static <LT,M1,B,RT> Either4<LT,M1,B,RT> left2Eval(com.aol.cyclops.control.Eval<M1> middle)

Construct a Either4#Second from an Eval

Parameters:

second - Eval to construct Either4#middle from

Returns:

Either4 second instance

left3Eval

static <LT,M1,B,RT> Either4<LT,M1,B,RT> left3Eval(com.aol.cyclops.control.Eval<B> middle)

Construct a Either4#Third from an Eval

Parameters:

third - Eval to construct Either4#middle from

Returns:

Either4 third instance

flatMapIterable

default <RT1> Either4<LT1,LT2,LT3,RT1> flatMapIterable(java.util.function.Function<? super RT,? extends java.lang.Iterable<? extends RT1>> mapper)

Specified by:

flatMapIterable in interface com.aol.cyclops.types.MonadicValue<RT>

flatMapPublisher

default <RT1> Either4<LT1,LT2,LT3,RT1> flatMapPublisher(java.util.function.Function<? super RT,? extends org.reactivestreams.Publisher<? extends RT1>> mapper)

Specified by:

flatMapPublisher in interface com.aol.cyclops.types.MonadicValue<RT>

visit

<R> R visit(java.util.function.Function<? super LT1,? extends R> left1,
            java.util.function.Function<? super LT2,? extends R> left2,
            java.util.function.Function<? super LT3,? extends R> left3,
            java.util.function.Function<? super RT,? extends R> right)

Visit the types in this Either4, only one user supplied function is executed depending on the type

Parameters:

left1 - Function to execute if this Either4 is a Left1 instance

left2 - Function to execute if this Either4 is a Left2 instance

left3 - Function to execute if this Either4 is a Left3 instance

right - Function to execute if this Either4 is a right instance

Returns:

Result of executed function

filter

com.aol.cyclops.control.Maybe<RT> filter(java.util.function.Predicate<? super RT> test)

Filter this Either4 resulting in a Maybe#none if it is not a Right instance or if the predicate does not hold. Otherwise results in a Maybe containing the current value

Specified by:

filter in interface com.aol.cyclops.types.Filterable<RT>

Specified by:

filter in interface com.aol.cyclops.types.MonadicValue<RT>

Parameters:

test - Predicate to apply to filter this Either4

Returns:

Maybe containing the current value if this is a Right instance and the predicate holds, otherwise Maybe#none

flatMap

<RT1> Either4<LT1,LT2,LT3,RT1> flatMap(java.util.function.Function<? super RT,? extends com.aol.cyclops.types.MonadicValue<? extends RT1>> mapper)

Flattening transformation on this Either4. Contains an internal trampoline so will convert tail-recursive calls to iteration.

Specified by:

flatMap in interface com.aol.cyclops.types.MonadicValue<RT>

Parameters:

mapper - Mapping function

Returns:

Mapped Either4

swap3

Either4<LT1,LT2,RT,LT3> swap3()

Returns:

Swap the third and the right types

swap2

Either4<LT1,RT,LT3,LT2> swap2()

Returns:

Swap the second and the right types

swap1

Either4<RT,LT2,LT3,LT1> swap1()

Returns:

Swap the right and left types

isRight

boolean isRight()

Returns:

True if this either contains the right type

isLeft1

boolean isLeft1()

Returns:

True if this either contains the left1 type

isLeft2

boolean isLeft2()

Returns:

True if this either contains the left2 type

isLeft3

boolean isLeft3()

Returns:

True if this either contains the left3 type

ofType

default <U> com.aol.cyclops.control.Maybe<U> ofType(java.lang.Class<? extends U> type)

Specified by:

ofType in interface com.aol.cyclops.types.Filterable<RT>

filterNot

default com.aol.cyclops.control.Maybe<RT> filterNot(java.util.function.Predicate<? super RT> predicate)

Specified by:

filterNot in interface com.aol.cyclops.types.Filterable<RT>

notNull

default com.aol.cyclops.control.Maybe<RT> notNull()

Specified by:

notNull in interface com.aol.cyclops.types.Filterable<RT>

bimap

<R1,R2> Either4<LT1,LT2,R1,R2> bimap(java.util.function.Function<? super LT3,? extends R1> fn1,
                                     java.util.function.Function<? super RT,? extends R2> fn2)

Specified by:

bimap in interface com.aol.cyclops.types.BiFunctor<LT3,RT>

map

<R> Either4<LT1,LT2,LT3,R> map(java.util.function.Function<? super RT,? extends R> fn)

Specified by:

map in interface com.aol.cyclops.types.ConvertableFunctor<RT>

Specified by:

map in interface com.aol.cyclops.types.Functor<RT>

Specified by:

map in interface com.aol.cyclops.types.MonadicValue<RT>

toIor

default com.aol.cyclops.control.Ior<LT1,RT> toIor()

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

Specified by:

toIor in interface com.aol.cyclops.types.Value<RT>

Returns:

new Ior

toXor

default com.aol.cyclops.control.Xor<LT1,RT> toXor()

Specified by:

toXor in interface com.aol.cyclops.types.Value<RT>

coflatMap

default <R> Either4<LT1,LT2,LT3,R> coflatMap(java.util.function.Function<? super com.aol.cyclops.types.MonadicValue<RT>,R> mapper)

Specified by:

coflatMap in interface com.aol.cyclops.types.MonadicValue<RT>

nest

default Either4<LT1,LT2,LT3,com.aol.cyclops.types.MonadicValue<RT>> nest()

Specified by:

nest in interface com.aol.cyclops.types.MonadicValue<RT>

forEach4

default <T2,R1,R2,R3,R> Either4<LT1,LT2,LT3,R> forEach4(java.util.function.Function<? super RT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1,
                                                        java.util.function.BiFunction<? super RT,? super R1,? extends com.aol.cyclops.types.MonadicValue<R2>> value2,
                                                        com.aol.cyclops.util.function.TriFunction<? super RT,? super R1,? super R2,? extends com.aol.cyclops.types.MonadicValue<R3>> value3,
                                                        com.aol.cyclops.util.function.QuadFunction<? super RT,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Specified by:

forEach4 in interface com.aol.cyclops.types.MonadicValue<RT>

forEach4

default <T2,R1,R2,R3,R> Either4<LT1,LT2,LT3,R> forEach4(java.util.function.Function<? super RT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1,
                                                        java.util.function.BiFunction<? super RT,? super R1,? extends com.aol.cyclops.types.MonadicValue<R2>> value2,
                                                        com.aol.cyclops.util.function.TriFunction<? super RT,? super R1,? super R2,? extends com.aol.cyclops.types.MonadicValue<R3>> value3,
                                                        com.aol.cyclops.util.function.QuadFunction<? super RT,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
                                                        com.aol.cyclops.util.function.QuadFunction<? super RT,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Specified by:

forEach4 in interface com.aol.cyclops.types.MonadicValue<RT>

forEach3

default <T2,R1,R2,R> Either4<LT1,LT2,LT3,R> forEach3(java.util.function.Function<? super RT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1,
                                                     java.util.function.BiFunction<? super RT,? super R1,? extends com.aol.cyclops.types.MonadicValue<R2>> value2,
                                                     com.aol.cyclops.util.function.TriFunction<? super RT,? super R1,? super R2,? extends R> yieldingFunction)

Specified by:

forEach3 in interface com.aol.cyclops.types.MonadicValue<RT>

forEach3

default <T2,R1,R2,R> Either4<LT1,LT2,LT3,R> forEach3(java.util.function.Function<? super RT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1,
                                                     java.util.function.BiFunction<? super RT,? super R1,? extends com.aol.cyclops.types.MonadicValue<R2>> value2,
                                                     com.aol.cyclops.util.function.TriFunction<? super RT,? super R1,? super R2,java.lang.Boolean> filterFunction,
                                                     com.aol.cyclops.util.function.TriFunction<? super RT,? super R1,? super R2,? extends R> yieldingFunction)

Specified by:

forEach3 in interface com.aol.cyclops.types.MonadicValue<RT>

forEach2

default <R1,R> Either4<LT1,LT2,LT3,R> forEach2(java.util.function.Function<? super RT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1,
                                               java.util.function.BiFunction<? super RT,? super R1,? extends R> yieldingFunction)

Specified by:

forEach2 in interface com.aol.cyclops.types.MonadicValue<RT>

forEach2

default <R1,R> Either4<LT1,LT2,LT3,R> forEach2(java.util.function.Function<? super RT,? extends com.aol.cyclops.types.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)

Specified by:

forEach2 in interface com.aol.cyclops.types.MonadicValue<RT>

combineEager

default Either4<LT1,LT2,LT3,RT> combineEager(com.aol.cyclops.Monoid<RT> monoid,
                                             com.aol.cyclops.types.MonadicValue<? extends RT> v2)

Specified by:

combineEager in interface com.aol.cyclops.types.MonadicValue<RT>

combine

default <T2,R> Either4<LT1,LT2,LT3,R> combine(com.aol.cyclops.types.Value<? extends T2> app,
                                              java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)

Specified by:

combine in interface com.aol.cyclops.types.Combiner<RT>

combine

default Either4<LT1,LT2,LT3,RT> combine(java.util.function.BinaryOperator<com.aol.cyclops.types.Combiner<RT>> combiner,
                                        com.aol.cyclops.types.Combiner<RT> app)

Specified by:

combine in interface com.aol.cyclops.types.Combiner<RT>

zip

default <U,R> Either4<LT1,LT2,LT3,R> zip(org.jooq.lambda.Seq<? extends U> other,
                                         java.util.function.BiFunction<? super RT,? super U,? extends R> zipper)

Specified by:

zip in interface com.aol.cyclops.types.Zippable<RT>

zip

default <U,R> Either4<LT1,LT2,LT3,R> zip(java.util.stream.Stream<? extends U> other,
                                         java.util.function.BiFunction<? super RT,? super U,? extends R> zipper)

Specified by:

zip in interface com.aol.cyclops.types.Zippable<RT>

zip

default <U> Either4<LT1,LT2,LT3,org.jooq.lambda.tuple.Tuple2<RT,U>> zip(java.util.stream.Stream<? extends U> other)

Specified by:

zip in interface com.aol.cyclops.types.Zippable<RT>

zip

default <U> Either4<LT1,LT2,LT3,org.jooq.lambda.tuple.Tuple2<RT,U>> zip(org.jooq.lambda.Seq<? extends U> other)

Specified by:

zip in interface com.aol.cyclops.types.Zippable<RT>

zip

default <U> Either4<LT1,LT2,LT3,org.jooq.lambda.tuple.Tuple2<RT,U>> zip(java.lang.Iterable<? extends U> other)

Specified by:

zip in interface com.aol.cyclops.types.Zippable<RT>

unit

<T> Either4<LT1,LT2,LT3,T> unit(T unit)

Specified by:

unit in interface com.aol.cyclops.types.MonadicValue<RT>

Specified by:

unit in interface com.aol.cyclops.types.Unit<RT>

zip

default <T2,R> Either4<LT1,LT2,LT3,R> zip(java.lang.Iterable<? extends T2> app,
                                          java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)

Specified by:

zip in interface com.aol.cyclops.types.applicative.ApplicativeFunctor<RT>

Specified by:

zip in interface com.aol.cyclops.types.Zippable<RT>

zip

default <T2,R> Either4<LT1,LT2,LT3,R> zip(java.util.function.BiFunction<? super RT,? super T2,? extends R> fn,
                                          org.reactivestreams.Publisher<? extends T2> app)

Specified by:

zip in interface com.aol.cyclops.types.applicative.ApplicativeFunctor<RT>

Specified by:

zip in interface com.aol.cyclops.types.Zippable<RT>

bipeek

default Either4<LT1,LT2,LT3,RT> bipeek(java.util.function.Consumer<? super LT3> c1,
                                       java.util.function.Consumer<? super RT> c2)

Specified by:

bipeek in interface com.aol.cyclops.types.BiFunctor<LT3,RT>

bicast

default <U1,U2> Either4<LT1,LT2,U1,U2> bicast(java.lang.Class<U1> type1,
                                              java.lang.Class<U2> type2)

Specified by:

bicast in interface com.aol.cyclops.types.BiFunctor<LT3,RT>

bitrampoline

default <R1,R2> Either4<LT1,LT2,R1,R2> bitrampoline(java.util.function.Function<? super LT3,? extends com.aol.cyclops.control.Trampoline<? extends R1>> mapper1,
                                                    java.util.function.Function<? super RT,? extends com.aol.cyclops.control.Trampoline<? extends R2>> mapper2)

Specified by:

bitrampoline in interface com.aol.cyclops.types.BiFunctor<LT3,RT>

cast

default <U> Either4<LT1,LT2,LT3,U> cast(java.lang.Class<? extends U> type)

Specified by:

cast in interface com.aol.cyclops.types.Functor<RT>

peek

default Either4<LT1,LT2,LT3,RT> peek(java.util.function.Consumer<? super RT> c)

Specified by:

peek in interface com.aol.cyclops.types.Functor<RT>

trampoline

default <R> Either4<LT1,LT2,LT3,R> trampoline(java.util.function.Function<? super RT,? extends com.aol.cyclops.control.Trampoline<? extends R>> mapper)

Specified by:

trampoline in interface com.aol.cyclops.types.Functor<RT>

patternMatch

default <R> Either4<LT1,LT2,LT3,R> patternMatch(java.util.function.Function<com.aol.cyclops.control.Matchable.CheckValue1<RT,R>,com.aol.cyclops.control.Matchable.CheckValue1<RT,R>> case1,
                                                java.util.function.Supplier<? extends R> otherwise)

Specified by:

patternMatch in interface com.aol.cyclops.types.Functor<RT>