Xor (cyclops-reactor 8.4.2 API)

Type Parameters:

ST - Secondary type

PT - Primary type

All Superinterfaces:

ApplicativeFunctor<PT>, BiFunctor<ST,PT>, Combiner<PT>, Convertable<PT>, ConvertableFunctor<PT>, Filterable<PT>, Foldable<PT>, Functor<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>>, Unit<PT>, Value<PT>, Visitable<PT>, Zippable<PT>

All Known Implementing Classes:

Xor.Primary, Xor.Secondary
```
public interface Xor<ST,PT>
extends To<Xor<ST,PT>>, java.util.function.Supplier<PT>, MonadicValue<PT>, Functor<PT>, BiFunctor<ST,PT>, Filterable<PT>, ApplicativeFunctor<PT>
```
eXclusive Or (Xor) 'Right' (or primary type) biased disjunct union. Often called Either, but in a generics heavy Java world Xor is half the length of Either. No 'projections' are provided, swap() and secondaryXXXX alternative methods can be used instead. Xor 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{
 Xor team; 
 }
 
 Rather than
 
 public class Member{
```

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class Xor.Primary<ST,PT>

static class Xor.Secondary<ST,PT>
- Nested classes/interfaces inherited from interface com.aol.cyclops.types.applicative.ApplicativeFunctor
 ApplicativeFunctor.Applicatives, ApplicativeFunctor.ApplyFunctions<T>
- Nested classes/interfaces inherited from interface com.aol.cyclops.types.Value
 Value.ValueImpl<T>
- Nested classes/interfaces inherited from interface com.aol.cyclops.types.Convertable
 Convertable.SupplierToConvertable<T>

Nested Classes
Modifier and Type	Interface and Description
`static class`	`Xor.Primary<ST,PT>`
`static class`	`Xor.Secondary<ST,PT>`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`static <ST,PT,R> Xor<?,R>`	`accumulatePrimary(CollectionX<Xor<ST,PT>> xors, java.util.function.Function<? super PT,R> mapper, Monoid<R> reducer)` Accumulate the results only from those Iors which have a Primary type present, using the supplied mapping function to convert the data from each Xor before reducing them 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 <ST,PT,R> Xor<?,R>`	`accumulatePrimary(CollectionX<Xor<ST,PT>> xors, Reducer<R> reducer)` Accumulate the result of the Primary types in the Collection of Xors provided using the supplied Reducer `Reducers`.
`static <ST,PT> Xor<?,PT>`	`accumulatePrimary(Monoid<PT> reducer, CollectionX<Xor<ST,PT>> xors)` Accumulate the results only from those Xors which have a Primary 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 <ST,PT,R> Xor<?,R>`	`accumulateSecondary(CollectionX<Xor<ST,PT>> xors, java.util.function.Function<? super ST,R> mapper, Monoid<R> reducer)` Accumulate the results only from those Xors which have a Secondary type present, using the supplied mapping function to convert the data from each Xor before reducing them 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 <ST,PT,R> Xor<?,R>`	`accumulateSecondary(CollectionX<Xor<ST,PT>> xors, Reducer<R> reducer)` Accumulate the result of the Secondary types in the Collection of Xors provided using the supplied Reducer `Reducers`.
`static <ST,PT> Xor<?,ST>`	`accumulateSecondary(Monoid<ST> reducer, CollectionX<Xor<ST,PT>> xors)` Accumulate the results only from those Xors which have a Secondary 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`.
`default AnyMValue<PT>`	`anyM()`
`default <U1,U2> Xor<U1,U2>`	`bicast(java.lang.Class<U1> type1, java.lang.Class<U2> type2)` Cast two data types simulatanously.
`default <R1,R2> Xor<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 Xor<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> Xor<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> Xor<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> Xor<ST,R>`	`coflatMap(java.util.function.Function<? super MonadicValue<PT>,R> mapper)` Perform a coflatMap operation.
`default Xor<ST,PT>`	`combine(java.util.function.BinaryOperator<Combiner<PT>> combiner, Combiner<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).
`<T2,R> Xor<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> Xor<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 Xor<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> Xor<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
`Xor<ST,PT>`	`filter(java.util.function.Predicate<? super PT> test)` Keep only elements for which the supplied predicates hold e.g.
`default Xor<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> Xor<ST,RT1>`	`flatMap(java.util.function.Function<? super PT,? extends MonadicValue<? extends RT1>> mapper)` A flattening transformation operation (@see `Optional.flatMap(Function)`
`default <R> Xor<ST,R>`	`flatMapIterable(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> Xor<ST,R>`	`flatMapPublisher(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 <R1,R> Xor<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> Xor<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> Xor<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, TriFunction<? 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> Xor<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, TriFunction<? super PT,? super R1,? super R2,java.lang.Boolean> filterFunction, TriFunction<? 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> Xor<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, TriFunction<? super PT,? super R1,? super R2,? extends MonadicValue<R3>> value3, QuadFunction<? 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> Xor<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, TriFunction<? super PT,? super R1,? super R2,? extends MonadicValue<R3>> value3, QuadFunction<? super PT,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, QuadFunction<? 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> Xor<ST,T>`	`fromIterable(java.lang.Iterable<T> iterable)` Construct a Primary Xor from the supplied Iterable
`static <T> Xor<java.lang.Throwable,T>`	`fromPublisher(org.reactivestreams.Publisher<T> pub)` Construct a Primary Xor from the supplied publisher
`PT`	`get()`
`default boolean`	`isPresent()`
`boolean`	`isPrimary()`
`boolean`	`isSecondary()`
`default Xor<PStackX<ST>,PT>`	`list()`
`<R> Xor<ST,R>`	`map(java.util.function.Function<? super PT,? extends R> fn)` Transform this functor using the supplied transformation function
`default <R1,R2> Xor<R1,R2>`	`mapBoth(java.util.function.Function<? super ST,? extends R1> secondary, java.util.function.Function<? super PT,? extends R2> primary)` Deprecated.
`<R> Eval<R>`	`matches(java.util.function.Function<Matchable.CheckValue1<ST,R>,Matchable.CheckValue1<ST,R>> fn1, java.util.function.Function<Matchable.CheckValue1<PT,R>,Matchable.CheckValue1<PT,R>> fn2, java.util.function.Supplier<? extends R> otherwise)` Pattern match on the value/s inside this Xor.
`default Xor<ST,MonadicValue<PT>>`	`nest()` cojoin pattern.
`default Xor<ST,PT>`	`notNull()` Filter elements retaining only values which are not null
`default <U> Xor<ST,U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`default <R> Xor<ST,R>`	`patternMatch(java.util.function.Function<Matchable.CheckValue1<PT,R>,Matchable.CheckValue1<PT,R>> case1, java.util.function.Supplier<? extends R> otherwise)` Transform the elements of this Stream with a Pattern Matching case and default value
`Xor<ST,PT>`	`peek(java.util.function.Consumer<? super PT> action)` Peek at the current value of this Functor, without transforming it
`void`	`peek(java.util.function.Consumer<? super ST> stAction, java.util.function.Consumer<? super PT> ptAction)` Deprecated.
`static <ST,PT> Xor<ST,PT>`	`primary(PT value)` Create an instance of the primary type.
`static <ST,PT> Xor<ST,PT>`	`secondary(ST value)` Create an instance of the secondary type.
`<LT1> Xor<LT1,PT>`	`secondaryFlatMap(java.util.function.Function<? super ST,? extends Xor<LT1,PT>> mapper)` Perform a flatMap operation on the Secondary type
`ST`	`secondaryGet()`
`<R> Xor<R,PT>`	`secondaryMap(java.util.function.Function<? super ST,? extends R> fn)` Always map the Secondary type of this Xor if it is present using the provided transformation function
`Xor<ST,PT>`	`secondaryPeek(java.util.function.Consumer<? super ST> action)` Peek at the Secondary type value if present
`java.util.Optional<ST>`	`secondaryToOptional()`
`Xor<ST,PT>`	`secondaryToPrimayFlatMap(java.util.function.Function<? super ST,? extends Xor<ST,PT>> fn)` A flatMap operation that keeps the Secondary and Primary types the same
`Xor<ST,PT>`	`secondaryToPrimayMap(java.util.function.Function<? super ST,? extends PT> fn)` If this Xor contains the Secondary type, map it's value so that it contains the Primary type
`ReactiveSeq<ST>`	`secondaryToStream()`
`Value<ST>`	`secondaryValue()`
`static <ST,PT> Xor<ListX<ST>,ListX<PT>>`	`sequencePrimary(CollectionX<Xor<ST,PT>> xors)` Turn a collection of Xors into a single Ior with Lists of values.
`static <ST,PT> Xor<ListX<PT>,ListX<ST>>`	`sequenceSecondary(CollectionX<Xor<ST,PT>> xors)` Turn a collection of Xors into a single Xor with Lists of values.
`Xor<PT,ST>`	`swap()` Swap types so operations directly affect the current (pre-swap) Secondary 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> Xor<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
`default <T> Xor<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.
`default <T2,R> Xor<ST,R>`	`zip(java.util.function.BiFunction<? super PT,? super T2,? extends R> fn, org.reactivestreams.Publisher<? extends T2> app)` Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
`default <T2,R> Xor<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> Xor<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 <U> Xor<ST,org.jooq.lambda.tuple.Tuple2<PT,U>>`	`zip(org.jooq.lambda.Seq<? extends U> other)` Zip (combine) this Zippable with the supplied Seq combining both into a Tuple2
`default <U,R> Xor<ST,R>`	`zip(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiFunction<? super PT,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Seq, using the supplied combining function
`default <U> Xor<ST,org.jooq.lambda.tuple.Tuple2<PT,U>>`	`zip(java.util.stream.Stream<? extends U> other)` Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2
`default <U,R> Xor<ST,R>`	`zip(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

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

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, 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, orElse, orElseGet, orElseThrow, toAtomicReference, toCompletableFuture, toCompletableFutureAsync, toCompletableFutureAsync, toFutureW, toFutureWAsync, toFutureWAsync, 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
 - fromPublisher
```
static <T> Xor<java.lang.Throwable,T> fromPublisher(org.reactivestreams.Publisher<T> pub)
```
 Construct a Primary Xor from the supplied publisher
```
 
 ReactiveSeq<Integer> stream = ReactiveSeq.of(1,2,3);
 
 Xor<Throwable,Integer> future = Xor.fromPublisher(stream);
 
 //Xor[1]
 
 
 
```
 Parameters:
 
 pub - Publisher to construct an Xor from
 
 Returns:
 
 Xor constructed from the supplied Publisher
 - fromIterable
```
static <ST,T> Xor<ST,T> fromIterable(java.lang.Iterable<T> iterable)
```
 Construct a Primary Xor from the supplied Iterable
```
 
 List<Integer> list = Arrays.asList(1,2,3);
 
 Xor<Throwable,Integer> future = Xor.fromPublisher(stream);
 
 //Xor[1]
 
 
 
```
 Parameters:
 
 iterable - Iterable to construct an Xor from
 
 Returns:
 
 Xor constructed from the supplied Iterable
 - secondary
```
static <ST,PT> Xor<ST,PT> secondary(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
```
 
 Xor.<Integer,Integer>secondary(10).map(i->i+1);
 //Xor.secondary[10]
 
 Xor.<Integer,Integer>secondary(10).swap().map(i->i+1);
 //Xor.primary[11]
 
 
```
 Parameters:
 
 value - to wrap
 
 Returns:
 
 Secondary instance of Xor
 - primary
```
static <ST,PT> Xor<ST,PT> primary(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 Xors
```
 
 Xor.<Integer,Integer>primary(10).map(i->i+1);
 //Xor.primary[11]
 
 
 
 
```
 Parameters:
 
 value - To construct an Xor from
 
 Returns:
 
 Primary type instanceof Xor
 - forEach4
```
default <T2,R1,R2,R3,R> Xor<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,
 TriFunction<? super PT,? super R1,? super R2,? extends MonadicValue<R3>> value3,
 QuadFunction<? 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>
 
 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> Xor<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,
 TriFunction<? super PT,? super R1,? super R2,? extends MonadicValue<R3>> value3,
 QuadFunction<? super PT,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
 QuadFunction<? 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>
 
 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> Xor<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,
 TriFunction<? 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>
 
 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> Xor<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,
 TriFunction<? super PT,? super R1,? super R2,java.lang.Boolean> filterFunction,
 TriFunction<? 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>
 
 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> Xor<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>
 
 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> Xor<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>
 
 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
 - anyM
```
default AnyMValue<PT> anyM()
```
 Specified by:
 
 anyM in interface MonadicValue<PT>
 
 Returns:
 
 This monad wrapped as an AnyMValue
 - combine
```
default Xor<ST,PT> combine(java.util.function.BinaryOperator<Combiner<PT>> combiner,
 Combiner<PT> app)
```
 Description copied from interface: Combiner
 
 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:
 
 combine in interface Combiner<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.cyclops.Semigroups#combineApplicatives(BiFunction) } or Monoids { {@see com.aol.cyclops.Monoids#combineApplicatives(java.util.function.Function, com.aol.cyclops.Monoid) } {@code BinaryOperator> sumMaybes = Semigroups.combineScalarFunctors(Semigroups.intSum); Maybe.just(1) .combine(sumMaybes, Maybe.just(5)) //Maybe.just(6)); }
 - flatMapIterable
```
default <R> Xor<ST,R> flatMapIterable(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).flatMapIterable(i->Arrays.asList(()->i*3,20);
 //Maybe[9]
 
 
```
 Specified by:
 
 flatMapIterable in interface MonadicValue<PT>
 
 Parameters:
 
 mapper - transformation function
 
 Returns:
 
 MonadicValue
 - flatMapPublisher
```
default <R> Xor<ST,R> flatMapPublisher(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).flatMapPublisher(i->Flux.just(()->i*3,20);
 //FutureW[9]
 
 
```
 Specified by:
 
 flatMapPublisher in interface MonadicValue<PT>
 
 Parameters:
 
 mapper - transformation function
 
 Returns:
 
 MonadicValue
 - coflatMap
```
default <R> Xor<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>
 
 Parameters:
 
 mapper - Mapping / transformation function
 
 Returns:
 
 MonadicValue wrapping return value from transformation function applied to the value inside this MonadicValue
 - nest
```
default Xor<ST,MonadicValue<PT>> nest()
```
 Description copied from interface: MonadicValue
 
 cojoin pattern. Nests this Monad inside another.
 
 Specified by:
 
 nest in interface MonadicValue<PT>
 
 Returns:
 
 Nested Monad
 - combineEager
```
default Xor<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>
 
 Returns:
 - unit
```
default <T> Xor<ST,T> unit(T unit)
```
 Specified by:
 
 unit in interface MonadicValue<PT>
 
 Specified by:
 
 unit in interface Unit<PT>
 - toOptional
```
default java.util.Optional<PT> toOptional()
```
 Specified by:
 
 toOptional in interface Convertable<PT>
 
 Returns:
 
 Optional that wraps contained value, Optional.empty if value is null
 - filter
```
Xor<ST,PT> filter(java.util.function.Predicate<? super PT> test)
```
 Description copied from interface: Filterable
 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 Filterable<PT>
 
 Specified by:
 
 filter in interface MonadicValue<PT>
 
 Parameters:
 
 test - to filter elements by, retaining matches
 
 Returns:
 
 Filterable with elements removed where the predicate does not hold
 - secondaryToPrimayMap
```
Xor<ST,PT> secondaryToPrimayMap(java.util.function.Function<? super ST,? extends PT> fn)
```
 If this Xor contains the Secondary type, map it's value so that it contains the Primary type
 
 Parameters:
 
 fn - Function to map secondary type to primary
 
 Returns:
 
 Xor with secondary type mapped to primary
 - secondaryMap
```
<R> Xor<R,PT> secondaryMap(java.util.function.Function<? super ST,? extends R> fn)
```
 Always map the Secondary type of this Xor if it is present using the provided transformation function
 
 Parameters:
 
 fn - Transformation function for Secondary types
 
 Returns:
 
 Xor with Secondary type transformed
 - map
```
<R> Xor<ST,R> map(java.util.function.Function<? super PT,? extends R> fn)
```
 Description copied from interface: Functor
 Transform this functor using the supplied transformation function
```
 
 
 
 of(1,2,3).map(i->i*2)
 
 //[2,4,6]
 
 
 
```
 Specified by:
 
 map in interface ConvertableFunctor<PT>
 
 Specified by:
 
 map in interface Functor<PT>
 
 Specified by:
 
 map in interface MonadicValue<PT>
 
 Parameters:
 
 fn - Transformation function
 
 Returns:
 
 Transformed Functor
 - secondaryPeek
```
Xor<ST,PT> secondaryPeek(java.util.function.Consumer<? super ST> action)
```
 Peek at the Secondary type value if present
 
 Parameters:
 
 action - Consumer to peek at the Secondary type value
 
 Returns:
 
 Xor with the same values as before
 - peek
```
Xor<ST,PT> peek(java.util.function.Consumer<? super PT> action)
```
 Description copied from interface: Functor
 Peek at the current value of this Functor, without transforming it
```
 
 
 
 of(1,2,3).map(System.out::println)
 
 1
 2
 3
 
 
 
```
 Specified by:
 
 peek in interface Functor<PT>
 
 Parameters:
 
 action - Consumer that recieves each element from this Functor
 
 Returns:
 
 Functor that will peek at each value
 - swap
```
Xor<PT,ST> swap()
```
 Swap types so operations directly affect the current (pre-swap) Secondary type
```
 
 
 Xor.secondary("hello")
 .map(v->v+" world") 
 //Xor.seconary["hello"]
 
 Xor.secondary("hello")
 .swap()
 .map(v->v+" world") 
 .swap()
 //Xor.seconary["hello world"]
 
 
```
 Returns:
 
 Swap the primary and secondary types, allowing operations directly on what was the Secondary 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>
 
 Returns:
 
 new Ior
 - isPresent
```
default boolean isPresent()
```
 Specified by:
 
 isPresent in interface Convertable<PT>
 
 Returns:
 
 True if value exists and is non-null
 - toXor
```
default Xor<ST,PT> toXor()
```
 Specified by:
 
 toXor in interface Value<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>
 
 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
 - sequenceSecondary
```
static <ST,PT> Xor<ListX<PT>,ListX<ST>> sequenceSecondary(CollectionX<Xor<ST,PT>> xors)
```
 Turn a collection of Xors into a single Xor with Lists of values. Primary and secondary types are swapped during this operation.
```
 
 Xor<String,Integer> just = Xor.primary(10);
 Xor<String,Integer> none = Xor.secondary("none");
 Xor<ListX<Integer>,ListX<String>> xors =Xor.sequenceSecondary(ListX.of(just,none,Xor.primary(1)));
 //Xor.primary(ListX.of("none")))
 
 
 
```
 Parameters:
 
 xors - Xors to sequence
 
 Returns:
 
 Xor sequenced and swapped
 - accumulateSecondary
```
static <ST,PT,R> Xor<?,R> accumulateSecondary(CollectionX<Xor<ST,PT>> xors,
 Reducer<R> reducer)
```
 Accumulate the result of the Secondary types in the Collection of Xors provided using the supplied Reducer Reducers.
```
 
 Xor<String,Integer> just = Xor.primary(10);
 Xor<String,Integer> none = Xor.secondary("none");
 
 Xor<?,PSetX<String>> xors = Xor.accumulateSecondary(ListX.of(just,none,Xor.primary(1)),Reducers.<String>toPSetX());
 //Xor.primary(PSetX.of("none"))));
 
 
```
 Parameters:
 
 xors - Collection of Iors to accumulate secondary values
 
 reducer - Reducer to accumulate results
 
 Returns:
 
 Xor populated with the accumulate secondary operation
 - accumulateSecondary
```
static <ST,PT,R> Xor<?,R> accumulateSecondary(CollectionX<Xor<ST,PT>> xors,
 java.util.function.Function<? super ST,R> mapper,
 Monoid<R> reducer)
```
 Accumulate the results only from those Xors which have a Secondary type present, using the supplied mapping function to convert the data from each Xor before reducing them 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..
```
 
 Xor<String,Integer> just = Xor.primary(10);
 Xor<String,Integer> none = Xor.secondary("none");
 
 Xor<?,String> xors = Xor.accumulateSecondary(ListX.of(just,none,Xor.secondary("1")),i->""+i,Monoids.stringConcat);
 //Xor.primary("none1")
 
 
 
```
 Parameters:
 
 xors - Collection of Iors to accumulate secondary values
 
 mapper - Mapping function to be applied to the result of each Ior
 
 reducer - Semigroup to combine values from each Ior
 
 Returns:
 
 Xor populated with the accumulate Secondary operation
 - sequencePrimary
```
static <ST,PT> Xor<ListX<ST>,ListX<PT>> sequencePrimary(CollectionX<Xor<ST,PT>> xors)
```
 Turn a collection of Xors into a single Ior with Lists of values.
```
 
 
 Xor<String,Integer> just = Xor.primary(10);
 Xor<String,Integer> none = Xor.secondary("none");
 
 
 Xor<ListX<String>,ListX<Integer>> xors =Xor.sequencePrimary(ListX.of(just,none,Xor.primary(1)));
 //Xor.primary(ListX.of(10,1)));
 
 
```
 Parameters:
 
 iors - Xors to sequence
 
 Returns:
 
 Xor Sequenced
 - accumulatePrimary
```
static <ST,PT,R> Xor<?,R> accumulatePrimary(CollectionX<Xor<ST,PT>> xors,
 Reducer<R> reducer)
```
 Accumulate the result of the Primary types in the Collection of Xors provided using the supplied Reducer Reducers.
```
 
 Xor<String,Integer> just = Xor.primary(10);
 Xor<String,Integer> none = Xor.secondary("none");
 
 Xor<?,PSetX<Integer>> xors =Xor.accumulatePrimary(ListX.of(just,none,Xor.primary(1)),Reducers.toPSetX());
 //Xor.primary(PSetX.of(10,1))));
 
 
```
 Parameters:
 
 Xors - Collection of Iors to accumulate primary values
 
 reducer - Reducer to accumulate results
 
 Returns:
 
 Xor populated with the accumulate primary operation
 - accumulatePrimary
```
static <ST,PT,R> Xor<?,R> accumulatePrimary(CollectionX<Xor<ST,PT>> xors,
 java.util.function.Function<? super PT,R> mapper,
 Monoid<R> reducer)
```
 Accumulate the results only from those Iors which have a Primary type present, using the supplied mapping function to convert the data from each Xor before reducing them 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..
```
 
 Xor<String,Integer> just = Xor.primary(10);
 Xor<String,Integer> none = Xor.secondary("none");
 
 Xor<?,String> iors = Xor.accumulatePrimary(ListX.of(just,none,Xor.primary(1)),i->""+i,Monoids.stringConcat);
 //Xor.primary("101"));
 
 
```
 Parameters:
 
 xors - Collection of Iors to accumulate primary values
 
 mapper - Mapping function to be applied to the result of each Ior
 
 reducer - Reducer to accumulate results
 
 Returns:
 
 Xor populated with the accumulate primary operation
 - accumulatePrimary
```
static <ST,PT> Xor<?,PT> accumulatePrimary(Monoid<PT> reducer,
 CollectionX<Xor<ST,PT>> xors)
```
 Accumulate the results only from those Xors which have a Primary 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.
```
 
 Xor<String,Integer> just = Xor.primary(10);
 Xor<String,Integer> none = Xor.secondary("none");
 
 Xor<?,Integer> xors XIor.accumulatePrimary(Monoids.intSum,ListX.of(just,none,Ior.primary(1)));
 //Ior.primary(11);
 
 
 
```
 Parameters:
 
 xors - Collection of Xors to accumulate primary values
 
 reducer - Reducer to accumulate results
 
 Returns:
 
 Xor populated with the accumulate primary operation
 - accumulateSecondary
```
static <ST,PT> Xor<?,ST> accumulateSecondary(Monoid<ST> reducer,
 CollectionX<Xor<ST,PT>> xors)
```
 Accumulate the results only from those Xors which have a Secondary 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.
```
 
 Xor.accumulateSecondary(ListX.of(Xor.secondary("failed1"),
 												Xor.secondary("failed2"),
 												Xor.primary("success")),
 												Semigroups.stringConcat)
 												
 												
 //Xors.Primary[failed1failed2]
 
 
```
```
 
 
 Xor<String,Integer> just = Xor.primary(10);
 Xor<String,Integer> none = Xor.secondary("none");
 
 Xor<?,Integer> iors = Xor.accumulateSecondary(Monoids.intSum,ListX.of(Xor.both(2, "boo!"),Xor.secondary(1)));
 //Xor.primary(3); 2+1
 
 
 
 
```
 Parameters:
 
 xors - Collection of Xors to accumulate secondary values
 
 reducer - Semigroup to combine values from each Xor
 
 Returns:
 
 Xor populated with the accumulate Secondary operation
 - 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 Xor contains an element of the secondary type Execute the primary function if this Xor contains an element of the primary type
```
 
 Xor.primary(10)
 .visit(secondary->"no", primary->"yes")
 //Xor["yes"]
 
 Xor.secondary(90)
 .visit(secondary->"no", primary->"yes")
 //Xor["no"]
 
 
 
 
 
```
 Parameters:
 
 secondary - Function to execute if this is a Secondary Xor
 
 primary - Function to execute if this is a Primary Ior
 
 both - Function to execute if this Ior contains both types
 
 Returns:
 
 Result of executing the appropriate function
 - mapBoth
```
@Deprecated
default <R1,R2> Xor<R1,R2> mapBoth(java.util.function.Function<? super ST,? extends R1> secondary,
 java.util.function.Function<? super PT,? extends R2> primary)
```
 Deprecated.
 - bimap
```
default <R1,R2> Xor<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>
 
 Parameters:
 
 secondary - transformation function for the first type
 
 primary - transformation function for the second type
 
 Returns:
 
 New BiFunctor containing transformed data
 - bipeek
```
default Xor<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>
 
 Parameters:
 
 c1 - consumer for the first type
 
 c2 - consumer for the second type
 
 Returns:
 
 New BiFunctor with the same data
 - bicast
```
default <U1,U2> Xor<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>
 
 Returns:
 - bitrampoline
```
default <R1,R2> Xor<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>
 
 Parameters:
 
 mapper1 - transformation function for the first type
 
 mapper2 - transformation function for the second type
 
 Returns:
 
 New BiFunctor containing transformed data
 - patternMatch
```
default <R> Xor<ST,R> patternMatch(java.util.function.Function<Matchable.CheckValue1<PT,R>,Matchable.CheckValue1<PT,R>> case1,
 java.util.function.Supplier<? extends R> otherwise)
```
 Description copied from interface: Functor
 Transform the elements of this Stream with a Pattern Matching case and default value
```
 
 List<String> result = CollectionX.of(1,2,3,4)
 .patternMatch(
 c->c.valuesWhere(i->"even", (Integer i)->i%2==0 )
 )
 
 // CollectionX["odd","even","odd","even"]
 
```
 Specified by:
 
 patternMatch in interface Functor<PT>
 
 Parameters:
 
 case1 - Function to generate a case (or chain of cases as a single case)
 
 otherwise - Value if supplied case doesn't match
 
 Returns:
 
 CollectionX where elements are transformed by pattern matching
 - matches
```
<R> Eval<R> matches(java.util.function.Function<Matchable.CheckValue1<ST,R>,Matchable.CheckValue1<ST,R>> fn1,
 java.util.function.Function<Matchable.CheckValue1<PT,R>,Matchable.CheckValue1<PT,R>> fn2,
 java.util.function.Supplier<? extends R> otherwise)
```
 Pattern match on the value/s inside this Xor.
```
 
 
 import static com.aol.cyclops.control.Matchable.otherwise;
 import static com.aol.cyclops.control.Matchable.then;
 import static com.aol.cyclops.control.Matchable.when;
 import static com.aol.cyclops.util.function.Predicates.instanceOf;
 
 Xor.primary(10)
 .matches(c->c.is(when("10"),then("hello")),
 c->c.is(when(instanceOf(Integer.class)), then("error")),
 otherwise("miss"))
 .get()
 //"error" Note the second case, 'primary' case is the one that matches
 
 
 
 
```
 Parameters:
 
 fn1 - Pattern matching function executed if this Xor has the secondary type
 
 fn2 - Pattern matching function executed if this Xor has the primary type
 
 otherwise - Supplier used to provide a value if the selecting pattern matching function fails to find a match
 
 Returns:
 
 Lazy result of the pattern matching
 - get
```
PT get()
```
 Specified by:
 
 get in interface Convertable<PT>
 
 Specified by:
 
 get in interface java.util.function.Supplier<PT>
 
 Returns:
 
 Contained value, maybe null
 - secondaryValue
```
Value<ST> secondaryValue()
```
 Returns:
 
 A Value containing the secondary Value if present
 - secondaryGet
```
ST secondaryGet()
```
 Returns:
 
 The Secondary Value if present, otherwise null
 - secondaryToOptional
```
java.util.Optional<ST> secondaryToOptional()
```
 Returns:
 
 The Secondary value wrapped in an Optional if present, otherwise an empty Optional
 - secondaryToStream
```
ReactiveSeq<ST> secondaryToStream()
```
 Returns:
 
 A Stream containing the secondary value if present, otherwise an empty Stream
 - flatMap
```
<RT1> Xor<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>
 
 Parameters:
 
 mapper - transformation function
 
 Returns:
 
 MonadicValue
 - secondaryFlatMap
```
<LT1> Xor<LT1,PT> secondaryFlatMap(java.util.function.Function<? super ST,? extends Xor<LT1,PT>> mapper)
```
 Perform a flatMap operation on the Secondary type
 
 Parameters:
 
 mapper - Flattening transformation function
 
 Returns:
 
 Xor containing the value inside the result of the transformation function as the Secondary value, if the Secondary type was present
 - secondaryToPrimayFlatMap
```
Xor<ST,PT> secondaryToPrimayFlatMap(java.util.function.Function<? super ST,? extends Xor<ST,PT>> fn)
```
 A flatMap operation that keeps the Secondary and Primary types the same
 
 Parameters:
 
 fn - Transformation function
 
 Returns:
 
 Xor
 - peek
```
@Deprecated
void peek(java.util.function.Consumer<? super ST> stAction,
 java.util.function.Consumer<? super PT> ptAction)
```
 Deprecated.
 - isPrimary
```
boolean isPrimary()
```
 Returns:
 
 True if this is a primary Xor
 - isSecondary
```
boolean isSecondary()
```
 Returns:
 
 True if this is a secondary Xor
 - combine
```
<T2,R> Xor<ST,R> combine(Value<? extends T2> app,
 java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)
```
 Description copied from interface: Combiner
 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 Combiner<PT>
 
 Parameters:
 
 app - Value to combine with this one.
 
 fn - BiFunction to combine them
 
 Returns:
 
 New Applicativefunctor that represents the combined values
 - list
```
default Xor<PStackX<ST>,PT> list()
```
 Returns:
 
 An Xor with the secondary type converted to a persistent list, for use with accumulating app function Xor#combine(Xor,BiFunction)
 - combineToList
```
default <T2,R> Xor<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
 
 Parameters:
 
 app - Value to combine with
 
 fn - Combiner function for primary values
 
 Returns:
 
 Combined Xor
 - combine
```
default <T2,R> Xor<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
```
 
 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")))]
 
 
```
 Parameters:
 
 app - Value to combine with
 
 semigroup - to combine secondary types
 
 fn - To combine primary types
 
 Returns:
 
 Combined Xor
 - zip
```
default <T2,R> Xor<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 ApplicativeFunctor<PT>
 
 Specified by:
 
 zip in interface Zippable<PT>
 
 Parameters:
 
 app - to zip with
 
 fn - Zip function
 
 Returns:
 
 Combined zippable
 - zip
```
default <T2,R> Xor<ST,R> zip(java.util.function.BiFunction<? super PT,? super T2,? extends R> fn,
 org.reactivestreams.Publisher<? extends T2> app)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
 
 Specified by:
 
 zip in interface ApplicativeFunctor<PT>
 
 Specified by:
 
 zip in interface Zippable<PT>
 
 Parameters:
 
 fn - Zip / combining function
 
 app - to combine with
 
 Returns:
 
 Combined zippable
 - zip
```
default <U,R> Xor<ST,R> zip(org.jooq.lambda.Seq<? 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 Seq, using the supplied combining function
 
 Specified by:
 
 zip in interface Zippable<PT>
 
 Parameters:
 
 other - Seq to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - zip
```
default <U,R> Xor<ST,R> zip(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:
 
 zip in interface Zippable<PT>
 
 Parameters:
 
 other - Stream to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - zip
```
default  Xor<ST,org.jooq.lambda.tuple.Tuple2<PT,U>> zip(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:
 
 zip in interface Zippable<PT>
 
 Parameters:
 
 other - Stream to combine with
 
 Returns:
 
 Combined Zippable
 - zip
```
default  Xor<ST,org.jooq.lambda.tuple.Tuple2<PT,U>> zip(org.jooq.lambda.Seq<? extends U> other)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Seq combining both into a Tuple2
 
 Specified by:
 
 zip in interface Zippable<PT>
 
 Parameters:
 
 other - Seq to combine with
 
 Returns:
 
 Combined Zippable
 - zip
```
default  Xor<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 Zippable<PT>
 
 Parameters:
 
 other - Iterable to combine with
 
 Returns:
 - ofType
```
default  Xor<ST,U> ofType(java.lang.Class<? extends U> type)
```
 Description copied from interface: Filterable
 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 Filterable<PT>
 - filterNot
```
default Xor<ST,PT> filterNot(java.util.function.Predicate<? super PT> fn)
```
 Description copied from interface: Filterable
 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 Filterable<PT>
 
 Parameters:
 
 fn - to filter elements by, retaining matches
 
 Returns:
 
 Filterable with elements removed where the predicate does not hold
 - notNull
```
default Xor<ST,PT> notNull()
```
 Description copied from interface: Filterable
 Filter elements retaining only values which are not null
```
 
 
 of(1,2,null,4).nonNull();
 
 //[1,2,4]
 
 
 
```
 Specified by:
 
 notNull in interface Filterable<PT>
 
 Returns:
 
 Filterable with nulls removed
 - cast
```
default  Xor<ST,U> cast(java.lang.Class<? extends U> type)
```
 Description copied from interface: Functor
 
 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 Functor<PT>
 - trampoline
```
default <R> Xor<ST,R> trampoline(java.util.function.Function<? super PT,? extends Trampoline<? extends R>> mapper)
```
 Description copied from interface: Functor
 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 Functor<PT>
 
 Parameters:
 
 mapper - TCO Transformation function
 
 Returns:
 
 Functor transformed by the supplied transformation function

Interface Xor<ST,PT>

Nested Class Summary

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

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

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

Method Summary

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

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

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

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

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

Methods inherited from interface java.util.function.Predicate

Methods inherited from interface java.lang.Iterable

Method Detail

fromPublisher

fromIterable

secondary

primary

forEach4

forEach4

forEach3

forEach3

forEach2

forEach2

anyM

combine

flatMapIterable

flatMapPublisher

coflatMap

nest

combineEager

unit

toOptional

filter

secondaryToPrimayMap

secondaryMap

map

secondaryPeek

peek

swap

toIor

isPresent

toXor

toXor

sequenceSecondary

accumulateSecondary

accumulateSecondary

sequencePrimary

accumulatePrimary

accumulatePrimary

accumulatePrimary

accumulateSecondary

visit

mapBoth

bimap

bipeek

bicast

bitrampoline

patternMatch

matches

get

secondaryValue

secondaryGet

secondaryToOptional

secondaryToStream

flatMap

secondaryFlatMap

secondaryToPrimayFlatMap

peek

isPrimary

isSecondary

combine

list

combineToList

combine

zip

zip

zip

zip

zip