Either (cyclops 10.3.2 API)

Type Parameters:

LT - Left type

RT - Right type

All Superinterfaces:

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

All Known Subinterfaces:

LazyEither<LT,RT>

All Known Implementing Classes:

Either.Left, Either.Right, LazyEither.CompletableEither, LazyEither.Lazy, LazyEither.Left, LazyEither.Right
```
public interface Either<LT,RT>
extends To<Either<LT,RT>>, BiTransformable<LT,RT>, Sealed2<LT,RT>, Value<RT>, OrElseValue<RT,Either<LT,RT>>, Unit<RT>, Transformable<RT>, Filters<RT>, java.io.Serializable, Higher2<DataWitness.either,LT,RT>
```
Either left or right. 'Right' (or right type) biased disjunct union. No 'projections' are provided, swap() and leftXXXX alternative methods can be used instead. Either 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{
           Either team;
     }

     Rather than

     public class Member{
```

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class Either.Left<L,R>

static class Either.Right<L,RT>

Nested Classes
Modifier and Type	Interface and Description
`static class`	`Either.Left<L,R>`
`static class`	`Either.Right<L,RT>`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`static <LT,RT,R> Either<RT,R>`	`accumulateLeft(java.lang.Iterable<Either<LT,RT>> xors, Reducer<R,LT> reducer)` Accumulate the result of the Left types in the Collection of Eithers provided using the supplied Reducer `cyclops2.Reducers`.
`static <ST,PT,R> Either<PT,R>`	`accumulateLeft(java.lang.Iterable<Either<ST,PT>> xors, java.util.function.Function<? super ST,R> mapper, Monoid<R> reducer)` Accumulate the results only from those Eithers which have a Left type present, using the supplied mapping function to convert the data from each Either 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> Either<PT,ST>`	`accumulateLeft(Monoid<ST> reducer, java.lang.Iterable<Either<ST,PT>> xors)` Accumulate the results only from those Eithers which have a Left 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 <LT,RT,R> Either<LT,R>`	`accumulateRight(java.lang.Iterable<Either<LT,RT>> xors, Reducer<R,RT> reducer)` Accumulate the result of the Right types in the Collection of Eithers provided using the supplied Reducer `cyclops2.Reducers`.
`static <ST,PT,R> Either<ST,R>`	`accumulateRight(java.lang.Iterable<Either<ST,PT>> xors, java.util.function.Function<? super PT,R> mapper, Monoid<R> reducer)` Accumulate the results only from those Iors which have a Right type present, using the supplied mapping function to convert the data from each Either 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> Either<ST,PT>`	`accumulateRight(Monoid<PT> reducer, java.lang.Iterable<Either<ST,PT>> xors)` Accumulate the results only from those Eithers which have a Right type present, using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) `cyclops2.Monoids` .
`static <X,LT extends X,M extends X,RT extends X,R> java.util.function.Function<java.util.function.Function<? super X,R>,R>`	`applyAny(Either<LT,RT> either)`
`default int`	`arity()`
`default <R1,R2> Either<R1,R2>`	`bimap(java.util.function.Function<? super LT,? extends R1> left, java.util.function.Function<? super RT,? extends R2> right)` Transform this BiTransformable, changing two value types at once.
`default Either<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)
`default <T2,R> Either<LT,R>`	`combine(Either<? extends LT,? extends T2> app, java.util.function.BinaryOperator<LT> semigroup, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)` Accumulate left values with the provided BinaryOperator / Semigroup `Semigroups` Right accumulation only occurs if all phases are right
`default <T2,R> Either<LazySeq<LT>,R>`	`combineToLazySeq(Either<LT,? extends T2> app, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)` Accumulate lefts into a LazySeq (extended Persistent List) and Right with the supplied combiner function Right accumulation only occurs if all phases are right
`default <T2,R> Either<Vector<LT>,R>`	`combineToVector(Either<LT,? extends T2> app, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)`
`static <X,LT extends X,M extends X,RT extends X> java.util.function.Consumer<java.util.function.Consumer<? super X>>`	`consumeAny(Either<LT,RT> either)` Static method useful as a method reference for fluent consumption of any value type stored in this Either (will capture the lowest common type)
`Option<RT>`	`filter(java.util.function.Predicate<? super RT> test)` Keep only elements for which the supplied predicates hold e.g.
`Either<LT,RT>`	`filter(java.util.function.Predicate<? super RT> test, java.util.function.Function<? super RT,? extends LT> rightToLeft)`
`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> Either<LT,RT1>`	`flatMap(java.util.function.Function<? super RT,? extends Either<? extends LT,? extends RT1>> mapper)`
`<LT1> Either<LT1,RT>`	`flatMapLeft(java.util.function.Function<? super LT,? extends Either<LT1,RT>> mapper)` Perform a flatMap operation on the Left type
`Either<LT,RT>`	`flatMapLeftToRight(java.util.function.Function<? super LT,? extends Either<LT,RT>> fn)` A flatMap operation that keeps the Left and Right types the same
`<R> R`	`fold(java.util.function.Function<? super LT,? extends R> left, java.util.function.Function<? super RT,? extends R> right)` Visitor pattern for this Ior.
`static <X,PT extends X,ST extends X,R> R`	`foldAny(Either<ST,PT> either, java.util.function.Function<? super X,? extends R> fn)`
`default <R1,R> Either<LT,R>`	`forEach2(java.util.function.Function<? super RT,? extends Either<LT,R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends R> yieldingFunction)`
`default <T2,R1,R2,R> Either<LT,R>`	`forEach3(java.util.function.Function<? super RT,? extends Either<LT,R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends Either<LT,R2>> value2, Function3<? super RT,? super R1,? super R2,? extends R> yieldingFunction)`
`default <T2,R1,R2,R3,R> Either<LT,R>`	`forEach4(java.util.function.Function<? super RT,? extends Either<LT,R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends Either<LT,R2>> value2, Function3<? super RT,? super R1,? super R2,? extends Either<LT,R3>> value3, Function4<? super RT,? super R1,? super R2,? super R3,? extends R> yieldingFunction)`
`static <ST,T> Either<ST,T>`	`fromIterable(java.lang.Iterable<T> iterable)` Construct a Right Either from the supplied Iterable
`static <T> Either<java.lang.Throwable,T>`	`fromPublisher(org.reactivestreams.Publisher<T> pub)` Construct a Right Either from the supplied publisher
`Option<RT>`	`get()`
`Option<LT>`	`getLeft()`
`boolean`	`isLeft()`
`default boolean`	`isPresent()`
`boolean`	`isRight()`
`default Either<LazySeq<LT>,RT>`	`lazySeq()`
`static <ST,PT> Either<ST,PT>`	`left(ST value)` Create an instance of the left type.
`LT`	`leftOrElse(LT alt)`
`ReactiveSeq<LT>`	`leftToStream()`
`<R> Either<LT,R>`	`map(java.util.function.Function<? super RT,? extends R> fn)` Transform this functor using the supplied transformation function
`<R> Either<R,RT>`	`mapLeft(java.util.function.Function<? super LT,? extends R> fn)` Always transform the Left type of this Either if it is present using the provided transformation function
`Either<LT,RT>`	`mapLeftToRight(java.util.function.Function<? super LT,? extends RT> fn)` If this Either contains the Left type, transform it's value so that it contains the Right type
`static <ST,T> Either<ST,T>`	`narrowK(Higher<Higher<DataWitness.either,ST>,T> xor)`
`static <ST,T> Either<ST,T>`	`narrowK2(Higher2<DataWitness.either,ST,T> xor)`
`default Either<LT,Either<LT,RT>>`	`nest()`
`default Eval<Either<LT,RT>>`	`nestedEval()`
`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.
`Either<LT,RT>`	`peek(java.util.function.Consumer<? super RT> action)` Peek at the current value of this Transformable, without transforming it
`Either<LT,RT>`	`peekLeft(java.util.function.Consumer<? super LT> action)` Peek at the Left type value if present
`Either<LT,RT>`	`recover(RT value)`
`Either<LT,RT>`	`recover(java.util.function.Supplier<? extends RT> value)`
`Either<LT,RT>`	`recoverWith(java.util.function.Supplier<? extends Either<LT,RT>> fn)`
`static <ST,PT> Either<ST,PT>`	`right(PT value)` Create an instance of the right type.
`static <L,T> Either<L,java.util.stream.Stream<T>>`	`sequence(java.util.stream.Stream<? extends Either<L,T>> stream)`
`static <ST,PT> Either<PT,ReactiveSeq<ST>>`	`sequenceLeft(java.lang.Iterable<Either<ST,PT>> xors)` Turn a Collection of Eithers into a single Either with Lists of values.
`static <ST,PT> Either<ST,ReactiveSeq<PT>>`	`sequenceRight(java.lang.Iterable<Either<ST,PT>> eithers)` Turn a Collection of Eithers into a single Either with Lists of values.
`Either<RT,LT>`	`swap()` Swap types so operations directly affect the current (pre-swap) Left type
`static <L,T,R> Either<L,R>`	`tailRec(T initial, java.util.function.Function<? super T,? extends Either<L,? extends Either<T,R>>> fn)`
`default <ST2> Either<ST2,RT>`	`toEither(ST2 left)` Convert to an Xor where the left value will be used if no right value is present
`Ior<LT,RT>`	`toIor()`
`default Trampoline<Either<LT,RT>>`	`toTrampoline()`
`static <L,T,R> Either<L,java.util.stream.Stream<R>>`	`traverse(java.util.function.Function<? super T,? extends R> fn, java.util.stream.Stream<Either<L,T>> stream)`
`default <T> Either<LT,T>`	`unit(T unit)`
`static <X,LT extends X,RT extends X> X`	`visitAny(java.util.function.Consumer<? super X> c, Either<LT,RT> either)`
`static <X,PT extends X,ST extends X,R> R`	`visitAny(Either<ST,PT> either, java.util.function.Function<? super X,? extends R> fn)` Deprecated.
`static <L,T> Higher<Higher<DataWitness.either,L>,T>`	`widen(Either<L,T> narrow)`
`default <T2,R> Either<LT,R>`	`zip(Either<LT,? extends T2> app, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)`
`default <T2,R> Either<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, nonEmptyList, nonEmptyListGet, orElse, orElseGet, print, print, printErr, printOut, stream, subscribe, toLazyEither, toLeft, toMaybe, toOption, toOptional, toRight, toTry, toTry, toTry

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

tailRec

static <L,T,R> Either<L,R> tailRec(T initial,
                                   java.util.function.Function<? super T,? extends Either<L,? extends Either<T,R>>> fn)

widen

static <L,T> Higher<Higher<DataWitness.either,L>,T> widen(Either<L,T> narrow)

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

nestedEval

default Eval<Either<LT,RT>> nestedEval()

consumeAny

static <X,LT extends X,M extends X,RT extends X> java.util.function.Consumer<java.util.function.Consumer<? super X>> consumeAny(Either<LT,RT> either)

Static method useful as a method reference for fluent consumption of any value type stored in this Either (will capture the lowest common type)

 

   myEither.to(Either::consumeAny)
                 .accept(System.out::println);

Parameters:: either - Either to consume value for
Returns:: Consumer we can 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(Either<LT,RT> either)

visitAny

@Deprecated
static <X,PT extends X,ST extends X,R> R visitAny(Either<ST,PT> either,
                                                              java.util.function.Function<? super X,? extends R> fn)

Deprecated.

foldAny

static <X,PT extends X,ST extends X,R> R foldAny(Either<ST,PT> either,
                                                 java.util.function.Function<? super X,? extends R> fn)

visitAny

static <X,LT extends X,RT extends X> X visitAny(java.util.function.Consumer<? super X> c,
                                                Either<LT,RT> either)

narrowK2

static <ST,T> Either<ST,T> narrowK2(Higher2<DataWitness.either,ST,T> xor)

narrowK

static <ST,T> Either<ST,T> narrowK(Higher<Higher<DataWitness.either,ST>,T> xor)

fromPublisher

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

Construct a Right Either from the supplied publisher

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

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

         //Either[1]

Parameters:: pub - Publisher to construct an Either from
Returns:: Either constructed from the supplied Publisher

fromIterable

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

Construct a Right Either from the supplied Iterable

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

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

         //Either[1]

Parameters:: iterable - Iterable to construct an Either from
Returns:: Either constructed from the supplied Iterable

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

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

value - to wrap

Returns:

Left instance of Either

right
```
static <ST,PT> Either<ST,PT> right(PT value)
```
Create an instance of the 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 Eithers
```
 
   Either.<Integer,Integer>right(10).map(i->i+1);
   //Either.right[11]


 
 
