Xor (cyclops-reactor 9.0.0-FINAL API)

Type Parameters:

ST - Secondary type

PT - Primary type

All Superinterfaces:

BiTransformable<ST,PT>, Convert<Higher<Higher<Witness.xor,ST>,PT>>, Convertable<PT>, Filters<PT>, Fn0<PT>, Folds<PT>, Higher<Higher<Witness.xor,ST>,PT>, Higher2<Witness.xor,ST,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>>, Transformable<PT>, Unit<PT>, Value<PT>, Visitable<PT>, Zippable<PT>

All Known Subinterfaces:

Either<LT,RT>

All Known Implementing Classes:

Either.CompletableEither, Either.Lazy, Either.Left, Either.Right, Xor.Primary, Xor.Secondary
```
public interface Xor<ST,PT>
extends To<Xor<ST,PT>>, MonadicValue<PT>, BiTransformable<ST,PT>, Higher2<Witness.xor,ST,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, lazy everything is ok - or we have an error). It can be used to avoid a common design anti-pattern where an Object has two fields one of which is always null (or worse, both are defined as Optionals).
```
  

     public class Member{
           Xor team;
     }

     Rather than

     public class Member{
```

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class Xor.Instances

static class Xor.Primary<ST,PT>

static class Xor.Secondary<ST,PT>
- Nested classes/interfaces inherited from interface com.aol.cyclops2.types.Value
  Value.ValueImpl<T>
- Nested classes/interfaces inherited from interface com.aol.cyclops2.types.foldable.Convertable
  Convertable.SupplierToConvertable<T>
- Nested classes/interfaces inherited from interface cyclops.function.Fn0
  Fn0.FunctionalOperations<R>, Fn0.SupplierKind<R>

Nested Classes
Modifier and Type	Interface and Description
`static class`	`Xor.Instances`
`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) `cyclops2.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 `cyclops2.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) `cyclops2.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) `cyclops2.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 `cyclops2.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) `cyclops2.Monoids` .
`default Active<Higher<Witness.xor,ST>,PT>`	`allTypeclasses()`
`default AnyMValue<Witness.xor,PT>`	`anyM()`
`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(Xor<LT,RT> either)`
`default int`	`arity()`
`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 BiTransformable, 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 reactiveStream 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.
`<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<LinkedListX<ST>,R>`	`combineToList(Xor<ST,? extends T2> app, java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)` Accumulate secondarys into a LinkedListX (extended Persistent List) and Primary with the supplied combiner function Primary accumulation only occurs if all phases are primary
`static <X,LT extends X,M extends X,RT extends X> java.util.function.Consumer<java.util.function.Consumer<? super X>>`	`consumeAny(Xor<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)
`default <W1> Coproduct<W1,Higher<Witness.xor,ST>,PT>`	`coproduct(InstanceDefinitions<W1> def2)`
`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>`	`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> Xor<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> Xor<ST,R>`	`flatMapS(java.util.function.Function<? super PT,? extends java.util.stream.Stream<? extends R>> mapper)`
`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 reactiveStream
`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, 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> 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, 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> 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, 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> 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, 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> 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()`
`static <L,T> Cokleisli<Higher<Witness.xor,L>,T,Xor<L,T>>`	`kindCokleisli()`
`static <L,T> Kleisli<Higher<Witness.xor,L>,Xor<L,T>,T>`	`kindKleisli()`
`default <W extends WitnessType<W>> XorT<W,ST,PT>`	`liftM(W witness)`
`default Xor<LinkedListX<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 <W2,R> Nested<Higher<Witness.xor,ST>,W2,R>`	`mapM(java.util.function.Function<? super PT,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs)`
`static <ST,T> Xor<ST,T>`	`narrowK(Higher<Higher<Witness.xor,ST>,T> xor)`
`static <ST,T> Xor<ST,T>`	`narrowK2(Higher2<Witness.xor,ST,T> xor)`
`default Xor<ST,MonadicValue<PT>>`	`nest()` cojoin pattern.
`static <W1,ST,PT> Nested<Higher<Witness.xor,ST>,W1,PT>`	`nested(Xor<ST,Higher<W1,PT>> nested, InstanceDefinitions<W1> def2)`
`default Eval<Xor<ST,PT>>`	`nestedEval()`
`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 reactiveStream that are of a given type.
`Xor<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.
`static <ST,PT> Xor<ST,PT>`	`primary(PT value)` Create an instance of the primary type.
`default <W1> Product<Higher<Witness.xor,ST>,W1,PT>`	`product(Active<W1,PT> active)`
`default <R> Xor<ST,R>`	`retry(java.util.function.Function<? super PT,? extends R> fn)` Retry a transformation if it fails.
`default <R> Xor<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> 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 Xor with Lists of values.
`static <ST,PT> Xor<ListX<PT>,ListX<ST>>`	`sequenceSecondary(CollectionX<Xor<ST,PT>> xors)` Turn a toX of Xors into a singleUnsafe 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 Trampoline<Xor<ST,PT>>`	`toTrampoline()`
`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.
`static <X,LT extends X,RT extends X> X`	`visitAny(java.util.function.Consumer<? super X> c, Xor<LT,RT> either)`
`static <X,PT extends X,ST extends X,R> R`	`visitAny(Xor<ST,PT> either, java.util.function.Function<? super X,? extends R> fn)`
`static <L,T> Higher<Higher<Witness.xor,L>,T>`	`widen(Xor<L,T> narrow)`
`default Xor<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 SemigroupK and Monoids for a large number of canned combinations).
`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 <S,U> Xor<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> Xor<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> Xor<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> Xor<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> Xor<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> Xor<ST,org.jooq.lambda.tuple.Tuple2<PT,U>>`	`zipP(org.reactivestreams.Publisher<? extends U> other)`
`default <U> Xor<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> Xor<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> Xor<ST,R>`	`zipWith(java.lang.Iterable<java.util.function.Function<? super PT,? extends R>> fn)`
`default <R> Xor<ST,R>`	`zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super PT,? extends R>> fn)`
`default <R> Xor<ST,R>`	`zipWithS(java.util.stream.Stream<java.util.function.Function<? super PT,? extends R>> fn)`

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

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

