Ior (cyclops-reactor 8.2.1 API)

Type Parameters:

ST - Secondary type

PT - Primary type

All Superinterfaces:

ApplicativeFunctor<PT>, BiFunctor<ST,PT>, Convertable<PT>, ConvertableFunctor<PT>, Filterable<PT>, Foldable<PT>, Functor<PT>, java.lang.Iterable<PT>, MonadicValue<PT>, MonadicValue2<ST,PT>, java.util.function.Predicate<PT>, org.reactivestreams.Publisher<PT>, java.util.function.Supplier<PT>, Unit<PT>, Value<PT>, Visitable<PT>, Zippable<PT>

All Known Implementing Classes:

Ior.Both, Ior.Primary, Ior.Secondary
```
public interface Ior<ST,PT>
extends java.util.function.Supplier<PT>, MonadicValue2<ST,PT>, BiFunctor<ST,PT>, Functor<PT>, Filterable<PT>, ApplicativeFunctor<PT>
```
Inclusive Or (can be one of Primary, Secondary or Both Primary and Secondary) An Either or Union type, but right biased. Primary and Secondary are used instead of Right & Left. 'Right' (or primary type) biased disjunct union. No 'projections' are provided, swap() and secondaryXXXX alternative methods can be used instead.

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class Ior.Both<ST,PT>

static class Ior.Primary<ST,PT>

