Either (cyclops-react 2.0.0-MI1 API)

Type Parameters:

ST - Left type

PT - Right type

All Superinterfaces:

BiFunctor<ST,PT>, Convertable<PT>, ConvertableToReactiveSeq<PT>, Filters<PT>, Fn0<PT>, Folds<PT>, org.jooq.lambda.function.Function0<PT>, java.lang.Iterable<PT>, MonadicValue<PT>, java.util.function.Predicate<PT>, org.reactivestreams.Publisher<PT>, java.util.function.Supplier<PT>, To<Xor<ST,PT>>, ToStream<PT>, Transformable<PT>, Unit<PT>, Value<PT>, Visitable<PT>, Xor<ST,PT>, Zippable<PT>

All Known Implementing Classes:

Either.Lazy, Either.Left, Either.Right
```
public interface Either<ST,PT>
extends Xor<ST,PT>
```
A totally Lazy Either implementation with tail call optimization for map and flatMap operators. 'Right' (or primary type) biased disjunct union. Often called Either, but in a generics heavy Java world Either is half the length of Either. 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, either 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.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.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.Convertable
 Convertable.SupplierToConvertable<T>
- Nested classes/interfaces inherited from interface cyclops.function.Fn0
 Fn0.FunctionalOperations<R>, Fn0.Instances, Fn0.SupplierKind<R>