Methods inherited from interface com.aol.cyclops2.types.foldable.Folds
endsWith, endsWithIterable, findAny, findFirst, firstValue, foldLeft, foldLeft, foldLeft, foldLeft, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, join, join, join, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleUnsafe, startsWith, startsWithIterable, takeOne, xMatch

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

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

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

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

Methods inherited from interface com.aol.cyclops2.hkt.Higher
applyHKT_, applyHKT, applyHKT

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

Method Detail

kindKleisli

static <L,T> Kleisli<Higher<Witness.xor,L>,Xor<L,T>,T> kindKleisli()

widen

static <L,T> Higher<Higher<Witness.xor,L>,T> widen(Xor<L,T> narrow)

kindCokleisli

static <L,T> Cokleisli<Higher<Witness.xor,L>,T,Xor<L,T>> kindCokleisli()

nested

static <W1,ST,PT> Nested<Higher<Witness.xor,ST>,W1,PT> nested(Xor<ST,Higher<W1,PT>> nested,
                                                              InstanceDefinitions<W1> def2)

product

default <W1> Product<Higher<Witness.xor,ST>,W1,PT> product(Active<W1,PT> active)

coproduct

default <W1> Coproduct<W1,Higher<Witness.xor,ST>,PT> coproduct(InstanceDefinitions<W1> def2)

allTypeclasses

default Active<Higher<Witness.xor,ST>,PT> allTypeclasses()

mapM

default <W2,R> Nested<Higher<Witness.xor,ST>,W2,R> mapM(java.util.function.Function<? super PT,? extends Higher<W2,R>> fn,
                                                        InstanceDefinitions<W2> defs)

liftM

default <W extends WitnessType<W>> XorT<W,ST,PT> liftM(W witness)

nestedEval
```
default Eval<Xor<ST,PT>> nestedEval()
```

consumeAny
```
static <X,LT extends X,M extends X,RT extends X> java.util.function.Consumer<java.util.function.Consumer<? super X>> consumeAny(Xor<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(Xor::consumeAny)
                 .accept(System.out::println);
 
 
```
Parameters:

either - Xor to consume value for

Returns:

Consumer we can applyHKT to consume value

applyAny

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

visitAny

static <X,PT extends X,ST extends X,R> R visitAny(Xor<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,
                                                Xor<LT,RT> either)

narrowK2

static <ST,T> Xor<ST,T> narrowK2(Higher2<Witness.xor,ST,T> xor)

narrowK

static <ST,T> Xor<ST,T> narrowK(Higher<Higher<Witness.xor,ST>,T> xor)

fromPublisher

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

Construct a Primary Xor from the supplied publisher

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

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

         //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(reactiveStream);

         //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

arity
```
default int arity()
```
Specified by:

arity in interface MonadicValue<PT>

zipWith

default <R> Xor<ST,R> zipWith(java.lang.Iterable<java.util.function.Function<? super PT,? extends R>> fn)

Specified by:: zipWith in interface Zippable<PT>

zipWithS

default <R> Xor<ST,R> zipWithS(java.util.stream.Stream<java.util.function.Function<? super PT,? extends R>> fn)

Specified by:: zipWithS in interface Zippable<PT>

zipWithP

default <R> Xor<ST,R> zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super PT,? extends R>> fn)

Specified by:: zipWithP in interface Zippable<PT>

retry

