Ior (cyclops 10.0.0-RC1 API)

Type Parameters:

LT - Left type

RT - Right type

All Superinterfaces:

BiTransformable<LT,RT>, Convert<Higher<Higher<DataWitness.ior,LT>,RT>>, Filters<RT>, Higher<Higher<DataWitness.ior,LT>,RT>, Higher2<DataWitness.ior,LT,RT>, io.kindedj.Hk<Higher<DataWitness.ior,LT>,RT>, java.lang.Iterable<RT>, OrElseValue<RT,Ior<LT,RT>>, org.reactivestreams.Publisher<RT>, SealedOr<RT>, To<Ior<LT,RT>>, Transformable<RT>, Unit<RT>, Value<RT>

All Known Implementing Classes:

Ior.Both, Ior.Primary, Ior.Secondary
```
public interface Ior<LT,RT>
extends To<Ior<LT,RT>>, Value<RT>, OrElseValue<RT,Ior<LT,RT>>, Unit<RT>, Transformable<RT>, Filters<RT>, BiTransformable<LT,RT>, Higher2<DataWitness.ior,LT,RT>
```
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 right type) biased disjunct union. No 'projections' are provided, swap() and secondaryXXXX alternative methods can be used instead. For exclusive or @see Either

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
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<PT,R>`	`accumulateLeft(java.lang.Iterable<Ior<ST,PT>> iors, java.util.function.Function<? super ST,R> mapper, Monoid<R> reducer)` Accumulate the results only from those Iors which have a Secondary type present, using the supplied mapping function to convert the data from each Ior 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> Ior<PT,R>`	`accumulateLeft(java.lang.Iterable<Ior<ST,PT>> iors, Reducer<R,ST> reducer)` Accumulate the result of the Secondary types in the Collection of Iors provided using the supplied Reducer `cyclops2.Reducers`.
`static <ST,PT> Ior<PT,ST>`	`accumulateLeft(Monoid<ST> reducer, java.lang.Iterable<Ior<ST,PT>> iors)` Accumulate the results only from those Iors 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` .
`static <ST,PT,R> Ior<ST,R>`	`accumulateRight(java.lang.Iterable<Ior<ST,PT>> iors, java.util.function.Function<? super PT,R> mapper, Semigroup<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 Ior before reducing them using the supplied Semgigroup (a combining BiFunction/BinaryOperator that takes two input values of the same type and returns the combined result) `cyclops2.SemigroupK` .
`static <ST,PT,R> Ior<ST,R>`	`accumulateRight(java.lang.Iterable<Ior<ST,PT>> iors, Reducer<R,PT> reducer)` Accumulate the result of the Primary types in the Collection of Iors provided using the supplied Reducer `cyclops2.Reducers`.
`static <ST,PT> Ior<ST,PT>`	`accumulateRight(java.lang.Iterable<Ior<ST,PT>> iors, Semigroup<PT> reducer)` Accumulate the results only from those Iors which have a Primary type present, using the supplied Semgigroup (a combining BiFunction/BinaryOperator that takes two input values of the same type and returns the combined result) `cyclops2.SemigroupK` .
`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(Ior<LT,RT> either)`
`default int`	`arity()`
`<R1,R2> Ior<R1,R2>`	`bimap(java.util.function.Function<? super LT,? extends R1> fn1, java.util.function.Function<? super RT,? extends R2> fn2)` Transform this BiTransformable, changing two value types at once.
`default Ior<LT,RT>`	`bipeek(java.util.function.Consumer<? super LT> c1, java.util.function.Consumer<? super RT> c2)` Peek at two data types simulatanously (typically to perform a side-effect with each data point)
`Option<Tuple2<LT,RT>>`	`both()`
`static <ST,PT> Ior<ST,PT>`	`both(ST left, PT right)` Create an Ior instance that contains both left and right types
`default <R> Ior<LT,R>`	`coflatMap(java.util.function.Function<? super Ior<LT,RT>,R> mapper)`
`static <X,LT extends X,M extends X,RT extends X> java.util.function.Consumer<java.util.function.Consumer<? super X>>`	`consumeAny(Ior<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)
`Option<RT>`	`filter(java.util.function.Predicate<? super RT> test)` Keep only elements for which the supplied predicates hold e.g.
`default Option<RT>`	`filterNot(java.util.function.Predicate<? super RT> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<RT1> Ior<LT,RT1>`	`flatMap(java.util.function.Function<? super RT,? extends Ior<? extends LT,? extends RT1>> mapper)`
`<LT1> Ior<LT1,RT>`	`flatMapLeft(java.util.function.Function<? super LT,? extends Ior<LT1,RT>> mapper)` Perform a flatMap operation on the Secondary type
`<R> R`	`fold(java.util.function.Function<? super LT,? extends R> secondary, java.util.function.Function<? super RT,? extends R> primary, java.util.function.BiFunction<? super LT,? super RT,? extends R> both)` Visitor pattern for this Ior.
`default <R1,R> Ior<LT,R>`	`forEach2(java.util.function.Function<? super RT,? extends Ior<LT,R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends R> yieldingFunction)`
`default <T2,R1,R2,R> Ior<LT,R>`	`forEach3(java.util.function.Function<? super RT,? extends Ior<LT,R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends Ior<LT,R2>> value2, Function3<? super RT,? super R1,? super R2,? extends R> yieldingFunction)`
`default <T2,R1,R2,R3,R> Ior<LT,R>`	`forEach4(java.util.function.Function<? super RT,? extends Ior<LT,R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends Ior<LT,R2>> value2, Function3<? super RT,? super R1,? super R2,? extends Ior<LT,R3>> value3, Function4<? super RT,? super R1,? super R2,? super R3,? extends R> yieldingFunction)`
`static <ST,T> Ior<ST,T>`	`fromIterable(java.lang.Iterable<T> iterable, T alt)` Construct an Ior that contains a single value extracted from the supplied Iterable
`static <T> Ior<java.lang.Throwable,T>`	`fromPublisher(org.reactivestreams.Publisher<T> pub)` Construct an Ior that contains a single value extracted from the supplied reactive-streams Publisher
`Option<RT>`	`get()`
`Option<LT>`	`getLeft()`
`boolean`	`isBoth()`
`boolean`	`isLeft()`
`default boolean`	`isPresent()`
`boolean`	`isRight()`
`static <LT,RT> Ior<LT,RT>`	`left(LT left)` Create an instance of the left type.
`<R> Ior<LT,R>`	`map(java.util.function.Function<? super RT,? extends R> fn)` Transform this functor using the supplied transformation function
`<R> Ior<R,RT>`	`mapLeft(java.util.function.Function<? super LT,? extends R> fn)`
`static <ST,T> Ior<ST,T>`	`narrowK(Higher<Higher<DataWitness.ior,ST>,T> ior)`
`static <ST,T> Ior<ST,T>`	`narrowK2(Higher2<DataWitness.ior,ST,T> ior)`
`default Ior<LT,Ior<LT,RT>>`	`nest()`
`default Option<RT>`	`notNull()` Filter elements retaining only values which are not null
`default <U> Option<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`Ior<LT,RT>`	`peek(java.util.function.Consumer<? super RT> action)` Peek at the current value of this Transformable, without transforming it
`Ior<LT,RT>`	`peekLeft(java.util.function.Consumer<? super LT> action)`
`Ior<LT,RT>`	`recover(RT value)`
`Ior<LT,RT>`	`recover(java.util.function.Supplier<? extends RT> value)`
`Ior<LT,RT>`	`recoverWith(java.util.function.Supplier<? extends Ior<LT,RT>> fn)`
`static <LT,RT> Ior<LT,RT>`	`right(RT right)` Create an instance of the right type.
`static <L,T> Ior<L,ReactiveSeq<T>>`	`sequence(ReactiveSeq<? extends Ior<L,T>> stream)`
`static <ST,PT> Ior<PT,ReactiveSeq<ST>>`	`sequenceLeft(java.lang.Iterable<? extends Ior<ST,PT>> iors)` Turn a toX of Iors into a single Ior with Lists of values.
`static <ST,PT> Ior<ST,ReactiveSeq<PT>>`	`sequenceRight(java.lang.Iterable<Ior<ST,PT>> iors)` Turn a toX of Iors into a single Ior with Lists of values.
`Ior<RT,LT>`	`swap()`
`Either<LT,RT>`	`toEither()`
`default <ST2> Either<ST2,RT>`	`toEither(ST2 secondary)` Convert to an Xor where the left value will be used if no right value is present
`Either<LT,RT>`	`toEitherDropRight()`
`static <L,T,R> Ior<L,ReactiveSeq<R>>`	`traverse(java.util.function.Function<? super T,? extends R> fn, ReactiveSeq<Ior<L,T>> stream)`
`default <T> Ior<LT,T>`	`unit(T unit)`
`static <X,LT extends X,RT extends X> X`	`visitAny(java.util.function.Consumer<? super X> c, Ior<LT,RT> either)`
`static <X,PT extends X,ST extends X,R> R`	`visitAny(Ior<ST,PT> either, java.util.function.Function<? super X,? extends R> fn)`
`static <L,T> Higher<Higher<DataWitness.ior,L>,T>`	`widen(Ior<L,T> narrow)`
`default <T2,R> Ior<LT,R>`	`zip(Either<LT,? extends T2> app, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)`
`default <T2,R> Ior<LT,R>`	`zip(Ior<LT,? extends T2> app, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)`

Methods inherited from interface com.oath.cyclops.types.foldable.To
to

Methods inherited from interface com.oath.cyclops.types.OrElseValue
orElseUse, orElseUse

Methods inherited from interface com.oath.cyclops.types.Value
asSupplier, collect, fold, forEach, generate, iterate, iterator, mkString, newSubscriber, nonEmptyList, nonEmptyListGet, orElse, orElseGet, print, print, printErr, printOut, stream, subscribe, toLazyEither, toLeft, toMaybe, toOption, toOptional, toRight, toTry, toTry, toTry, transform

Methods inherited from interface com.oath.cyclops.matching.SealedOr
fold

Methods inherited from interface java.lang.Iterable
spliterator

Methods inherited from interface com.oath.cyclops.hkt.Higher
applyHKT_, applyHKT, applyHKT

Methods inherited from interface com.oath.cyclops.hkt.Convert
convert

Method Detail

widen

static <L,T> Higher<Higher<DataWitness.ior,L>,T> widen(Ior<L,T> narrow)

recover

Ior<LT,RT> recover(java.util.function.Supplier<? extends RT> value)

recover
```
Ior<LT,RT> recover(RT value)
```

recoverWith

Ior<LT,RT> recoverWith(java.util.function.Supplier<? extends Ior<LT,RT>> fn)

arity
```
default int arity()
```

consumeAny
```
static <X,LT extends X,M extends X,RT extends X> java.util.function.Consumer<java.util.function.Consumer<? super X>> consumeAny(Ior<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(Ior<LT,RT> either)

visitAny

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

fromPublisher

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

Construct an Ior that contains a single value extracted from the supplied reactive-streams Publisher

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

        Ior<Throwable,Integer> future = Ior.fromPublisher(stream);

        //Ior[1]

Parameters:: pub - Publisher to extract value from
Returns:: Ior populated from Publisher

fromIterable

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

Construct an Ior that contains a single value extracted from the supplied Iterable

 
   List<Integer> list =  Arrays.asList(1,2,3);

        Ior<Throwable,Integer> future = Ior.fromPublisher(list);

        //Ior[1]

Parameters:: iterable - Iterable to extract value from
Returns:: Ior populated from Iterable

right
```
static <LT,RT> Ior<LT,RT> right(RT right)
```
Create an instance of the right type. Most methods are biased to the right type, which means, for example, that the transform method operates on the right type but does nothing on left Iors
```
 
   Ior.<Integer,Integer>right(10).map(i->i+1);
 //Ior.right[11]


 
 
```
Parameters:

right - To construct an Ior from

Returns:

Primary type instanceof Ior

left
```
static <LT,RT> Ior<LT,RT> left(LT left)
```
Create an instance of the left type. Most methods are biased to the right type, so you will need to use swap() or leftXXXX to manipulate the wrapped value
```
 
   Ior.<Integer,Integer>left(10).map(i->i+1);
   //Ior.left[10]

    Ior.<Integer,Integer>left(10).swap().map(i->i+1);
    //Ior.right[11]
 
 
```
Parameters:

left - to wrap

Returns:

Secondary instance of Ior

both
```
static <ST,PT> Ior<ST,PT> both(ST left,
                               PT right)
```
Create an Ior instance that contains both left and right types
```
 
    Ior<String,Ingeger> kv = Ior.both("hello",90);
    //Ior["hello",90]
 
 
```
Parameters:

left - Secondary value

right - Primary value

Returns:

Ior that contains both the left and the right value

forEach4

default <T2,R1,R2,R3,R> Ior<LT,R> forEach4(java.util.function.Function<? super RT,? extends Ior<LT,R1>> value1,
                                           java.util.function.BiFunction<? super RT,? super R1,? extends Ior<LT,R2>> value2,
                                           Function3<? super RT,? super R1,? super R2,? extends Ior<LT,R3>> value3,
                                           Function4<? super RT,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

forEach3

default <T2,R1,R2,R> Ior<LT,R> forEach3(java.util.function.Function<? super RT,? extends Ior<LT,R1>> value1,
                                        java.util.function.BiFunction<? super RT,? super R1,? extends Ior<LT,R2>> value2,
                                        Function3<? super RT,? super R1,? super R2,? extends R> yieldingFunction)

forEach2

default <R1,R> Ior<LT,R> forEach2(java.util.function.Function<? super RT,? extends Ior<LT,R1>> value1,
                                  java.util.function.BiFunction<? super RT,? super R1,? extends R> yieldingFunction)

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

unit in interface Unit<RT>

filter
```
Option<RT> filter(java.util.function.Predicate<? super RT> 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<RT>

Parameters:

test - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

toEither
```
Either<LT,RT> toEither()
```

toEitherDropRight
```
Either<LT,RT> toEitherDropRight()
```
Returns:

Convert to an Either, dropping the right type if this Ior contains both

toEither
```
default <ST2> Either<ST2,RT> toEither(ST2 secondary)
```
Description copied from interface: Value

Convert to an Xor where the left value will be used if no right value is present

Specified by:

toEither in interface Value<RT>

Parameters:

secondary - Value to use in case no right value is present

Returns:

Right Either with same value as this Value, or a Left Either with the provided Value if this Value is zero

mapLeft

<R> Ior<R,RT> mapLeft(java.util.function.Function<? super LT,? extends R> fn)

map
```
<R> Ior<LT,R> map(java.util.function.Function<? super RT,? 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 Transformable<RT>

Parameters:

fn - Transformation function

Returns:

Transformed Transformable

peekLeft

Ior<LT,RT> peekLeft(java.util.function.Consumer<? super LT> action)

peek
```
Ior<LT,RT> peek(java.util.function.Consumer<? super RT> 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<RT>

Parameters:

action - Consumer that recieves each element from this Transformable

Returns:

Transformable that will peek at each value

swap
```
Ior<RT,LT> swap()
```
Returns:

Ior with Primary and Secondary types and value swapped

coflatMap

default <R> Ior<LT,R> coflatMap(java.util.function.Function<? super Ior<LT,RT>,R> mapper)

nest
```
default Ior<LT,Ior<LT,RT>> nest()
```

both
```
Option<Tuple2<LT,RT>> both()
```
Returns:

An zero Option if this Ior only has lazy the Secondary or Primary type. Or an Optional containing a Tuple2 with both the Secondary and Primary types if they are both present.

bimap

<R1,R2> Ior<R1,R2> bimap(java.util.function.Function<? super LT,? extends R1> fn1,
                         java.util.function.Function<? super RT,? extends R2> fn2)

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

fold

<R> R fold(java.util.function.Function<? super LT,? extends R> secondary,
           java.util.function.Function<? super RT,? extends R> primary,
           java.util.function.BiFunction<? super LT,? super RT,? extends R> both)

Visitor pattern for this Ior. Execute the left function if this Ior contains an element of the left type only Execute the right function if this Ior contains an element of the right type only Execute the both function if this Ior contains an element of both type

 
  Ior.right(10)
     .visit(left->"no", right->"yes",(sec,pri)->"oops!")
  //Ior["yes"]

        Ior.left(90)
           .visit(left->"no", right->"yes",(sec,pri)->"oops!")
        //Ior["no"]

        Ior.both(10, "eek")
           .visit(left->"no", right->"yes",(sec,pri)->"oops!")
        //Ior["oops!"]

Parameters:: secondary - Function to execute if this is a Secondary Ior; 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

get
```
Option<RT> get()
```

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

isPresent in interface Value<RT>

getLeft
```
Option<LT> getLeft()
```

flatMap

<RT1> Ior<LT,RT1> flatMap(java.util.function.Function<? super RT,? extends Ior<? extends LT,? extends RT1>> mapper)

flatMapLeft
```
<LT1> Ior<LT1,RT> flatMapLeft(java.util.function.Function<? super LT,? extends Ior<LT1,RT>> mapper)
```
Perform a flatMap operation on the Secondary type

Parameters:

mapper - Flattening transformation function

Returns:

Ior containing the value inside the result of the transformation function as the Secondary value, if the Secondary type was present

isRight
```
boolean isRight()
```
Returns:

True if this is a right (only) Ior

isLeft
```
boolean isLeft()
```
Returns:

True if this was a left (only) Ior

isBoth
```
boolean isBoth()
```
Returns:

True if this Ior has both left and right types

sequenceLeft

static <ST,PT> Ior<PT,ReactiveSeq<ST>> sequenceLeft(java.lang.Iterable<? extends Ior<ST,PT>> iors)

Turn a toX of Iors into a single Ior with Lists of values. Primary and left types are swapped during this operation.

 
  Ior<String,Integer> just  = Ior.right(10);
        Ior<String,Integer> none = Ior.left("none");
  Ior<Seq<Integer>,Seq<String>> iors =Ior.sequenceLeft(Seq.of(just,none,Ior.right(1)));
        //Ior.right(Seq.of("none")))

Parameters:: iors - Iors to sequence
Returns:: Ior sequenced and swapped

accumulateLeft

static <ST,PT,R> Ior<PT,R> accumulateLeft(java.lang.Iterable<Ior<ST,PT>> iors,
                                          Reducer<R,ST> reducer)

Accumulate the result of the Secondary types in the Collection of Iors provided using the supplied Reducer cyclops2.Reducers.

 
  Ior<String,Integer> just  = Ior.right(10);
        Ior<String,Integer> none = Ior.left("none");
  Ior<?,PersistentSetX<String>> iors = Ior.accumulateLeft(Seq.of(just,none,Ior.right(1)),Reducers.<String>toPersistentSetX());
      //Ior.right(PersistentSetX.of("none"))));

Parameters:: iors - Collection of Iors to accumulate left values; reducer - Reducer to accumulate results
Returns:: Ior populated with the accumulate left operation

accumulateLeft
```
static <ST,PT,R> Ior<PT,R> accumulateLeft(java.lang.Iterable<Ior<ST,PT>> iors,
                                          java.util.function.Function<? super ST,R> mapper,
                                          Monoid<R> reducer)
```
Accumulate the results only from those Iors which have a Secondary type present, using the supplied mapping function to convert the data from each Ior 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 .
```
 
  Ior<String,Integer> just  = Ior.right(10);
        Ior<String,Integer> none = Ior.left("none");

  Ior<?,String> iors = Ior.accumulateLeft(Seq.of(just,none,Ior.left("1")),i->""+i,Monoids.stringConcat);
        //Ior.right("none1")

 
 
```
Parameters:

iors - Collection of Iors to accumulate left values

mapper - Mapping function to be applied to the result of each Ior

reducer - Semigroup to combine values from each Ior

Returns:

Ior populated with the accumulate Secondary operation

accumulateLeft
```
static <ST,PT> Ior<PT,ST> accumulateLeft(Monoid<ST> reducer,
                                         java.lang.Iterable<Ior<ST,PT>> iors)
```
Accumulate the results only from those Iors 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 .
```
 

  Ior<String,Integer> just  = Ior.right(10);
        Ior<String,Integer> none = Ior.left("none");

 Ior<?,Integer> iors = Ior.accumulateLeft(Monoids.intSum,Seq.of(Ior.both(2, "boo!"),Ior.left(1)));
       //Ior.right(3);  2+1


 
 
```
Parameters:

iors - Collection of Iors to accumulate left values

reducer - Semigroup to combine values from each Ior

Returns:

populated with the accumulate Secondary operation

sequenceRight

static <ST,PT> Ior<ST,ReactiveSeq<PT>> sequenceRight(java.lang.Iterable<Ior<ST,PT>> iors)

Turn a toX of Iors into a single Ior with Lists of values.

 

 Ior<String,Integer> just  = Ior.right(10);
       Ior<String,Integer> none = Ior.left("none");


 Ior<String,ReactiveSeq<Integer>> iors =Ior.sequenceRight(Seq.of(just,none,Ior.right(1)));
       //Ior.right(Seq.of(10,1)));

Parameters:: iors - Iors to sequence
Returns:: Ior Sequenced

sequence

static <L,T> Ior<L,ReactiveSeq<T>> sequence(ReactiveSeq<? extends Ior<L,T>> stream)

traverse

static <L,T,R> Ior<L,ReactiveSeq<R>> traverse(java.util.function.Function<? super T,? extends R> fn,
                                              ReactiveSeq<Ior<L,T>> stream)

accumulateRight

static <ST,PT,R> Ior<ST,R> accumulateRight(java.lang.Iterable<Ior<ST,PT>> iors,
                                           Reducer<R,PT> reducer)

Accumulate the result of the Primary types in the Collection of Iors provided using the supplied Reducer cyclops2.Reducers.

 
  Ior<String,Integer> just  = Ior.right(10);
        Ior<String,Integer> none = Ior.left("none");

  Ior<?,PersistentSetX<Integer>> iors =Ior.accumulateRight(Seq.of(just,none,Ior.right(1)),Reducers.toPersistentSetX());
        //Ior.right(PersistentSetX.of(10,1))));

Parameters:: iors - Collection of Iors to accumulate right values; reducer - Reducer to accumulate results
Returns:: Ior populated with the accumulate right operation

accumulateRight
```
static <ST,PT,R> Ior<ST,R> accumulateRight(java.lang.Iterable<Ior<ST,PT>> iors,
                                           java.util.function.Function<? super PT,R> mapper,
                                           Semigroup<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 Ior before reducing them using the supplied Semgigroup (a combining BiFunction/BinaryOperator that takes two input values of the same type and returns the combined result) cyclops2.SemigroupK .
```
 
  Ior<String,Integer> just  = Ior.right(10);
        Ior<String,Integer> none = Ior.left("none");

 Ior<?,String> iors = Ior.accumulateRight(Seq.of(just,none,Ior.right(1)),i->""+i,SemigroupK.stringConcat);
       //Ior.right("101"));
 
 
```
Parameters:

iors - Collection of Iors to accumulate right values

mapper - Mapping function to be applied to the result of each Ior

reducer - Reducer to accumulate results

Returns:

Ior populated with the accumulate right operation

accumulateRight

static <ST,PT> Ior<ST,PT> accumulateRight(java.lang.Iterable<Ior<ST,PT>> iors,
                                          Semigroup<PT> reducer)

Accumulate the results only from those Iors which have a Primary type present, using the supplied Semgigroup (a combining BiFunction/BinaryOperator that takes two input values of the same type and returns the combined result) cyclops2.SemigroupK .

 
  Ior<String,Integer> just  = Ior.right(10);
        Ior<String,Integer> none = Ior.left("none");

  Ior<?,Integer> iors =Ior.accumulateRight(Seq.of(just,none,Ior.right(1)),SemigroupK.intSum);
        //Ior.right(11);

Parameters:: iors - Collection of Iors to accumulate right values; reducer - Reducer to accumulate results
Returns:: Ior populated with the accumulate right operation

ofType

default <U> Option<U> ofType(java.lang.Class<? extends U> type)

Description copied from interface: Filters

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

 

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

Specified by:: ofType in interface Filters<RT>

filterNot
```
default Option<RT> filterNot(java.util.function.Predicate<? super RT> 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<RT>

Parameters:

fn - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

notNull
```
default Option<RT> 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<RT>

Returns:

Filters with nulls removed

bipeek
```
default Ior<LT,RT> bipeek(java.util.function.Consumer<? super LT> c1,
                          java.util.function.Consumer<? super RT> 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<LT,RT>

Parameters:

c1 - consumer for the first type

c2 - consumer for the second type

Returns:

New BiTransformable with the same data

zip

default <T2,R> Ior<LT,R> zip(Ior<LT,? extends T2> app,
                             java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)

zip

default <T2,R> Ior<LT,R> zip(Either<LT,? extends T2> app,
                             java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)

narrowK2

static <ST,T> Ior<ST,T> narrowK2(Higher2<DataWitness.ior,ST,T> ior)

narrowK

static <ST,T> Ior<ST,T> narrowK(Higher<Higher<DataWitness.ior,ST>,T> ior)

Interface Ior<LT,RT>

Nested Class Summary

Method Summary

Methods inherited from interface com.oath.cyclops.types.foldable.To

Methods inherited from interface com.oath.cyclops.types.OrElseValue

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

Methods inherited from interface com.oath.cyclops.matching.SealedOr

Methods inherited from interface java.lang.Iterable

Methods inherited from interface com.oath.cyclops.hkt.Higher

Methods inherited from interface com.oath.cyclops.hkt.Convert

Method Detail

widen

recover

recover

recoverWith

arity

consumeAny

applyAny

visitAny

visitAny

fromPublisher

fromIterable

right

left

both

forEach4

forEach3

forEach2

unit

filter

toEither

toEitherDropRight

toEither

mapLeft

map

peekLeft

peek

swap

coflatMap

nest

both

bimap

fold

get

isPresent

getLeft

flatMap

flatMapLeft

isRight

isLeft

isBoth

sequenceLeft

accumulateLeft

accumulateLeft

accumulateLeft

sequenceRight

sequence

traverse

accumulateRight

accumulateRight

accumulateRight

ofType

filterNot

notNull

bipeek

zip

zip

narrowK2

narrowK