Nested Classes
Modifier and Type	Interface and Description
`static class`	`Either.Lazy<ST,PT>`
`static class`	`Either.Left<ST,PT>`
`static class`	`Either.Right<ST,PT>`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
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,PT>`	`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)`
`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 ST,? extends R1> secondary, java.util.function.Function<? super PT,? extends R2> primary)` Transform this BiFunctor, changing two value types at once.
`default Either<ST,PT>`	`bipeek(java.util.function.Consumer<? super ST> c1, java.util.function.Consumer<? super PT> 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 ST,? extends Trampoline<? extends R1>> mapper1, java.util.function.Function<? super PT,? extends Trampoline<? extends R2>> mapper2)` Perform a tail-call optimized recursive transformation operation across two data points simultaneously
`default <U> Either<ST,U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`default <R> Either<ST,R>`	`coflatMap(java.util.function.Function<? super MonadicValue<PT>,R> mapper)` Perform a coflatMap operation.
`default <T2,R> Either<ST,R>`	`combine(Either<? extends ST,? extends T2> app, java.util.function.BinaryOperator<ST> semigroup, java.util.function.BiFunction<? super PT,? 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<ST,R>`	`combine(Value<? extends T2> app, java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)` Lazily combine this ApplicativeFunctor with the supplied value via the supplied BiFunction Example
`default <T2,R> Either<ST,R>`	`combine(Xor<? extends ST,? extends T2> app, java.util.function.BinaryOperator<ST> semigroup, java.util.function.BiFunction<? super PT,? 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<ST,PT>`	`combineEager(Monoid<PT> monoid, MonadicValue<? extends PT> v2)` Eagerly combine two MonadicValues using the supplied monoid (@see ApplicativeFunctor for type appropraite i.e.
`default <T2,R> Either<PStackX<ST>,R>`	`combineToList(Either<ST,? extends T2> app, java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)` Accumulate secondarys into a PStackX (extended Persistent List) and Right with the supplied combiner function Right accumulation only occurs if all phases are primary
`default <T2,R> Either<PStackX<ST>,R>`	`combineToList(Xor<ST,? extends T2> app, java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)` Accumulate secondarys into a PStackX (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)
`Either<ST,PT>`	`filter(java.util.function.Predicate<? super PT> test)` Keep only elements for which the supplied predicates hold e.g.
`default Either<ST,PT>`	`filterNot(java.util.function.Predicate<? super PT> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<RT1> Either<ST,RT1>`	`flatMap(java.util.function.Function<? super PT,? extends MonadicValue<? extends RT1>> mapper)` A flattening transformation operation (@see `Optional.flatMap(Function)`
`default <R> Either<ST,R>`	`flatMapI(java.util.function.Function<? super PT,? extends java.lang.Iterable<? extends R>> mapper)` A flattening transformation operation that takes the first value from the returned Iterable.
`default <R> Either<ST,R>`	`flatMapP(java.util.function.Function<? super PT,? extends org.reactivestreams.Publisher<? extends R>> mapper)` A flattening transformation operation that takes the first value from the returned Publisher.
`default <R> Either<ST,R>`	`flatMapS(java.util.function.Function<? super PT,? extends java.util.stream.Stream<? extends R>> mapper)`
`default <R1,R> Either<ST,R>`	`forEach2(java.util.function.Function<? super PT,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super PT,? super R1,? extends R> yieldingFunction)` Perform a two level nested internal iteration over this MonadicValue and the supplied MonadicValue
`default <R1,R> Either<ST,R>`	`forEach2(java.util.function.Function<? super PT,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super PT,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super PT,? super R1,? extends R> yieldingFunction)` Perform a two level nested internal iteration over this MonadicValue and the supplied stream
`default <T2,R1,R2,R> Either<ST,R>`	`forEach3(java.util.function.Function<? super PT,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super PT,? super R1,? extends MonadicValue<R2>> value2, Fn3<? super PT,? 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<ST,R>`	`forEach3(java.util.function.Function<? super PT,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super PT,? super R1,? extends MonadicValue<R2>> value2, Fn3<? super PT,? super R1,? super R2,java.lang.Boolean> filterFunction, Fn3<? super PT,? 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<ST,R>`	`forEach4(java.util.function.Function<? super PT,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super PT,? super R1,? extends MonadicValue<R2>> value2, Fn3<? super PT,? super R1,? super R2,? extends MonadicValue<R3>> value3, Fn4<? super PT,? 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<ST,R>`	`forEach4(java.util.function.Function<? super PT,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super PT,? super R1,? extends MonadicValue<R2>> value2, Fn3<? super PT,? super R1,? super R2,? extends MonadicValue<R3>> value3, Fn4<? super PT,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, Fn4<? super PT,? 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 <ST,T> Either<ST,T>`	`fromIterable(java.lang.Iterable<T> iterable)` Construct a Right Either from the supplied Iterable
`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)`
`PT`	`get()` Apply this function to the arguments.
`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<PStackX<ST>,PT>`	`list()`
`<R> Either<ST,R>`	`map(java.util.function.Function<? super PT,? extends R> fn)` Transform this functor using the supplied transformation function
`default <R1,R2> Either<R1,R2>`	`mapBoth(java.util.function.Function<? super ST,? extends R1> secondary, java.util.function.Function<? super PT,? extends R2> primary)` Deprecated.
`static <ST,PT> Either<ST,PT>`	`narrow(Either<? extends ST,? extends PT> broad)`
`default Either<ST,MonadicValue<PT>>`	`nest()` cojoin pattern.
`default Either<ST,PT>`	`notNull()` Filter elements retaining only values which are not null
`default <U> Either<ST,U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`Either<ST,PT>`	`peek(java.util.function.Consumer<? super PT> action)` Peek at the current value of this Transformable, without transforming it
`void`	`peek(java.util.function.Consumer<? super ST> stAction, java.util.function.Consumer<? super PT> ptAction)` Deprecated.
`default <R> Either<ST,R>`	`retry(java.util.function.Function<? super PT,? extends R> fn)` Retry a transformation if it fails.
`default <R> Either<ST,R>`	`retry(java.util.function.Function<? super PT,? 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,PT>`	`secondaryFlatMap(java.util.function.Function<? super ST,? extends Xor<LT1,PT>> mapper)` Perform a flatMap operation on the Left type
`ST`	`secondaryGet()`
`<R> Either<R,PT>`	`secondaryMap(java.util.function.Function<? super ST,? extends R> fn)` Always map the Left type of this Either if it is present using the provided transformation function
`Either<ST,PT>`	`secondaryPeek(java.util.function.Consumer<? super ST> action)` Peek at the Left type value if present
`java.util.Optional<ST>`	`secondaryToOptional()`
`Either<ST,PT>`	`secondaryToPrimayFlatMap(java.util.function.Function<? super ST,? extends Xor<ST,PT>> fn)` A flatMap operation that keeps the Left and Right types the same
`Either<ST,PT>`	`secondaryToPrimayMap(java.util.function.Function<? super ST,? extends PT> fn)` If this Either contains the Left type, map it's value so that it contains the Right type
`ReactiveSeq<ST>`	`secondaryToStream()`
`Value<ST>`	`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 collection of Eithers into a single Either with Lists of values.
`Either<PT,ST>`	`swap()` Swap types so operations directly affect the current (pre-swap) Left type
`Ior<ST,PT>`	`toIor()` Return an Ior that can be this object or a Ior.primary or Ior.secondary
`default java.util.Optional<PT>`	`toOptional()`
`default Xor<ST,PT>`	`toXor()`
`default <ST2> Xor<ST2,PT>`	`toXor(ST2 secondary)` Convert to an Xor where the secondary value will be used if no primary value is present
`default <R> Either<ST,R>`	`trampoline(java.util.function.Function<? super PT,? 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)` Traverse a Collection of Either producting an Either3 with a ListX, applying the transformation function to every element in the list
`default <T> Either<ST,T>`	`unit(T unit)`
`<R> R`	`visit(java.util.function.Function<? super ST,? extends R> secondary, java.util.function.Function<? super PT,? 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<ST,PT>`	`zip(java.util.function.BinaryOperator<Zippable<PT>> combiner, Zippable<PT> app)` Combine two applicatives together using the provided BinaryOperator (Semigroup, Monoid and Reducer all extend BinaryOperator - checkout Semigroups and Monoids for a large number of canned combinations).
`default <T2,R> Either<ST,R>`	`zip(java.lang.Iterable<? extends T2> app, java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)` Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
`default <U> Either<ST,org.jooq.lambda.tuple.Tuple2<PT,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<ST,org.jooq.lambda.tuple.Tuple3<PT,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<ST,R>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third, Fn3<? super PT,? super S,? super U,? extends R> fn3)`
`default <T2,T3,T4> Either<ST,org.jooq.lambda.tuple.Tuple4<PT,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<ST,R>`	`zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth, Fn4<? super PT,? super T2,? super T3,? super T4,? extends R> fn)`
`default <T2,R> Either<ST,R>`	`zipP(org.reactivestreams.Publisher<? extends T2> app, java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)` Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
`default <U> Either<ST,org.jooq.lambda.tuple.Tuple2<PT,U>>`	`zipP(org.reactivestreams.Publisher<? extends U> other)`
`default <U> Either<ST,org.jooq.lambda.tuple.Tuple2<PT,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<ST,R>`	`zipS(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super PT,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
`default <R> Either<ST,R>`	`zipWith(java.lang.Iterable<java.util.function.Function<? super PT,? extends R>> fn)`
`default <R> Either<ST,R>`	`zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super PT,? extends R>> fn)`
`default <R> Either<ST,R>`	`zipWithS(java.util.stream.Stream<java.util.function.Function<? super PT,? extends R>> fn)`

Methods inherited from interface cyclops.control.Xor
accumulatePrimary, accumulatePrimary, accumulatePrimary, accumulateSecondary, accumulateSecondary, accumulateSecondary, anyM, applyAny, consumeAny, primary, secondary, sequencePrimary, sequenceSecondary, visitAny, visitAny

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

Methods inherited from interface com.aol.cyclops2.types.Value
apply, generate, iterate, iterator, mkString, newSubscriber, of, stream, subscribe, test, toEvalAlways, toEvalLater, toEvalNow, toMaybe, toTry, toTry, toTry

Methods inherited from interface com.aol.cyclops2.types.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, singleOptional, startsWith, startsWithIterable, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, xMatch

Methods inherited from interface com.aol.cyclops2.types.stream.ToStream
futureStream, getStreamable, isEmpty, jdkStream, reactiveSeq, reveresedJDKStream, reveresedStream

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Methods inherited from interface com.aol.cyclops2.types.Convertable
collect, fromSupplier, orElse, orElseGet, orElseThrow, toCompletableFuture, toCompletableFutureAsync, toCompletableFutureAsync, toFuture, toFutureWAsync, toFutureWAsync, toStream, visit

Methods inherited from interface cyclops.function.Fn0
andThen, fnTo, functionOps, lift, lift, liftF, liftOpt, liftTry, memoize, memoize, run, suspend, λ, λv

Methods inherited from interface org.jooq.lambda.function.Function0
apply, from, toSupplier

Methods inherited from interface java.util.function.Predicate
and, isEqual, negate, or

- Method Detail
 - fromMonadicValue
```
static <LT1,RT> Either<LT1,RT> fromMonadicValue(MonadicValue<RT> mv2)
```
 - fromXor
```
static <ST,PT> Either<ST,PT> fromXor(Xor<ST,PT> xor)
```
 - sequenceRight
```
static <LT1,PT> Either<ListX<LT1>,ListX<PT>> sequenceRight(CollectionX<Either<LT1,PT>> xors)
```
 Turn a collection of Eithers into a single Either with Lists of values.
```
 
 
 Either<String,Integer> just = Either.right(10);
 Either<String,Integer> none = Either.left("none");
 
 
 Either<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)
```
 Traverse 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 apply 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)
```
 - forEach4
```
default <T2,R1,R2,R3,R> Either<ST,R> forEach4(java.util.function.Function<? super PT,? extends MonadicValue<R1>> value1,
 java.util.function.BiFunction<? super PT,? super R1,? extends MonadicValue<R2>> value2,
 Fn3<? super PT,? super R1,? super R2,? extends MonadicValue<R3>> value3,
 Fn4<? super PT,? 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<PT>
 
 Specified by:
 
 forEach4 in interface Xor<ST,PT>
 
 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<ST,R> forEach4(java.util.function.Function<? super PT,? extends MonadicValue<R1>> value1,
 java.util.function.BiFunction<? super PT,? super R1,? extends MonadicValue<R2>> value2,
 Fn3<? super PT,? super R1,? super R2,? extends MonadicValue<R3>> value3,
 Fn4<? super PT,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
 Fn4<? super PT,? 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<PT>
 
 Specified by:
 
 forEach4 in interface Xor<ST,PT>
 
 Parameters:
 
 value1 - Nested MonadicValue to iterate over
 
 value2 - Nested MonadicValue to iterate over
 
 value3 - Nested MonadicValue to iterate over
 
 filterFunction - Filter to apply 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<ST,R> forEach3(java.util.function.Function<? super PT,? extends MonadicValue<R1>> value1,
 java.util.function.BiFunction<? super PT,? super R1,? extends MonadicValue<R2>> value2,
 Fn3<? super PT,? 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<PT>
 
 Specified by:
 
 forEach3 in interface Xor<ST,PT>
 
 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<ST,R> forEach3(java.util.function.Function<? super PT,? extends MonadicValue<R1>> value1,
 java.util.function.BiFunction<? super PT,? super R1,? extends MonadicValue<R2>> value2,
 Fn3<? super PT,? super R1,? super R2,java.lang.Boolean> filterFunction,
 Fn3<? super PT,? 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<PT>
 
 Specified by:
 
 forEach3 in interface Xor<ST,PT>
 
 Parameters:
 
 value1 - Nested MonadicValue to iterate over
 
 value2 - Nested MonadicValue to iterate over
 
 filterFunction - Filter to apply 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<ST,R> forEach2(java.util.function.Function<? super PT,? extends MonadicValue<R1>> value1,
 java.util.function.BiFunction<? super PT,? 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<PT>
 
 Specified by:
 
 forEach2 in interface Xor<ST,PT>
 
 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<ST,R> forEach2(java.util.function.Function<? super PT,? extends MonadicValue<R1>> value1,
 java.util.function.BiFunction<? super PT,? super R1,java.lang.Boolean> filterFunction,
 java.util.function.BiFunction<? super PT,? super R1,? extends R> yieldingFunction)
```
 Description copied from interface: MonadicValue
 Perform a two level nested internal iteration over this MonadicValue and the supplied stream
```
 
 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<PT>
 
 Specified by:
 
 forEach2 in interface Xor<ST,PT>
 
 filterFunction - Filter to apply 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<PStackX<ST>,R> combineToList(Xor<ST,? extends T2> app,
 java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)
```
 Description copied from interface: Xor
 
 Accumulate secondarys into a PStackX (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<ST,PT>
 
 Parameters:
 
 app - Value to combine with
 
 fn - Combiner function for primary values
 
 Returns:
 
 Combined Xor
 - combine
```
default <T2,R> Either<ST,R> combine(Xor<? extends ST,? extends T2> app,
 java.util.function.BinaryOperator<ST> semigroup,
 java.util.function.BiFunction<? super PT,? 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<PStackX<String>,String> result = fail1.list().combine(Xor.secondary("failed2").list(), Semigroups.collectionConcat(),(a,b)->a+b);
 
 //Secondary of [PStackX.of("failed1","failed2")))]
 
 
```
 Specified by:
 
 combine in interface Xor<ST,PT>
 
 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> stream = ReactiveSeq.of(1,2,3);
 
 Either<Throwable,Integer> future = Either.fromPublisher(stream);
 
 //Either[1]
 
 
 
```
 Specified by:
 
 fromPublisher in interface Xor<ST,PT>
 
 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<ST,PT>
 
 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,PT> anyMEither()
```
 - zip
```
default Either<ST,PT> zip(java.util.function.BinaryOperator<Zippable<PT>> combiner,
 Zippable<PT> app)
```
 Description copied from interface: Zippable
 
 Combine two applicatives together using the provided BinaryOperator (Semigroup, Monoid and Reducer all extend BinaryOperator - checkout Semigroups 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<ST,PT>
 
 Specified by:
 
 zip in interface Zippable<PT>
 
 Returns:
 
 See Also:
 Semigroup, Semigroups, Monoid, To lift any Semigroup (or monoid) up to handling Applicatives use the combineApplicatives operator in Semigroups {@see com.aol.cyclops2.Semigroups#combineApplicatives(BiFunction) } or Monoids { {@see com.aol.cyclops2.Monoids#combineApplicatives(java.util.function.Function, com.aol.cyclops2.function.Monoid) } {@code BinaryOperator> sumMaybes = Semigroups.combineScalarFunctors(Semigroups.intSum); Maybe.just(1).zip(sumMaybes, Maybe.just(5)) //Maybe.just(6)); }
 - flatMapI
```
default <R> Either<ST,R> flatMapI(java.util.function.Function<? super PT,? 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<PT>
 
 Specified by:
 
 flatMapI in interface Xor<ST,PT>
 
 Parameters:
 
 mapper - transformation function
 
 Returns:
 
 MonadicValue
 - flatMapP
```
default <R> Either<ST,R> flatMapP(java.util.function.Function<? super PT,? 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.
```
 
 FutureW.ofResult(1).map(i->i+2).flatMapP(i->Flux.just(()->i*3,20);
 //FutureW[9]
 
 
```
 Specified by:
 
 flatMapP in interface MonadicValue<PT>
 
 Specified by:
 
 flatMapP in interface Xor<ST,PT>
 
 Parameters:
 
 mapper - transformation function
 
 Returns:
 
 MonadicValue
 - coflatMap
```
default <R> Either<ST,R> coflatMap(java.util.function.Function<? super MonadicValue<PT>,R> mapper)
```
 Description copied from interface: MonadicValue
 Perform a coflatMap operation. The mapping function accepts this MonadicValue and returns a single value to be wrapped inside a Monad.
```
 
 Maybe.none().coflatMap(m -> m.isPresent() ? m.get() : 10);
 //Maybe[10]
 
 
```
 Specified by:
 
 coflatMap in interface MonadicValue<PT>
 
 Specified by:
 
 coflatMap in interface Xor<ST,PT>
 
 Parameters:
 
 mapper - Mapping / transformation function
 
 Returns:
 
 MonadicValue wrapping return value from transformation function applied to the value inside this MonadicValue
 - nest
```
default Either<ST,MonadicValue<PT>> nest()
```
 Description copied from interface: MonadicValue
 
 cojoin pattern. Nests this Monad inside another.
 
 Specified by:
 
 nest in interface MonadicValue<PT>
 
 Specified by:
 
 nest in interface Xor<ST,PT>
 
 Returns:
 
 Nested Monad
 - combineEager
```
default Either<ST,PT> combineEager(Monoid<PT> monoid,
 MonadicValue<? extends PT> v2)
```
 Description copied from interface: MonadicValue
 Eagerly combine two MonadicValues using the supplied monoid (@see ApplicativeFunctor for type appropraite i.e. lazy / async alternatives)
```
 
 
 Monoid<Integer> add = Monoid.of(1,Semigroups.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 , Semigroups.firstNonNull());
 Maybe.of(10).combineEager(firstNonNull,Maybe.of(10));
 //Maybe[10]
 
```
 Specified by:
 
 combineEager in interface MonadicValue<PT>
 
 Specified by:
 
 combineEager in interface Xor<ST,PT>
 
 Returns:
 - unit
```
default <T> Either<ST,T> unit(T unit)
```
 Specified by:
 
 unit in interface MonadicValue<PT>
 
 Specified by:
 
 unit in interface Unit<PT>
 
 Specified by:
 
 unit in interface Xor<ST,PT>
 - toOptional
```
default java.util.Optional<PT> toOptional()
```
 Specified by:
 
 toOptional in interface Convertable<PT>
 
 Specified by:
 
 toOptional in interface Xor<ST,PT>
 
 Returns:
 
 Optional that wraps contained value, Optional.empty if value is null
 - filter
```
Either<ST,PT> filter(java.util.function.Predicate<? super PT> 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<PT>
 
 Specified by:
 
 filter in interface MonadicValue<PT>
 
 Specified by:
 
 filter in interface Xor<ST,PT>
 
 Parameters:
 
 test - to filter elements by, retaining matches
 
 Returns:
 
 Filters with elements removed where the predicate does not hold
 - secondaryToPrimayMap
```
Either<ST,PT> secondaryToPrimayMap(java.util.function.Function<? super ST,? extends PT> 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<ST,PT>
 
 Parameters:
 
 fn - Function to map secondary type to primary
 
 Returns:
 
 Either with secondary type mapped to primary
 - secondaryMap
```
<R> Either<R,PT> secondaryMap(java.util.function.Function<? super ST,? 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<ST,PT>
 
 Parameters:
 
 fn - Transformation function for Left types
 
 Returns:
 
 Either with Left type transformed
 - map
```
<R> Either<ST,R> map(java.util.function.Function<? super PT,? 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<PT>
 
 Specified by:
 
 map in interface Transformable<PT>
 
 Specified by:
 
 map in interface Xor<ST,PT>
 
 Parameters:
 
 fn - Transformation function
 
 Returns:
 
 Transformed Transformable
 - secondaryPeek
```
Either<ST,PT> secondaryPeek(java.util.function.Consumer<? super ST> action)
```
 Peek at the Left type value if present
 
 Specified by:
 
 secondaryPeek in interface Xor<ST,PT>
 
 Parameters:
 
 action - Consumer to peek at the Left type value
 
 Returns:
 
 Either with the same values as before
 - peek
```
Either<ST,PT> peek(java.util.function.Consumer<? super PT> 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<PT>
 
 Specified by:
 
 peek in interface Xor<ST,PT>
 
 Parameters:
 
 action - Consumer that recieves each element from this Transformable
 
 Returns:
 
 Transformable that will peek at each value
 - zipWith
```
default <R> Either<ST,R> zipWith(java.lang.Iterable<java.util.function.Function<? super PT,? extends R>> fn)
```
 Specified by:
 
 zipWith in interface Xor<ST,PT>
 
 Specified by:
 
 zipWith in interface Zippable<PT>
 - zipWithS
```
default <R> Either<ST,R> zipWithS(java.util.stream.Stream<java.util.function.Function<? super PT,? extends R>> fn)
```
 Specified by:
 
 zipWithS in interface Xor<ST,PT>
 
 Specified by:
 
 zipWithS in interface Zippable<PT>
 - zipWithP
```
default <R> Either<ST,R> zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super PT,? extends R>> fn)
```
 Specified by:
 
 zipWithP in interface Xor<ST,PT>
 
 Specified by:
 
 zipWithP in interface Zippable<PT>
 - retry
```
default <R> Either<ST,R> retry(java.util.function.Function<? super PT,? 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.apply(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<PT>
 
 Specified by:
 
 retry in interface Xor<ST,PT>
 
 Parameters:
 
 fn - Function to retry if fails
 - zipP
```
default  Either<ST,org.jooq.lambda.tuple.Tuple2<PT,U>> zipP(org.reactivestreams.Publisher<? extends U> other)
```
 Specified by:
 
 zipP in interface Xor<ST,PT>
 
 Specified by:
 
 zipP in interface Zippable<PT>
 - retry
```
default <R> Either<ST,R> retry(java.util.function.Function<? super PT,? 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.apply(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<PT>
 
 Specified by:
 
 retry in interface Xor<ST,PT>
 
 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<ST,org.jooq.lambda.tuple.Tuple3<PT,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(Collectors.toList());

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

 
```
 Specified by:
 
 zip3 in interface Xor<ST,PT>
 
 Specified by:
 
 zip3 in interface Zippable<PT>
 - zip3
```
default <S,U,R> Either<ST,R> zip3(java.lang.Iterable<? extends S> second,
 java.lang.Iterable<? extends U> third,
 Fn3<? super PT,? super S,? super U,? extends R> fn3)
```
 Specified by:
 
 zip3 in interface Xor<ST,PT>
 
 Specified by:
 
 zip3 in interface Zippable<PT>
 - zip4
```
default <T2,T3,T4> Either<ST,org.jooq.lambda.tuple.Tuple4<PT,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(Collectors.toList());

 
 // [[1,100,'a',"hello"],[2,200,'b',"world"]]
 
```
 Specified by:
 
 zip4 in interface Xor<ST,PT>
 
 Specified by:
 
 zip4 in interface Zippable<PT>
 - zip4
```
default <T2,T3,T4,R> Either<ST,R> zip4(java.lang.Iterable<? extends T2> second,
 java.lang.Iterable<? extends T3> third,
 java.lang.Iterable<? extends T4> fourth,
 Fn4<? super PT,? super T2,? super T3,? super T4,? extends R> fn)
```
 Specified by:
 
 zip4 in interface Xor<ST,PT>
 
 Specified by:
 
 zip4 in interface Zippable<PT>
 - flatMapS
```
default <R> Either<ST,R> flatMapS(java.util.function.Function<? super PT,? extends java.util.stream.Stream<? extends R>> mapper)
```
 Specified by:
 
 flatMapS in interface MonadicValue<PT>
 
 Specified by:
 
 flatMapS in interface Xor<ST,PT>
 - swap
```
Either<PT,ST> 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<ST,PT>
 
 Returns:
 
 Swap the primary and secondary types, allowing operations directly on what was the Left type
 - toIor
```
Ior<ST,PT> 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<PT>
 
 Specified by:
 
 toIor in interface Xor<ST,PT>
 
 Returns:
 
 new Ior
 - isPresent
```
default boolean isPresent()
```
 Specified by:
 
 isPresent in interface Convertable<PT>
 
 Specified by:
 
 isPresent in interface Xor<ST,PT>
 
 Returns:
 
 True if value exists and is non-null
 - toXor
```
default Xor<ST,PT> toXor()
```
 Specified by:
 
 toXor in interface Value<PT>
 
 Specified by:
 
 toXor in interface Xor<ST,PT>
 
 Returns:
 
 Primary Xor that has the same value as this Value
 - toXor
```
default <ST2> Xor<ST2,PT> 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<PT>
 
 Specified by:
 
 toXor in interface Xor<ST,PT>
 
 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 empty
 - isSecondary
```
default boolean isSecondary()
```
 Specified by:
 
 isSecondary in interface Xor<ST,PT>
 
 Returns:
 
 True if this is a secondary Xor
 - isPrimary
```
default boolean isPrimary()
```
 Specified by:
 
 isPrimary in interface Xor<ST,PT>
 
 Returns:
 
 True if this is a primary Xor
 - visit
```
<R> R visit(java.util.function.Function<? super ST,? extends R> secondary,
 java.util.function.Function<? super PT,? 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<ST,PT>
 
 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 ST,? extends R1> secondary,
 java.util.function.Function<? super PT,? extends R2> primary)
```
 Deprecated.
 
 Specified by:
 
 mapBoth in interface Xor<ST,PT>
 - bimap
```
default <R1,R2> Either<R1,R2> bimap(java.util.function.Function<? super ST,? extends R1> secondary,
 java.util.function.Function<? super PT,? extends R2> primary)
```
 Description copied from interface: BiFunctor
 Transform this BiFunctor, 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 BiFunctor<ST,PT>
 
 Specified by:
 
 bimap in interface Xor<ST,PT>
 
 Parameters:
 
 secondary - transformation function for the first type
 
 primary - transformation function for the second type
 
 Returns:
 
 New BiFunctor containing transformed data
 - bipeek
```
default Either<ST,PT> bipeek(java.util.function.Consumer<? super ST> c1,
 java.util.function.Consumer<? super PT> c2)
```
 Description copied from interface: BiFunctor
 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 BiFunctor<ST,PT>
 
 Specified by:
 
 bipeek in interface Xor<ST,PT>
 
 Parameters:
 
 c1 - consumer for the first type
 
 c2 - consumer for the second type
 
 Returns:
 
 New BiFunctor 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: BiFunctor
 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 BiFunctor<ST,PT>
 
 Specified by:
 
 bicast in interface Xor<ST,PT>
 
 Returns:
 - bitrampoline
```
default <R1,R2> Either<R1,R2> bitrampoline(java.util.function.Function<? super ST,? extends Trampoline<? extends R1>> mapper1,
 java.util.function.Function<? super PT,? extends Trampoline<? extends R2>> mapper2)
```
 Description copied from interface: BiFunctor
 
 Perform a tail-call optimized recursive transformation operation across two data points simultaneously
 
 Specified by:
 
 bitrampoline in interface BiFunctor<ST,PT>
 
 Specified by:
 
 bitrampoline in interface Xor<ST,PT>
 
 Parameters:
 
 mapper1 - transformation function for the first type
 
 mapper2 - transformation function for the second type
 
 Returns:
 
 New BiFunctor containing transformed data
 - get
```
PT get()
```
 Description copied from interface: org.jooq.lambda.function.Function0
 
 Apply this function to the arguments.
 
 Specified by:
 
 get in interface Convertable<PT>
 
 Specified by:
 
 get in interface org.jooq.lambda.function.Function0<PT>
 
 Specified by:
 
 get in interface java.util.function.Supplier<PT>
 
 Specified by:
 
 get in interface Xor<ST,PT>
 
 Returns:
 
 Contained value, maybe null
 - secondaryValue
```
Value<ST> secondaryValue()
```
 Specified by:
 
 secondaryValue in interface Xor<ST,PT>
 
 Returns:
 
 A Value containing the secondary Value if present
 - secondaryGet
```
ST secondaryGet()
```
 Specified by:
 
 secondaryGet in interface Xor<ST,PT>
 
 Returns:
 
 The Left Value if present, otherwise null
 - secondaryToOptional
```
java.util.Optional<ST> secondaryToOptional()
```
 Specified by:
 
 secondaryToOptional in interface Xor<ST,PT>
 
 Returns:
 
 The Left value wrapped in an Optional if present, otherwise an empty Optional
 - secondaryToStream
```
ReactiveSeq<ST> secondaryToStream()
```
 Specified by:
 
 secondaryToStream in interface Xor<ST,PT>
 
 Returns:
 
 A Stream containing the secondary value if present, otherwise an empty Stream
 - flatMap
```
<RT1> Either<ST,RT1> flatMap(java.util.function.Function<? super PT,? 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<PT>
 
 Specified by:
 
 flatMap in interface Xor<ST,PT>
 
 Parameters:
 
 mapper - transformation function
 
 Returns:
 
 MonadicValue
 - secondaryFlatMap
```
<LT1> Either<LT1,PT> secondaryFlatMap(java.util.function.Function<? super ST,? extends Xor<LT1,PT>> mapper)
```
 Perform a flatMap operation on the Left type
 
 Specified by:
 
 secondaryFlatMap in interface Xor<ST,PT>
 
 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<ST,PT> secondaryToPrimayFlatMap(java.util.function.Function<? super ST,? extends Xor<ST,PT>> fn)
```
 A flatMap operation that keeps the Left and Right types the same
 
 Specified by:
 
 secondaryToPrimayFlatMap in interface Xor<ST,PT>
 
 Parameters:
 
 fn - Transformation function
 
 Returns:
 
 Either
 - peek
```
@Deprecated
void peek(java.util.function.Consumer<? super ST> stAction,
 java.util.function.Consumer<? super PT> ptAction)
```
 Deprecated.
 
 Specified by:
 
 peek in interface Xor<ST,PT>
 - 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<ST,R> combine(Value<? extends T2> app,
 java.util.function.BiFunction<? super PT,? 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<PT>
 
 Specified by:
 
 combine in interface Xor<ST,PT>
 
 Parameters:
 
 app - Value to combine with this one.
 
 fn - BiFunction to combine them
 
 Returns:
 
 New Applicativefunctor that represents the combined values
 - list
```
default Either<PStackX<ST>,PT> list()
```
 Specified by:
 
 list in interface Xor<ST,PT>
 
 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<PStackX<ST>,R> combineToList(Either<ST,? extends T2> app,
 java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)
```
 Accumulate secondarys into a PStackX (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<ST,R> combine(Either<? extends ST,? extends T2> app,
 java.util.function.BinaryOperator<ST> semigroup,
 java.util.function.BiFunction<? super PT,? 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<PStackX<String>,String> result = fail1.list().combine(Either.left("failed2").list(), Semigroups.collectionConcat(),(a,b)->a+b);
 
 //Left of [PStackX.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<ST,R> zip(java.lang.Iterable<? extends T2> app,
 java.util.function.BiFunction<? super PT,? 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<PT>
 
 Specified by:
 
 zip in interface Xor<ST,PT>
 
 Specified by:
 
 zip in interface Zippable<PT>
 
 Parameters:
 
 app - to zip with
 
 fn - Zip function
 
 Returns:
 
 Combined zippable
 - zipP
```
default <T2,R> Either<ST,R> zipP(org.reactivestreams.Publisher<? extends T2> app,
 java.util.function.BiFunction<? super PT,? 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<PT>
 
 Specified by:
 
 zipP in interface Xor<ST,PT>
 
 Specified by:
 
 zipP in interface Zippable<PT>
 
 Parameters:
 
 app - to combine with
 
 fn - Zip / combining function
 
 Returns:
 
 Combined zippable
 - zipS
```
default <U,R> Either<ST,R> zipS(java.util.stream.Stream<? extends U> other,
 java.util.function.BiFunction<? super PT,? 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<ST,PT>
 
 Specified by:
 
 zipS in interface Zippable<PT>
 
 Parameters:
 
 other - Stream to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - zipS
```
default  Either<ST,org.jooq.lambda.tuple.Tuple2<PT,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<ST,PT>
 
 Specified by:
 
 zipS in interface Zippable<PT>
 
 Parameters:
 
 other - Stream to combine with
 
 Returns:
 
 Combined Zippable
 - zip
```
default  Either<ST,org.jooq.lambda.tuple.Tuple2<PT,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<ST,PT>
 
 Specified by:
 
 zip in interface Zippable<PT>
 
 Parameters:
 
 other - Iterable to combine with
 
 Returns:
 - ofType
```
default  Either<ST,U> ofType(java.lang.Class<? extends U> type)
```
 Description copied from interface: Filters
 Keep only those elements in a stream 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<PT>
 
 Specified by:
 
 ofType in interface Xor<ST,PT>
 - filterNot
```
default Either<ST,PT> filterNot(java.util.function.Predicate<? super PT> 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<PT>
 
 Specified by:
 
 filterNot in interface Xor<ST,PT>
 
 Parameters:
 
 fn - to filter elements by, retaining matches
 
 Returns:
 
 Filters with elements removed where the predicate does not hold
 - notNull
```
default Either<ST,PT> 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<PT>
 
 Specified by:
 
 notNull in interface Xor<ST,PT>
 
 Returns:
 
 Filters with nulls removed
 - cast
```
default  Either<ST,U> cast(java.lang.Class<? extends U> type)
```
 Description copied from interface: Transformable
 
 Cast all elements in a stream 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<PT>
 
 Specified by:
 
 cast in interface Xor<ST,PT>
 - trampoline
```
default <R> Either<ST,R> trampoline(java.util.function.Function<? super PT,? 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<PT>
 
 Specified by:
 
 trampoline in interface Xor<ST,PT>
 
 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)
```

Interface Either<ST,PT>

Nested Class Summary

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

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

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

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

Method Summary

Methods inherited from interface cyclops.control.Xor

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

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

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

Methods inherited from interface com.aol.cyclops2.types.stream.ToStream

Methods inherited from interface java.lang.Iterable

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

Methods inherited from interface cyclops.function.Fn0

Methods inherited from interface org.jooq.lambda.function.Function0

Methods inherited from interface java.util.function.Predicate

Method Detail

fromMonadicValue

fromXor

sequenceRight

sequenceLeft

traverseRight

traverseLeft

accumulate

rightEval

leftEval

consumeAny

applyAny

visitAny

visitAny

forEach4

forEach4

forEach3

forEach3

forEach2

forEach2

combineToList

combine

fromPublisher

fromIterable

left

right

anyMEither

zip

flatMapI

flatMapP

coflatMap

nest

combineEager

unit

toOptional

filter

secondaryToPrimayMap

secondaryMap

map

secondaryPeek

peek

zipWith

zipWithS

zipWithP

retry

zipP

retry

zip3

zip3

zip4

zip4

flatMapS

swap

toIor

isPresent

toXor

toXor

isSecondary

isPrimary

visit

mapBoth

bimap

bipeek