LazyEither3 (cyclops 10.1.0 API)

Type Parameters:

LT1 - Left1 type

LT2 - Left2 type

RT - Right type (operations are performed on this type if present)

All Superinterfaces:

BiTransformable<LT2,RT>, Convert<Higher<Higher<Higher<DataWitness.lazyEither3,LT1>,LT2>,RT>>, Filters<RT>, Higher<Higher<Higher<DataWitness.lazyEither3,LT1>,LT2>,RT>, Higher2<Higher<DataWitness.lazyEither3,LT1>,LT2,RT>, Higher3<DataWitness.lazyEither3,LT1,LT2,RT>, io.kindedj.Hk<Higher<Higher<DataWitness.lazyEither3,LT1>,LT2>,RT>, java.lang.Iterable<RT>, OrElseValue<RT,LazyEither3<LT1,LT2,RT>>, org.reactivestreams.Publisher<RT>, Sealed3<LT1,LT2,RT>, SealedOr<RT>, To<LazyEither3<LT1,LT2,RT>>, Transformable<RT>, Unit<RT>, Value<RT>

All Known Implementing Classes:

LazyEither3.CompletableEither3, LazyEither3.Lazy, LazyEither3.Left1, LazyEither3.Left2, LazyEither3.Right
```
public interface LazyEither3<LT1,LT2,RT>
extends Value<RT>, OrElseValue<RT,LazyEither3<LT1,LT2,RT>>, Unit<RT>, Transformable<RT>, Filters<RT>, BiTransformable<LT2,RT>, To<LazyEither3<LT1,LT2,RT>>, Sealed3<LT1,LT2,RT>, Higher3<DataWitness.lazyEither3,LT1,LT2,RT>
```
A right biased Lazy Either3 type. transform / flatMap operators are tail-call optimized Can be one of 3 types

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static class`	`LazyEither3.CompletableEither3<ORG,LT1,RT>`
`static class`	`LazyEither3.Lazy<ST,M,PT>`
`static class`	`LazyEither3.Left1<ST,M,PT>`
`static class`	`LazyEither3.Left2<ST,M,PT>`
`static class`	`LazyEither3.Right<ST,M,PT>`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`static <LT1,LT2,RT> LazyEither3<LT1,LT2,RT>`	`accumulate(Monoid<RT> reducer, java.lang.Iterable<LazyEither3<LT1,LT2,RT>> xors)` Accumulate the results only from those Either3 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) `com.oath.cyclops.Monoids` .
`static <ST,T,RT> LazyEither3<ST,T,RT>`	`always(java.util.function.Supplier<LazyEither3<ST,T,RT>> lazy)`
`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(LazyEither3<LT,M,RT> either)`
`<R1,R2> LazyEither3<LT1,R1,R2>`	`bimap(java.util.function.Function<? super LT2,? extends R1> fn1, java.util.function.Function<? super RT,? extends R2> fn2)` Transform this BiTransformable, changing two value types at once.
`default LazyEither3<LT1,LT2,RT>`	`bipeek(java.util.function.Consumer<? super LT2> 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 <R> LazyEither3<LT1,LT2,R>`	`coflatMap(java.util.function.Function<? super LazyEither3<LT1,LT2,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(LazyEither3<LT,M,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)
`static <LT2,RT> LazyEither3.CompletableEither3<RT,LT2,RT>`	`either3()` Create a reactive CompletableEither
`Maybe<RT>`	`filter(java.util.function.Predicate<? super RT> test)` Filter this Either3 resulting in a Maybe#none if it is not a Right instance or if the predicate does not hold.
`default LazyEither3<LT1,LT2,RT>`	`filter(java.util.function.Predicate<? super RT> test, java.util.function.Function<? super RT,? extends LT1> rightToLeft)`
`default Maybe<RT>`	`filterNot(java.util.function.Predicate<? super RT> predicate)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<R2> LazyEither3<LT1,LT2,R2>`	`flatMap(java.util.function.Function<? super RT,? extends LazyEither3<LT1,LT2,? extends R2>> mapper)` Flattening transformation on this Either3.
`<R> R`	`fold(java.util.function.Function<? super LT1,? extends R> left1, java.util.function.Function<? super LT2,? extends R> mid, java.util.function.Function<? super RT,? extends R> right)` Visit the types in this Either3, only one user supplied function is executed depending on the type
`static <X,LT extends X,M extends X,RT extends X,R> R`	`foldAny(LazyEither3<LT,M,RT> either, java.util.function.Function<? super X,? extends R> fn)`
`default <R1,R> LazyEither3<LT1,LT2,R>`	`forEach2(java.util.function.Function<? super RT,? extends LazyEither3<LT1,LT2,R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends R> yieldingFunction)`
`default <T2,R1,R2,R> LazyEither3<LT1,LT2,R>`	`forEach3(java.util.function.Function<? super RT,? extends LazyEither3<LT1,LT2,R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends LazyEither3<LT1,LT2,R2>> value2, Function3<? super RT,? super R1,? super R2,? extends R> yieldingFunction)`
`default <T2,R1,R2,R3,R> LazyEither3<LT1,LT2,R>`	`forEach4(java.util.function.Function<? super RT,? extends LazyEither3<LT1,LT2,R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends LazyEither3<LT1,LT2,R2>> value2, Function3<? super RT,? super R1,? super R2,? extends LazyEither3<LT1,LT2,R3>> value3, Function4<? super RT,? super R1,? super R2,? super R3,? extends R> yieldingFunction)`
`static <LT2,RT> LazyEither3<java.lang.Throwable,LT2,RT>`	`fromFuture(Future<RT> future)`
`static <ST,T,RT> LazyEither3<ST,T,RT>`	`fromIterable(java.lang.Iterable<RT> iterable)` Construct a Right Either3 from the supplied Iterable
`static <LT1,LT2,RT> LazyEither3<LT1,LT2,RT>`	`fromLazy(Eval<LazyEither3<LT1,LT2,RT>> lazy)`
`static <T1,T> LazyEither3<java.lang.Throwable,T1,T>`	`fromPublisher(org.reactivestreams.Publisher<T> pub)` Lazily construct a Right Either from the supplied publisher
`Option<RT>`	`get()`
`boolean`	`isLeft1()`
`boolean`	`isLeft2()`
`boolean`	`isRight()`
`static <ST,T,RT> LazyEither3<ST,T,RT>`	`later(java.util.function.Supplier<LazyEither3<ST,T,RT>> lazy)`
`static <LT,B,RT> LazyEither3<LT,B,RT>`	`left1(LT left)` Construct a Either3#Left1
`static <LT,B,RT> LazyEither3<LT,B,RT>`	`left1Eval(Eval<LT> left)` Construct a Either3#Left1 from an Eval
`static <LT,B,RT> LazyEither3<LT,B,RT>`	`left2(B middle)` Construct a Either3#Left2
`static <LT,B,RT> LazyEither3<LT,B,RT>`	`left2Eval(Eval<B> middle)` Construct a Either3#Left2 from an Eval
`<R> LazyEither3<LT1,LT2,R>`	`map(java.util.function.Function<? super RT,? extends R> fn)` Transform this functor using the supplied transformation function
`static <L1,L2,T> LazyEither3<L1,L2,T>`	`narrowK(Higher<Higher<Higher<DataWitness.lazyEither3,L1>,L2>,T> xor)`
`static <L1,L2,T> LazyEither3<L1,L2,T>`	`narrowK3(Higher3<DataWitness.lazyEither3,L1,L2,T> xor)`
`default LazyEither3<LT1,LT2,LazyEither3<LT1,LT2,RT>>`	`nest()`
`default Maybe<RT>`	`notNull()` Filter elements retaining only values which are not null
`default <U> Maybe<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`default LazyEither3<LT1,LT2,RT>`	`peek(java.util.function.Consumer<? super RT> c)` Peek at the current value of this Transformable, without transforming it
`static <LT,B,RT> LazyEither3<LT,B,RT>`	`right(RT right)` Construct a Either3#Right
`static <LT,B,RT> LazyEither3<LT,B,RT>`	`rightEval(Eval<RT> right)` Construct a Either3#Right from an Eval
`static <LT1,LT2,PT> LazyEither3<LT1,LT2,ReactiveSeq<PT>>`	`sequence(java.lang.Iterable<? extends LazyEither3<LT1,LT2,PT>> xors)` Turn an IterableX of Either3 into a single Either with Lists of values.
`static <L1,L2,T> LazyEither3<L1,L2,ReactiveSeq<T>>`	`sequence(ReactiveSeq<? extends LazyEither3<L1,L2,T>> stream)`
`LazyEither3<RT,LT2,LT1>`	`swap1()`
`LazyEither3<LT1,RT,LT2>`	`swap2()`
`default Either<LT1,RT>`	`toEither()`
`default Ior<LT1,RT>`	`toIor()` Return an Ior that can be this object or a Ior.right or Ior.left
`default Trampoline<LazyEither3<LT1,LT2,RT>>`	`toTrampoline()`
`static <L1,L2,T,R> LazyEither3<L1,L2,ReactiveSeq<R>>`	`traverse(java.util.function.Function<? super T,? extends R> fn, ReactiveSeq<LazyEither3<L1,L2,T>> stream)`
`static <LT1,LT2,PT,R> LazyEither3<LT1,LT2,ReactiveSeq<R>>`	`traverse(java.lang.Iterable<LazyEither3<LT1,LT2,PT>> xors, java.util.function.Function<? super PT,? extends R> fn)` Traverse a Collection of Either3 producing an Either3 with a Seq, applying the transformation function to every element in the list
`<T> LazyEither3<LT1,LT2,T>`	`unit(T unit)`
`static <X,LT extends X,M extends X,RT extends X> X`	`visitAny(java.util.function.Consumer<? super X> c, LazyEither3<LT,M,RT> either)`
`static <X,LT extends X,M extends X,RT extends X,R> R`	`visitAny(LazyEither3<LT,M,RT> either, java.util.function.Function<? super X,? extends R> fn)` Deprecated.
`static <LT1,LT2,T> Higher<Higher<Higher<DataWitness.lazyEither3,LT1>,LT2>,T>`	`widen(LazyEither3<LT1,LT2,T> narrow)`
`default <T2,R> LazyEither3<LT1,LT2,R>`	`zip(LazyEither3<LT1,LT2,? extends T2> app, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)`
`default <T2,R> LazyEither3<LT1,LT2,R>`	`zip(org.reactivestreams.Publisher<? extends T2> app, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)`

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, isPresent, iterate, iterator, mkString, nonEmptyList, nonEmptyListGet, orElse, orElseGet, print, print, printErr, printOut, stream, subscribe, toEither, 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.types.foldable.To
to

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 <LT1,LT2,T> Higher<Higher<Higher<DataWitness.lazyEither3,LT1>,LT2>,T> widen(LazyEither3<LT1,LT2,T> narrow)

filter

default LazyEither3<LT1,LT2,RT> filter(java.util.function.Predicate<? super RT> test,
                                       java.util.function.Function<? super RT,? extends LT1> rightToLeft)

zip

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

zip

default <T2,R> LazyEither3<LT1,LT2,R> zip(org.reactivestreams.Publisher<? extends T2> app,
                                          java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)

either3

static <LT2,RT> LazyEither3.CompletableEither3<RT,LT2,RT> either3()

Create a reactive CompletableEither

  
      ___Example 1___

      CompletableEither<Integer,Integer> completable = Either3.lazyEither3();
            Either3<Throwable,String,Integer> mapped = completable.map(i->i*2)
                                                                  .flatMap(i->Eval.later(()->i+1));

            completable.complete(5);

            mapped.printOut();
            //11

            ___Example 2___

            CompletableEither<Integer,Integer> completable = Either3.lazyEither3();
            Either3<Throwable,String,Integer> mapped = completable.map(i->i*2)
                                                                  .flatMap(i->Eval.later(()->i+1));


            completable.complete(null);

            //Either3:Left3[NoSuchElementException]

            ___Example 3___

            CompletableEither<Integer,Integer> completable = Either3.lazyEither3();
            Either3<Throwable,String,Integer> mapped = completable.map(i->i*2)
                                                                 .flatMap(i->Eval.later(()->i+1));

            completable.complete(new IllegalStateException());

    //Either:Left[IllegalStateElementException]

Type Parameters:: RT -
Returns:

fromLazy

static <LT1,LT2,RT> LazyEither3<LT1,LT2,RT> fromLazy(Eval<LazyEither3<LT1,LT2,RT>> lazy)

fromFuture

static <LT2,RT> LazyEither3<java.lang.Throwable,LT2,RT> fromFuture(Future<RT> future)

sequence

static <LT1,LT2,PT> LazyEither3<LT1,LT2,ReactiveSeq<PT>> sequence(java.lang.Iterable<? extends LazyEither3<LT1,LT2,PT>> xors)

Turn an IterableX of Either3 into a single Either with Lists of values.

 

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


 Either3<String,String,ReactiveSeq<Integer>> xors =Either3.sequence(Seq.of(just,none,Either3.right(1)));
       //Eitehr.right(ReactiveSeq.of(10,1)));

Parameters:: xors - Either3 to sequence
Returns:: Either3 Sequenced

sequence

static <L1,L2,T> LazyEither3<L1,L2,ReactiveSeq<T>> sequence(ReactiveSeq<? extends LazyEither3<L1,L2,T>> stream)

traverse

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

traverse
```
static <LT1,LT2,PT,R> LazyEither3<LT1,LT2,ReactiveSeq<R>> traverse(java.lang.Iterable<LazyEither3<LT1,LT2,PT>> xors,
                                                                   java.util.function.Function<? super PT,? extends R> fn)
```
Traverse a Collection of Either3 producing an Either3 with a Seq, applying the transformation function to every element in the list

Parameters:

xors - Either3s to sequence and transform

fn - Transformation function

Returns:

An Either3 with a transformed list

accumulate

static <LT1,LT2,RT> LazyEither3<LT1,LT2,RT> accumulate(Monoid<RT> reducer,
                                                       java.lang.Iterable<LazyEither3<LT1,LT2,RT>> xors)

Accumulate the results only from those Either3 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) com.oath.cyclops.Monoids .

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

  Either3<Seq<String>,Seq<String>,Integer> xors = Either3.accumulateRight(Monoids.intSum,Seq.of(just,none,Either3.right(1)));
        //Either3.right(11);

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

fromPublisher

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

Lazily construct a Right Either from the supplied publisher

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

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

         //Either[1]

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

fromIterable

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

Construct a Right Either3 from the supplied Iterable

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

         Either3<Throwable,String,Integer> future = Either3.fromIterable(list);

         //Either[1]

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

later

static <ST,T,RT> LazyEither3<ST,T,RT> later(java.util.function.Supplier<LazyEither3<ST,T,RT>> lazy)

always

static <ST,T,RT> LazyEither3<ST,T,RT> always(java.util.function.Supplier<LazyEither3<ST,T,RT>> lazy)

consumeAny

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

visitAny

@Deprecated
static <X,LT extends X,M extends X,RT extends X,R> R visitAny(LazyEither3<LT,M,RT> either,
                                                                          java.util.function.Function<? super X,? extends R> fn)

Deprecated.

foldAny

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

visitAny

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

rightEval
```
static <LT,B,RT> LazyEither3<LT,B,RT> rightEval(Eval<RT> right)
```
Construct a Either3#Right from an Eval

Parameters:

right - Eval to construct Either3#Right from

Returns:

Either3 right instance

left1Eval
```
static <LT,B,RT> LazyEither3<LT,B,RT> left1Eval(Eval<LT> left)
```
Construct a Either3#Left1 from an Eval

Parameters:

left - Eval to construct Either3#Left from

Returns:

Either3 left instance

right
```
static <LT,B,RT> LazyEither3<LT,B,RT> right(RT right)
```
Construct a Either3#Right

Parameters:

right - Value to store

Returns:

Either3 Right instance

left1
```
static <LT,B,RT> LazyEither3<LT,B,RT> left1(LT left)
```
Construct a Either3#Left1

Parameters:

left - Value to store

Returns:

Left instance

left2
```
static <LT,B,RT> LazyEither3<LT,B,RT> left2(B middle)
```
Construct a Either3#Left2

Parameters:

middle - Value to store

Returns:

Left2 instance

left2Eval
```
static <LT,B,RT> LazyEither3<LT,B,RT> left2Eval(Eval<B> middle)
```
Construct a Either3#Left2 from an Eval

Parameters:

middle - Eval to construct Either3#middle from

Returns:

Either3 Left2 instance

fold
```
<R> R fold(java.util.function.Function<? super LT1,? extends R> left1,
           java.util.function.Function<? super LT2,? extends R> mid,
           java.util.function.Function<? super RT,? extends R> right)
```
Visit the types in this Either3, only one user supplied function is executed depending on the type

Specified by:

fold in interface Sealed3<LT1,LT2,RT>

Parameters:

left1 - Function to execute if this Either3 is a Left instance

mid - Function to execute if this Either3 is a middle instance

right - Function to execute if this Either3 is a right instance

Returns:

Result of executed function

filter
```
Maybe<RT> filter(java.util.function.Predicate<? super RT> test)
```
Filter this Either3 resulting in a Maybe#none if it is not a Right instance or if the predicate does not hold. Otherwise results in a Maybe containing the current value

Specified by:

filter in interface Filters<RT>

Parameters:

test - Predicate to applyHKT to filter this Either3

Returns:

Maybe containing the current value if this is a Right instance and the predicate holds, otherwise Maybe#none

flatMap
```
<R2> LazyEither3<LT1,LT2,R2> flatMap(java.util.function.Function<? super RT,? extends LazyEither3<LT1,LT2,? extends R2>> mapper)
```
Flattening transformation on this Either3. Contains an internal trampoline so will convert tail-recursive calls to iteration.

Parameters:

mapper - Mapping function

Returns:

Mapped Either3

swap2
```
LazyEither3<LT1,RT,LT2> swap2()
```
Returns:

Swap the middle and the right types

swap1
```
LazyEither3<RT,LT2,LT1> swap1()
```
Returns:

Swap the right and left types

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

True if this lazy contains the right type

isLeft1
```
boolean isLeft1()
```
Returns:

True if this lazy contains the left1 type

isLeft2
```
boolean isLeft2()
```
Returns:

True if this lazy contains the left2 type

toIor
```
default Ior<LT1,RT> toIor()
```
Return an Ior that can be this object or a Ior.right or Ior.left

Returns:

new Ior

toEither
```
default Either<LT1,RT> toEither()
```

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

ofType

default <U> Maybe<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 Maybe<RT> filterNot(java.util.function.Predicate<? super RT> predicate)
```
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:

predicate - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

toTrampoline

default Trampoline<LazyEither3<LT1,LT2,RT>> toTrampoline()

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

coflatMap

default <R> LazyEither3<LT1,LT2,R> coflatMap(java.util.function.Function<? super LazyEither3<LT1,LT2,RT>,R> mapper)

nest

default LazyEither3<LT1,LT2,LazyEither3<LT1,LT2,RT>> nest()

forEach4

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

forEach3

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

forEach2

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

bimap

<R1,R2> LazyEither3<LT1,R1,R2> bimap(java.util.function.Function<? super LT2,? 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<LT2,RT>
Parameters:: fn1 - transformation function for the first type; fn2 - transformation function for the second type
Returns:: New BiTransformable containing transformed data

map
```
<R> LazyEither3<LT1,LT2,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

unit

<T> LazyEither3<LT1,LT2,T> unit(T unit)

Specified by:: unit in interface Unit<RT>

bipeek
```
default LazyEither3<LT1,LT2,RT> bipeek(java.util.function.Consumer<? super LT2> 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<LT2,RT>

Parameters:

c1 - consumer for the first type

c2 - consumer for the second type

Returns:

New BiTransformable with the same data

peek
```
default LazyEither3<LT1,LT2,RT> peek(java.util.function.Consumer<? super RT> c)
```
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:

c - Consumer that recieves each element from this Transformable

Returns:

Transformable that will peek at each value

narrowK3

static <L1,L2,T> LazyEither3<L1,L2,T> narrowK3(Higher3<DataWitness.lazyEither3,L1,L2,T> xor)

narrowK

static <L1,L2,T> LazyEither3<L1,L2,T> narrowK(Higher<Higher<Higher<DataWitness.lazyEither3,L1>,L2>,T> xor)

Interface LazyEither3<LT1,LT2,RT>

Nested Class Summary

Method Summary

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.types.foldable.To

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

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

Method Detail

widen

filter

zip

zip

either3

fromLazy

fromFuture

sequence

sequence

traverse

traverse

accumulate

fromPublisher

fromIterable

later

always

consumeAny

applyAny

visitAny

foldAny

visitAny

rightEval

left1Eval

right

left1

left2

left2Eval

fold

filter

flatMap

swap2

swap1

isRight

isLeft1

isLeft2

toIor

toEither

get

ofType

filterNot

toTrampoline

notNull

coflatMap

nest

forEach4

forEach3

forEach2

bimap

map

unit

bipeek

peek

narrowK3

narrowK