```
Parameters:

value - To construct an Either from

Returns:

Right type instanceof Either

forEach4

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

forEach3

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

forEach2

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

nest

default Either<LT,Either<LT,RT>> nest()

unit

default <T> Either<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

filter

Either<LT,RT> filter(java.util.function.Predicate<? super RT> test,
                     java.util.function.Function<? super RT,? extends LT> rightToLeft)

mapLeftToRight
```
Either<LT,RT> mapLeftToRight(java.util.function.Function<? super LT,? extends RT> fn)
```
If this Either contains the Left type, transform it's value so that it contains the Right type

Parameters:

fn - Function to transform left type to right

Returns:

Either with left type mapped to right

mapLeft
```
<R> Either<R,RT> mapLeft(java.util.function.Function<? super LT,? extends R> fn)
```
Always transform the Left type of this Either if it is present using the provided transformation function

Parameters:

fn - Transformation function for Left types

Returns:

Either with Left type transformed

map
```
<R> Either<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
```
Either<LT,RT> peekLeft(java.util.function.Consumer<? super LT> action)
```
Peek at the Left type value if present

Parameters:

action - Consumer to peek at the Left type value

Returns:

Either with the same values as before

peek
```
Either<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

Either<RT,LT> swap()

Swap types so operations directly affect the current (pre-swap) Left type

  

    Either.left("hello")
       .map(v->v+" world")
    //Either.seconary["hello"]

    Either.left("hello")
       .swap()
       .map(v->v+" world")
       .swap()
    //Either.seconary["hello world"]

Returns:: Swap the right and left types, allowing operations directly on what was the Left type

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

isPresent in interface Value<RT>

toEither
```
default <ST2> Either<ST2,RT> toEither(ST2 left)
```
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:

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

sequenceLeft

static <ST,PT> Either<PT,ReactiveSeq<ST>> sequenceLeft(java.lang.Iterable<Either<ST,PT>> xors)

Turn a Collection of Eithers into a single Either with Lists of values. Right and left types are swapped during this operation.

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

Parameters:: xors - Eithers to sequence
Returns:: Either sequenced and swapped

sequence

static <L,T> Either<L,java.util.stream.Stream<T>> sequence(java.util.stream.Stream<? extends Either<L,T>> stream)

traverse

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

accumulateLeft

static <LT,RT,R> Either<RT,R> accumulateLeft(java.lang.Iterable<Either<LT,RT>> xors,
                                             Reducer<R,LT> reducer)

Accumulate the result of the Left types in the Collection of Eithers provided using the supplied Reducer cyclops2.Reducers.

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

  Either<?,PersistentSetX<String>> xors = Either.accumulateLeft(Seq.of(just,none,Either.right(1)),Reducers.<String>toPersistentSetX());
      //Either.right(PersistentSetX.of("none"))));

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

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

  Either<?,String> xors = Either.accumulateLeft(Seq.of(just,none,Either.left("1")),i->""+i,Monoids.stringConcat);

        //Either.right("none1")

 
 
```
Parameters:

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