default <R> Xor<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.applyHKT(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");


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

 		//result = 42

Specified by:: retry in interface Transformable<PT>
Parameters:: fn - Function to retry if fails

zipP

default <U> Xor<ST,org.jooq.lambda.tuple.Tuple2<PT,U>> zipP(org.reactivestreams.Publisher<? extends U> other)

Specified by:: zipP in interface Zippable<PT>

retry

default <R> Xor<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.applyHKT(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");


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

 		//result = 42

Specified by:: retry in interface Transformable<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> Xor<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(CyclopsCollectors.toList());

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

Specified by:: zip3 in interface Zippable<PT>

zip3

default <S,U,R> Xor<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 Zippable<PT>

zip4

default <T2,T3,T4> Xor<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(CyclopsCollectors.toList());

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

Specified by:: zip4 in interface Zippable<PT>

zip4

default <T2,T3,T4,R> Xor<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 Zippable<PT>

flatMapS

default <R> Xor<ST,R> flatMapS(java.util.function.Function<? super PT,? extends java.util.stream.Stream<? extends R>> mapper)

Specified by:: flatMapS in interface MonadicValue<PT>

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,
                                           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>
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,
                                           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>

Parameters:

value1 - Nested MonadicValue to iterate over

value2 - Nested MonadicValue to iterate over

value3 - Nested MonadicValue to iterate over

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

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

Returns:

MonadicValue with elements generated via nested iteration

forEach3

default <T2,R1,R2,R> 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,
                                        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>
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,
                                        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>
Parameters:: value1 - Nested MonadicValue to iterate over; value2 - Nested MonadicValue to iterate over; filterFunction - Filter to applyHKT over elements before passing non-filtered values to the yielding function; yieldingFunction - Function with pointers to the current element from both MonadicValue that generates the new elements
Returns:: MonadicValue with elements generated via nested iteration

forEach2
```
default <R1,R> 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 reactiveStream

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

Specified by:: forEach2 in interface MonadicValue<PT>; filterFunction - Filter to applyHKT over elements before passing non-filtered values to the yielding function; yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
Returns:: MonadicValue with elements generated via nested iteration

anyM

default AnyMValue<Witness.xor,PT> anyM()

zip
```
default Xor<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 SemigroupK and Monoids for a large number of canned combinations). If this Applicative is a scalar value the provided value is combined with that value, otherwise the value is combined pair wise with all value in a non-scalar datastructure
Specified by:

zip in interface Zippable<PT>

Returns:

See Also:
Semigroup, Semigroups, Monoid,
To lift any Semigroup (or monoid) up to handling Applicatives use the combineApplicatives operator in SemigroupK {@see com.aol.cyclops2.SemigroupK#combineApplicatives(BiFunction) } or Monoids { {@see com.aol.cyclops2.Monoids#combineApplicatives(java.util.function.Function, com.aol.cyclops2.function.Monoid) } {@code BinaryOperator> sumMaybes = SemigroupK.combineScalarFunctors(SemigroupK.intSum); Maybe.just(1).zip(sumMaybes, Maybe.just(5)) //Maybe.just(6)); }

flatMapI
```
default <R> Xor<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>

Parameters:

mapper - transformation function

Returns:

MonadicValue

flatMapP
```
default <R> Xor<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.
```
  
   Future.ofResult(1).map(i->i+2).flatMapP(i->Flux.just(()->i*3,20);
   //Future[9]
 
 
```
Specified by:

flatMapP 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 singleUnsafe value to be wrapped inside a Monad.
```
  
   Maybe.none().coflatMap(m -> m.isPresent() ? m.get() : 10);
   //Maybe[10]
 
 
```
Specified by:

coflatMap in interface MonadicValue<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. maybe / async alternatives)

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

Specified by:: combineEager in interface MonadicValue<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.zero if value is null

filter
```
Xor<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>

Parameters:

test - to filter elements by, retaining matches

Returns:

Filters 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: 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>

Parameters:

fn - Transformation function

Returns:

Transformed Transformable

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: 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>

Parameters:

action - Consumer that recieves each element from this Transformable

Returns:

Transformable 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 zero

sequenceSecondary

static <ST,PT> Xor<ListX<PT>,ListX<ST>> sequenceSecondary(CollectionX<Xor<ST,PT>> xors)

Turn a toX of Xors into a singleUnsafe 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 cyclops2.Reducers.

 
  Xor<String,Integer> just  = Xor.primary(10);
        Xor<String,Integer> none = Xor.secondary("none");

  Xor<?,PersistentSetX<String>> xors = Xor.accumulateSecondary(ListX.of(just,none,Xor.primary(1)),Reducers.<String>toPersistentSetX());
      //Xor.primary(PersistentSetX.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) cyclops2.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 Xor 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 cyclops2.Reducers.

 
  Xor<String,Integer> just  = Xor.primary(10);
        Xor<String,Integer> none = Xor.secondary("none");

  Xor<?,PersistentSetX<Integer>> xors =Xor.accumulatePrimary(ListX.of(just,none,Xor.primary(1)),Reducers.toPersistentSetX());
        //Xor.primary(PersistentSetX.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) cyclops2.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) cyclops2.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) cyclops2.Monoids .

 
 Xor.accumulateSecondary(ListX.of(Xor.secondary("failed1"),
    												Xor.secondary("failed2"),
    												Xor.primary("success")),
    												SemigroupK.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

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: BiTransformable

Transform this BiTransformable, changing two value types at once.

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

Specified by:: bimap in interface BiTransformable<ST,PT>
Parameters:: secondary - transformation function for the first type; primary - transformation function for the second type
Returns:: New BiTransformable 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: BiTransformable
Peek at two data types simulatanously (typically to perform a side-effect with each data point)
```
 
     MapX<String,Integer> map = MapXs.of("hello",2);
     map.bipeek(s->System.out.pritnln("key = " + s),System.out::println);
 
 
```
Specified by:

bipeek in interface BiTransformable<ST,PT>

Parameters:

c1 - consumer for the first type

c2 - consumer for the second type

Returns:

New BiTransformable 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: BiTransformable

Cast two data types simulatanously.

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

Specified by:: bicast in interface BiTransformable<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: BiTransformable

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

Specified by:

bitrampoline in interface BiTransformable<ST,PT>

Parameters:

mapper1 - transformation function for the first type

mapper2 - transformation function for the second type

Returns:

New BiTransformable containing transformed data

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 zero Optional

secondaryToStream
```
ReactiveSeq<ST> secondaryToStream()
```
Returns:

A Stream containing the secondary value if present, otherwise an zero 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: 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>
Parameters:: app - Value to combine with this one.; fn - BiFunction to combine them
Returns:: New Applicativefunctor that represents the combined values

list
```
default Xor<LinkedListX<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<LinkedListX<ST>,R> combineToList(Xor<ST,? extends T2> app,
                                                    java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)
```
Accumulate secondarys into a LinkedListX (extended Persistent List) and Primary with the supplied combiner function Primary accumulation only occurs if all phases are primary

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

        //Secondary of [LinkedListX.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 MonadicValue<PT>

Specified by:

zip in interface Zippable<PT>

Parameters:

app - to zip with

fn - Zip function

Returns:

Combined zippable

zipP
```
default <T2,R> Xor<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 Zippable<PT>

Parameters:

app - to combine with

fn - Zip / combining function

Returns:

Combined zippable

zipS
```
default <U,R> Xor<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 Zippable<PT>

Parameters:

other - Stream to combine with

zipper - Zip / combining function

Returns:

Combined zippable

zipS
```
default <U> Xor<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 Zippable<PT>

Parameters:

other - Stream to combine with

Returns:

Combined Zippable

zip
```
default <U> 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 <U> Xor<ST,U> ofType(java.lang.Class<? extends U> type)

Description copied from interface: Filters

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

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

Specified by:: ofType in interface Filters<PT>

filterNot
```
default Xor<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>

Parameters:

fn - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

notNull
```
default Xor<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>

Returns:

Filters with nulls removed

cast
```
default <U> Xor<ST,U> cast(java.lang.Class<? extends U> type)
```
Description copied from interface: Transformable

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

Specified by:

cast in interface Transformable<PT>

trampoline

default <R> Xor<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>
Parameters:: mapper - TCO Transformation function
Returns:: Transformable transformed by the supplied transformation function

toTrampoline

default Trampoline<Xor<ST,PT>> toTrampoline()

Interface Xor<ST,PT>

Nested Class Summary

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

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

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

Method Summary

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

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

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

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

Methods inherited from interface java.lang.Iterable

Methods inherited from interface cyclops.function.Fn0

Methods inherited from interface java.util.function.Predicate

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

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

Method Detail

kindKleisli

widen

kindCokleisli

nested

product

coproduct

allTypeclasses

mapM

liftM

nestedEval

consumeAny

applyAny

visitAny

visitAny

narrowK2

narrowK

fromPublisher

fromIterable

secondary

primary

arity

zipWith

zipWithS

zipWithP

retry

zipP

retry

zip3

zip3

zip4

zip4

flatMapS

forEach4

forEach4

forEach3

forEach3

forEach2

forEach2

anyM

zip

flatMapI

flatMapP

coflatMap

nest

combineEager

unit

toOptional

filter

secondaryToPrimayMap

secondaryMap

map

secondaryPeek

peek

swap

toIor

isPresent

toXor

toXor

sequenceSecondary

accumulateSecondary

accumulateSecondary

sequencePrimary

accumulatePrimary

accumulatePrimary