static class Ior.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`	`Ior.Both<ST,PT>`
`static class`	`Ior.Primary<ST,PT>`
`static class`	`Ior.Secondary<ST,PT>`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`static <ST,PT,R> Ior<?,R>`	`accumulatePrimary(CollectionX<Ior<ST,PT>> iors, java.util.function.Function<? super PT,R> mapper, Semigroup<R> reducer)`
`static <ST,PT,R> Ior<?,R>`	`accumulatePrimary(CollectionX<Ior<ST,PT>> iors, Reducer<R> reducer)`
`static <ST,PT> Ior<?,PT>`	`accumulatePrimary(CollectionX<Ior<ST,PT>> iors, Semigroup<PT> reducer)`
`static <ST,PT,R> Ior<?,R>`	`accumulateSecondary(CollectionX<Ior<ST,PT>> iors, java.util.function.Function<? super ST,R> mapper, Semigroup<R> reducer)`
`static <ST,PT,R> Ior<?,R>`	`accumulateSecondary(CollectionX<Ior<ST,PT>> iors, Reducer<R> reducer)`
`static <ST,PT> Ior<?,ST>`	`accumulateSecondary(CollectionX<Ior<ST,PT>> iors, Semigroup<ST> reducer)`
`default AnyMValue<PT>`	`anyM()`
`default <U1,U2> Ior<U1,U2>`	`bicast(java.lang.Class<U1> type1, java.lang.Class<U2> type2)` Cast two data types simulatanously.
`default <R1,R2> Ior<R1,R2>`	`bimap(java.util.function.Function<? super ST,? extends R1> fn1, java.util.function.Function<? super PT,? extends R2> fn2)` Transform this BiFunctor, changing two value types at once.
`default Ior<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> Ior<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
`java.util.Optional<org.jooq.lambda.tuple.Tuple2<ST,PT>>`	`both()`
`static <ST,PT> Ior<ST,PT>`	`both(Ior<ST,PT> secondary, Ior<ST,PT> primary)`
`static <ST,PT> Ior<ST,PT>`	`both(ST secondary, PT primary)`
`default Value<java.util.Optional<org.jooq.lambda.tuple.Tuple2<ST,PT>>>`	`bothValue()`
`default <U> Ior<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> Ior<ST,R>`	`coflatMap(java.util.function.Function<? super MonadicValue<PT>,R> mapper)` Perform a coflatMap operation.
`default Ior<ST,PT>`	`combineEager(Monoid<PT> monoid, MonadicValue2<? extends ST,? extends PT> v2)` Eagerly combine two MonadicValues using the supplied monoid
`Ior<ST,PT>`	`filter(java.util.function.Predicate<? super PT> test)` Keep only elements for which the supplied predicates hold e.g.
`default Ior<ST,PT>`	`filterNot(java.util.function.Predicate<? super PT> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<LT1,RT1> Ior<LT1,RT1>`	`flatMap(java.util.function.Function<? super PT,? extends MonadicValue2<? extends LT1,? extends RT1>> mapper)` Perform a flattening transformation of this Monadicvalue2
`default <R> Ior<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 Publisher.
`default <R> Ior<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.
`static <ST,T> Ior<ST,T>`	`fromIterable(java.lang.Iterable<T> iterable)`
`static <T> Ior<java.lang.Throwable,T>`	`fromPublisher(org.reactivestreams.Publisher<T> pub)`
`PT`	`get()`
`boolean`	`isBoth()`
`default boolean`	`isPresent()`
`boolean`	`isPrimary()`
`boolean`	`isSecondary()`
`<R> Ior<ST,R>`	`map(java.util.function.Function<? super PT,? extends R> fn)` Transform this functor using the supplied transformation function
`<R> Eval<R>`	`matches(java.util.function.Function<Matchable.CheckValue1<ST,R>,Matchable.CheckValue1<ST,R>> secondary, java.util.function.Function<Matchable.CheckValue1<PT,R>,Matchable.CheckValue1<PT,R>> primary, java.util.function.Function<Matchable.CheckValue2<ST,PT,R>,Matchable.CheckValue2<ST,PT,R>> both, java.util.function.Supplier<? extends R> otherwise)`
`default Ior<ST,MonadicValue<PT>>`	`nest()` cojoin pattern.
`default Ior<ST,PT>`	`notNull()` Filter elements retaining only values which are not null
`default <U> Ior<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
`Ior<ST,PT>`	`peek(java.util.function.Consumer<? super PT> action)` Peek at the current value of this Functor, without transforming it
`static <ST,PT> Ior<ST,PT>`	`primary(PT primary)`
`static <ST,PT> Ior<ST,PT>`	`secondary(ST secondary)`
`<LT1,RT1> Ior<LT1,RT1>`	`secondaryFlatMap(java.util.function.Function<? super ST,? extends Ior<LT1,RT1>> mapper)`
`ST`	`secondaryGet()`
`<R> Ior<R,PT>`	`secondaryMap(java.util.function.Function<? super ST,? extends R> fn)`
`Ior<ST,PT>`	`secondaryPeek(java.util.function.Consumer<? super ST> action)`
`java.util.Optional<ST>`	`secondaryToOptional()`
`Ior<ST,PT>`	`secondaryToPrimayFlatMap(java.util.function.Function<? super ST,? extends Ior<ST,PT>> fn)`
`Ior<ST,PT>`	`secondaryToPrimayMap(java.util.function.Function<? super ST,? extends PT> fn)`
`ReactiveSeq<ST>`	`secondaryToStream()`
`Value<ST>`	`secondaryValue()`
`static <ST,PT> Ior<ListX<ST>,ListX<PT>>`	`sequencePrimary(CollectionX<Ior<ST,PT>> iors)`
`static <ST,PT> Ior<ListX<PT>,ListX<ST>>`	`sequenceSecondary(CollectionX<Ior<ST,PT>> iors)`
`Ior<PT,ST>`	`swap()`
`default Ior<ST,PT>`	`toIor()` Return an Ior that can be this object or a Ior.primary or Ior.secondary
`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
`Xor<ST,PT>`	`toXorDropPrimary()`
`default <R> Ior<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> Ior<ST,T>`	`unit(T unit)`
`default <R> R`	`visit(java.util.function.Function<? super ST,? extends R> secondary, java.util.function.Function<? super PT,? extends R> primary, java.util.function.BiFunction<? super ST,? super PT,? extends R> both)`
`default <T2,R> Ior<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> Ior<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> Ior<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> Ior<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> Ior<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> Ior<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> Ior<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.applicative.ApplicativeFunctor
applyFunctions, combine

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, toOptional, toOptionalAtomicReference, toStream, visit

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

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

Method Detail

fromPublisher

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

fromIterable

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

primary

static <ST,PT> Ior<ST,PT> primary(PT primary)

secondary

static <ST,PT> Ior<ST,PT> secondary(ST secondary)

both

static <ST,PT> Ior<ST,PT> both(Ior<ST,PT> secondary,
                               Ior<ST,PT> primary)

both

static <ST,PT> Ior<ST,PT> both(ST secondary,
                               PT primary)

flatMapIterable
```
default <R> Ior<ST,R> flatMapIterable(java.util.function.Function<? super PT,? extends java.lang.Iterable<? extends R>> mapper)
```
Description copied from interface: MonadicValue2
A flattening transformation operation that takes the first value from the returned Publisher.
```
 
 Xor.primary(1).map(i->i+2).flatMapPublisher(i->Arrays.asList(()->i*3,20);
 //Xor[9]
 
 
```
Specified by:

flatMapIterable in interface MonadicValue2<ST,PT>

Parameters:

mapper - transformation function

Returns:

MonadicValue2 the first element returned after the flatMap function is applied

flatMapPublisher
```
default <R> Ior<ST,R> flatMapPublisher(java.util.function.Function<? super PT,? extends org.reactivestreams.Publisher<? extends R>> mapper)
```
Description copied from interface: MonadicValue2
A flattening transformation operation that takes the first value from the returned Publisher.
```
 
 Ior.primary(1).map(i->i+2).flatMapPublisher(i->Flux.just(()->i*3,20);
 //Xor[9]
 
 
```
Specified by:

flatMapPublisher in interface MonadicValue2<ST,PT>

Parameters:

mapper - FlatMap transformation function

Returns:

MonadicValue2 subscribed from publisher after the flatMap function is applied

anyM
```
default AnyMValue<PT> anyM()
```
Specified by:

anyM in interface MonadicValue<PT>

Returns:

This monad wrapped as an AnyMValue

unit
```
default <T> Ior<ST,T> unit(T unit)
```
Specified by:

unit in interface MonadicValue<PT>

Specified by:

unit in interface MonadicValue2<ST,PT>

Specified by:

unit in interface Unit<PT>

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

Parameters:

test - to filter elements by, retaining matches

Returns:

Filterable with elements removed where the predicate does not hold

toXor
```
Xor<ST,PT> toXor()
```
Specified by:

toXor in interface Value<PT>

Returns:

Primary Xor that has the same value as this Value

toXorDropPrimary
```
Xor<ST,PT> toXorDropPrimary()
```

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

toIor
```
default 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

secondaryToPrimayMap

Ior<ST,PT> secondaryToPrimayMap(java.util.function.Function<? super ST,? extends PT> fn)

secondaryMap

<R> Ior<R,PT> secondaryMap(java.util.function.Function<? super ST,? extends R> fn)

map
```
<R> Ior<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>

Specified by:

map in interface MonadicValue2<ST,PT>

Parameters:

fn - Transformation function

Returns:

Transformed Functor

secondaryPeek

Ior<ST,PT> secondaryPeek(java.util.function.Consumer<? super ST> action)

peek
```
Ior<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
```
Ior<PT,ST> swap()
```

coflatMap
```
default <R> Ior<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 Ior<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 Ior<ST,PT> combineEager(Monoid<PT> monoid,
                                MonadicValue2<? extends ST,? extends PT> v2)

Description copied from interface: MonadicValue2

Eagerly combine two MonadicValues using the supplied monoid

  
 
  Monoid<Integer> add = Mondoid.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 MonadicValue2<ST,PT>
Parameters:: monoid - Monoid to be used to combine values; v2 - MonadicValue to combine with
Returns:: Combined MonadicValue

both

java.util.Optional<org.jooq.lambda.tuple.Tuple2<ST,PT>> both()

bothValue

default Value<java.util.Optional<org.jooq.lambda.tuple.Tuple2<ST,PT>>> bothValue()

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

bimap

default <R1,R2> Ior<R1,R2> bimap(java.util.function.Function<? super ST,? extends R1> fn1,
                                 java.util.function.Function<? super PT,? extends R2> fn2)

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:: fn1 - transformation function for the first type; fn2 - transformation function for the second type
Returns:: New BiFunctor containing transformed data

visit

default <R> R visit(java.util.function.Function<? super ST,? extends R> secondary,
                    java.util.function.Function<? super PT,? extends R> primary,
                    java.util.function.BiFunction<? super ST,? super PT,? extends R> both)

Parameters:: secondary -; primary -; both -
Returns:

matches

<R> Eval<R> matches(java.util.function.Function<Matchable.CheckValue1<ST,R>,Matchable.CheckValue1<ST,R>> secondary,
                    java.util.function.Function<Matchable.CheckValue1<PT,R>,Matchable.CheckValue1<PT,R>> primary,
                    java.util.function.Function<Matchable.CheckValue2<ST,PT,R>,Matchable.CheckValue2<ST,PT,R>> both,
                    java.util.function.Supplier<? extends R> otherwise)

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

isPresent
```
default boolean isPresent()
```
Specified by:

isPresent in interface Convertable<PT>

Returns:

True if value exists and is non-null

secondaryValue
```
Value<ST> secondaryValue()
```

secondaryGet
```
ST secondaryGet()
```

secondaryToOptional

java.util.Optional<ST> secondaryToOptional()

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

flatMap
```
<LT1,RT1> Ior<LT1,RT1> flatMap(java.util.function.Function<? super PT,? extends MonadicValue2<? extends LT1,? extends RT1>> mapper)
```
Description copied from interface: MonadicValue2

Perform a flattening transformation of this Monadicvalue2

Specified by:

flatMap in interface MonadicValue2<ST,PT>

Parameters:

mapper - transformation function

Returns:

Transformed MonadicValue2

secondaryFlatMap

<LT1,RT1> Ior<LT1,RT1> secondaryFlatMap(java.util.function.Function<? super ST,? extends Ior<LT1,RT1>> mapper)

secondaryToPrimayFlatMap

Ior<ST,PT> secondaryToPrimayFlatMap(java.util.function.Function<? super ST,? extends Ior<ST,PT>> fn)

isPrimary
```
boolean isPrimary()
```

isSecondary
```
boolean isSecondary()
```

isBoth
```
boolean isBoth()
```

sequenceSecondary

static <ST,PT> Ior<ListX<PT>,ListX<ST>> sequenceSecondary(CollectionX<Ior<ST,PT>> iors)

accumulateSecondary

static <ST,PT,R> Ior<?,R> accumulateSecondary(CollectionX<Ior<ST,PT>> iors,
                                              Reducer<R> reducer)

accumulateSecondary

static <ST,PT,R> Ior<?,R> accumulateSecondary(CollectionX<Ior<ST,PT>> iors,
                                              java.util.function.Function<? super ST,R> mapper,
                                              Semigroup<R> reducer)

accumulateSecondary

static <ST,PT> Ior<?,ST> accumulateSecondary(CollectionX<Ior<ST,PT>> iors,
                                             Semigroup<ST> reducer)

sequencePrimary

static <ST,PT> Ior<ListX<ST>,ListX<PT>> sequencePrimary(CollectionX<Ior<ST,PT>> iors)

accumulatePrimary

static <ST,PT,R> Ior<?,R> accumulatePrimary(CollectionX<Ior<ST,PT>> iors,
                                            Reducer<R> reducer)

accumulatePrimary

static <ST,PT,R> Ior<?,R> accumulatePrimary(CollectionX<Ior<ST,PT>> iors,
                                            java.util.function.Function<? super PT,R> mapper,
                                            Semigroup<R> reducer)

accumulatePrimary

static <ST,PT> Ior<?,PT> accumulatePrimary(CollectionX<Ior<ST,PT>> iors,
                                           Semigroup<PT> reducer)

ofType
```
default  Ior<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 Ior<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 Ior<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  Ior<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> Ior<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

bipeek
```
default Ior<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> Ior<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> Ior<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

zip
```
default <T2,R> Ior<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> Ior<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> Ior<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> Ior<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  Ior<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  Ior<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  Ior<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:

Interface Ior<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.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

primary

secondary

both

both

flatMapIterable

flatMapPublisher

anyM

unit

filter

toXor

toXorDropPrimary

toXor

toIor

secondaryToPrimayMap

secondaryMap

map

secondaryPeek

peek

swap

coflatMap

nest

combineEager

both

bothValue

patternMatch

bimap

visit

matches

get

isPresent

secondaryValue

secondaryGet

secondaryToOptional

secondaryToStream

flatMap

secondaryFlatMap

secondaryToPrimayFlatMap

isPrimary

isSecondary

isBoth

sequenceSecondary

accumulateSecondary

accumulateSecondary

accumulateSecondary

sequencePrimary

accumulatePrimary

accumulatePrimary

accumulatePrimary

ofType

filterNot

notNull

cast

trampoline

bipeek

bicast

bitrampoline

zip

zip

zip

zip

zip

zip

zip