Either populated with the accumulate Left operation

sequenceRight

static <ST,PT> Either<ST,ReactiveSeq<PT>> sequenceRight(java.lang.Iterable<Either<ST,PT>> eithers)

Turn a Collection of Eithers into a single Either with Lists of values.

 

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


 Either<Seq<String>,Seq<Integer>> xors =Either.sequenceRight(Seq.of(just,none,Either.right(1)));
       //Either.right(Seq.of(10,1)));

Parameters:: eithers - Eithers to sequence
Returns:: Either Sequenced

accumulateRight

static <LT,RT,R> Either<LT,R> accumulateRight(java.lang.Iterable<Either<LT,RT>> xors,
                                              Reducer<R,RT> reducer)

Accumulate the result of the Right types in the Collection of Eithers provided using the supplied Reducer cyclops2.Reducers.

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

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

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

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

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

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

Either populated with the accumulate right operation

accumulateRight
```
static <ST,PT> Either<ST,PT> accumulateRight(Monoid<PT> reducer,
                                             java.lang.Iterable<Either<ST,PT>> xors)
```
Accumulate the results only from those Eithers which have a Right type present, using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two input values of the same type and returns the combined result) cyclops2.Monoids .
```
 
  Either<String,Integer> just  = Either.right(10);
        Either<String,Integer> none = Either.left("none");

  Either<?,Integer> xors XIor.accumulateRight(Monoids.intSum,Seq.of(just,none,Ior.right(1)));
        //Ior.right(11);

 
 
```
Parameters:

xors - Collection of Eithers to accumulate right values

reducer - Reducer to accumulate results

Returns:

Either populated with the accumulate right operation

accumulateLeft

static <ST,PT> Either<PT,ST> accumulateLeft(Monoid<ST> reducer,
                                            java.lang.Iterable<Either<ST,PT>> xors)

Accumulate the results only from those Eithers which have a Left 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 .

 
 Either.accumulateLeft(Seq.of(Either.left("failed1"),
    												Either.left("failed2"),
    												Either.right("success")),
    												SemigroupK.stringConcat)


 //Eithers.Right[failed1failed2]

 

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

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

Parameters:: xors - Collection of Eithers to accumulate left values; reducer - Semigroup to combine values from each Either
Returns:: Either populated with the accumulate Left operation

fold
```
<R> R fold(java.util.function.Function<? super LT,? extends R> left,
           java.util.function.Function<? super RT,? extends R> right)
```
Visitor pattern for this Ior. Execute the left function if this Either contains an element of the left type Execute the right function if this Either contains an element of the right type
```
 
  Either.right(10)
     .visit(left->"no", right->"yes")
  //Either["yes"]

        Either.left(90)
           .visit(left->"no", right->"yes")
        //Either["no"]



 
 
```
Specified by:

fold in interface Sealed2<LT,RT>

Parameters:

left - Function to execute if this is a Left Either

right - Function to execute if this is a Right Ior

Returns:

Result of executing the appropriate function

bimap

default <R1,R2> Either<R1,R2> bimap(java.util.function.Function<? super LT,? extends R1> left,
                                    java.util.function.Function<? super RT,? extends R2> right)

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:: left - transformation function for the first type; right - transformation function for the second type
Returns:: New BiTransformable containing transformed data

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

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

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

The Left Value if present, otherwise null

leftOrElse
```
LT leftOrElse(LT alt)
```

recover

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

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

recoverWith

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

leftToStream
```
ReactiveSeq<LT> leftToStream()
```
Returns:

A Stream containing the Either Left value if present, otherwise an zero Stream

flatMap

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

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

Parameters:

mapper - Flattening transformation function

Returns:

Either containing the value inside the result of the transformation function as the Left value, if the Left type was present

flatMapLeftToRight
```
Either<LT,RT> flatMapLeftToRight(java.util.function.Function<? super LT,? extends Either<LT,RT>> fn)
```
A flatMap operation that keeps the Left and Right types the same

Parameters:

fn - Transformation function

Returns:

Either

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

True if this is a right Either

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

True if this is a left Either

zip

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

zip

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

lazySeq

default Either<LazySeq<LT>,RT> lazySeq()

combineToLazySeq
```
default <T2,R> Either<LazySeq<LT>,R> combineToLazySeq(Either<LT,? extends T2> app,
                                                      java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)
```
Accumulate lefts into a LazySeq (extended Persistent List) and Right with the supplied combiner function Right accumulation only occurs if all phases are right

Parameters:

app - Value to combine with

fn - Combiner function for right values

Returns:

Combined Either

combineToVector

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

combine

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

Accumulate left values with the provided BinaryOperator / Semigroup Semigroups Right accumulation only occurs if all phases are right

 
  Either<String,String> fail1 =  Either.left("failed1");
        Either<LazySeq<String>,String> result = fail1.list().combine(Either.left("failed2").list(), SemigroupK.collectionConcat(),(a,b)->a+b);

        //Left of [LazySeq.of("failed1","failed2")))]

Parameters:: app - Value to combine with; semigroup - to combine left types; fn - To combine right types
Returns:: Combined Either

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

toIor
```
Ior<LT,RT> toIor()
```

toTrampoline

default Trampoline<Either<LT,RT>> toTrampoline()

Interface Either<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

tailRec

widen

arity

nestedEval

consumeAny

applyAny

visitAny

foldAny

visitAny

narrowK2

narrowK

fromPublisher

fromIterable

left

right

forEach4

forEach3

forEach2

nest

unit

filter

filter

mapLeftToRight

mapLeft

map

peekLeft

peek

swap

isPresent

toEither

sequenceLeft

sequence

traverse

accumulateLeft

accumulateLeft

sequenceRight

accumulateRight

accumulateRight

accumulateRight

accumulateLeft

fold

bimap

bipeek

get

getLeft

leftOrElse

recover

recover

recoverWith

leftToStream

flatMap

flatMapLeft

flatMapLeftToRight

isRight

isLeft

zip

zip

lazySeq

combineToLazySeq

combineToVector

combine

ofType

filterNot

notNull

toIor

toTrampoline