com.aol.cyclops.sum.types

Interface Either<ST,PT>

Type Parameters:

ST - Left type

PT - Right type

All Superinterfaces:

com.aol.cyclops.types.applicative.ApplicativeFunctor<PT>, com.aol.cyclops.types.BiFunctor<ST,PT>, com.aol.cyclops.types.Combiner<PT>, com.aol.cyclops.types.Convertable<PT>, com.aol.cyclops.types.ConvertableFunctor<PT>, com.aol.cyclops.types.Filterable<PT>, com.aol.cyclops.types.Foldable<PT>, com.aol.cyclops.types.Functor<PT>, java.lang.Iterable<PT>, com.aol.cyclops.types.MonadicValue<PT>, java.util.function.Predicate<PT>, org.reactivestreams.Publisher<PT>, java.util.function.Supplier<PT>, com.aol.cyclops.types.To<com.aol.cyclops.control.Xor<ST,PT>>, com.aol.cyclops.types.Unit<PT>, com.aol.cyclops.types.Value<PT>, com.aol.cyclops.types.Visitable<PT>, com.aol.cyclops.control.Xor<ST,PT>, com.aol.cyclops.types.Zippable<PT>

All Known Implementing Classes:

Either.Lazy, Either.Left, Either.Right

public interface Either<ST,PT>
extends com.aol.cyclops.control.Xor<ST,PT>

A totally Lazy Either implementation with tail call optimization for map and flatMap operators. 'Right' (or primary type) biased disjunct union. Often called Either, but in a generics heavy Java world Either is half the length of Either. No 'projections' are provided, swap() and secondaryXXXX alternative methods can be used instead. Either is used to represent values that can be one of two states (for example a validation result, either 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.Lazy<ST,PT>
static class	Either.Left<ST,PT>
static class	Either.Right<ST,PT>

Nested classes/interfaces inherited from interface com.aol.cyclops.control.Xor

com.aol.cyclops.control.Xor.Primary<ST,PT>, com.aol.cyclops.control.Xor.Secondary<ST,PT>

Nested classes/interfaces inherited from interface com.aol.cyclops.types.applicative.ApplicativeFunctor

com.aol.cyclops.types.applicative.ApplicativeFunctor.Applicatives, com.aol.cyclops.types.applicative.ApplicativeFunctor.ApplyFunctions<T>

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

com.aol.cyclops.types.Value.ValueImpl<T>

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

com.aol.cyclops.types.Convertable.SupplierToConvertable<T>

Method Summary

Modifier and Type	Method and Description
static <LT1,RT> Either<com.aol.cyclops.data.collections.extensions.standard.ListX<LT1>,RT>	accumulate(com.aol.cyclops.Monoid<RT> reducer, com.aol.cyclops.data.collections.extensions.CollectionX<Either<LT1,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) Monoids.
default com.aol.cyclops.types.anyM.AnyMValue<PT>	anyM()
static <LT1,T> com.aol.cyclops.types.anyM.AnyMValue<T>	anyM(Either<LT1,T> xor) Create an AnyMValue instance that wraps an Either3
static <ST,T> com.aol.cyclops.data.collections.extensions.standard.ListX<com.aol.cyclops.types.anyM.AnyMValue<T>>	anyMList(java.lang.Iterable<Either<ST,T>> anyM) Take an iterable containing Either3s and convert them into a List of AnyMs e.g.
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 <U1,U2> Either<U1,U2>	bicast(java.lang.Class<U1> type1, java.lang.Class<U2> type2)
default <R1,R2> Either<R1,R2>	bimap(java.util.function.Function<? super ST,? extends R1> secondary, java.util.function.Function<? super PT,? extends R2> primary)
default Either<ST,PT>	bipeek(java.util.function.Consumer<? super ST> c1, java.util.function.Consumer<? super PT> c2)
default <R1,R2> Either<R1,R2>	bitrampoline(java.util.function.Function<? super ST,? extends com.aol.cyclops.control.Trampoline<? extends R1>> mapper1, java.util.function.Function<? super PT,? extends com.aol.cyclops.control.Trampoline<? extends R2>> mapper2)
default <U> Either<ST,U>	cast(java.lang.Class<? extends U> type)
default <R> Either<ST,R>	coflatMap(java.util.function.Function<? super com.aol.cyclops.types.MonadicValue<PT>,R> mapper)
default Either<ST,PT>	combine(java.util.function.BinaryOperator<com.aol.cyclops.types.Combiner<PT>> combiner, com.aol.cyclops.types.Combiner<PT> app)
default <T2,R> Either<ST,R>	combine(Either<? extends ST,? extends T2> app, java.util.function.BinaryOperator<ST> semigroup, java.util.function.BiFunction<? super PT,? super T2,? extends R> fn) Accumulate secondary values with the provided BinaryOperator / Semigroup Semigroups Right accumulation only occurs if all phases are primary
<T2,R> Either<ST,R>	combine(com.aol.cyclops.types.Value<? extends T2> app, java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)
default <T2,R> Either<ST,R>	combine(com.aol.cyclops.control.Xor<? extends ST,? extends T2> app, java.util.function.BinaryOperator<ST> semigroup, java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)
default Either<ST,PT>	combineEager(com.aol.cyclops.Monoid<PT> monoid, com.aol.cyclops.types.MonadicValue<? extends PT> v2)
default <T2,R> Either<com.aol.cyclops.data.collections.extensions.persistent.PStackX<ST>,R>	combineToList(Either<ST,? extends T2> app, java.util.function.BiFunction<? super PT,? super T2,? extends R> fn) Accumulate secondarys into a PStackX (extended Persistent List) and Right with the supplied combiner function Right accumulation only occurs if all phases are primary
default <T2,R> Either<com.aol.cyclops.data.collections.extensions.persistent.PStackX<ST>,R>	combineToList(com.aol.cyclops.control.Xor<ST,? extends T2> app, java.util.function.BiFunction<? super PT,? 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)
Either<ST,PT>	filter(java.util.function.Predicate<? super PT> test)
default Either<ST,PT>	filterNot(java.util.function.Predicate<? super PT> fn)
<RT1> Either<ST,RT1>	flatMap(java.util.function.Function<? super PT,? extends com.aol.cyclops.types.MonadicValue<? extends RT1>> mapper)
default <R> Either<ST,R>	flatMapIterable(java.util.function.Function<? super PT,? extends java.lang.Iterable<? extends R>> mapper)
default <R> Either<ST,R>	flatMapPublisher(java.util.function.Function<? super PT,? extends org.reactivestreams.Publisher<? extends R>> mapper)
default <R1,R> Either<ST,R>	forEach2(java.util.function.Function<? super PT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1, java.util.function.BiFunction<? super PT,? super R1,? extends R> yieldingFunction)
default <R1,R> Either<ST,R>	forEach2(java.util.function.Function<? super PT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1, java.util.function.BiFunction<? super PT,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super PT,? super R1,? extends R> yieldingFunction)
default <T2,R1,R2,R> Either<ST,R>	forEach3(java.util.function.Function<? super PT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1, java.util.function.BiFunction<? super PT,? super R1,? extends com.aol.cyclops.types.MonadicValue<R2>> value2, com.aol.cyclops.util.function.TriFunction<? super PT,? super R1,? super R2,? extends R> yieldingFunction)
default <T2,R1,R2,R> Either<ST,R>	forEach3(java.util.function.Function<? super PT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1, java.util.function.BiFunction<? super PT,? super R1,? extends com.aol.cyclops.types.MonadicValue<R2>> value2, com.aol.cyclops.util.function.TriFunction<? super PT,? super R1,? super R2,java.lang.Boolean> filterFunction, com.aol.cyclops.util.function.TriFunction<? super PT,? super R1,? super R2,? extends R> yieldingFunction)
default <T2,R1,R2,R3,R> Either<ST,R>	forEach4(java.util.function.Function<? super PT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1, java.util.function.BiFunction<? super PT,? super R1,? extends com.aol.cyclops.types.MonadicValue<R2>> value2, com.aol.cyclops.util.function.TriFunction<? super PT,? super R1,? super R2,? extends com.aol.cyclops.types.MonadicValue<R3>> value3, com.aol.cyclops.util.function.QuadFunction<? super PT,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
default <T2,R1,R2,R3,R> Either<ST,R>	forEach4(java.util.function.Function<? super PT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1, java.util.function.BiFunction<? super PT,? super R1,? extends com.aol.cyclops.types.MonadicValue<R2>> value2, com.aol.cyclops.util.function.TriFunction<? super PT,? super R1,? super R2,? extends com.aol.cyclops.types.MonadicValue<R3>> value3, com.aol.cyclops.util.function.QuadFunction<? super PT,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, com.aol.cyclops.util.function.QuadFunction<? super PT,? 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 <LT1,RT> Either<LT1,RT>	fromMonadicValue(com.aol.cyclops.types.MonadicValue<RT> mv2)
static <T> Either<java.lang.Throwable,T>	fromPublisher(org.reactivestreams.Publisher<T> pub) Lazily construct a Right Either from the supplied publisher
PT	get()
boolean	isLeft()
default boolean	isPresent()
default boolean	isPrimary()
boolean	isRight()
default boolean	isSecondary()
static <ST,PT> Either<ST,PT>	left(ST value) Create an instance of the secondary type.
static <LT,B,RT> Either<LT,RT>	leftEval(com.aol.cyclops.control.Eval<LT> left)
default Either<com.aol.cyclops.data.collections.extensions.persistent.PStackX<ST>,PT>	list()
<R> Either<ST,R>	map(java.util.function.Function<? super PT,? extends R> fn)
default <R1,R2> Either<R1,R2>	mapBoth(java.util.function.Function<? super ST,? extends R1> secondary, java.util.function.Function<? super PT,? extends R2> primary) Deprecated.
<R> com.aol.cyclops.control.Eval<R>	matches(java.util.function.Function<com.aol.cyclops.control.Matchable.CheckValue1<ST,R>,com.aol.cyclops.control.Matchable.CheckValue1<ST,R>> fn1, java.util.function.Function<com.aol.cyclops.control.Matchable.CheckValue1<PT,R>,com.aol.cyclops.control.Matchable.CheckValue1<PT,R>> fn2, java.util.function.Supplier<? extends R> otherwise) Pattern match on the value/s inside this Either.
static <ST,PT> Either<ST,PT>	narrow(Either<? extends ST,? extends PT> broad)
default Either<ST,com.aol.cyclops.types.MonadicValue<PT>>	nest()
default Either<ST,PT>	notNull()
default <U> Either<ST,U>	ofType(java.lang.Class<? extends U> type)
default <R> Either<ST,R>	patternMatch(java.util.function.Function<com.aol.cyclops.control.Matchable.CheckValue1<PT,R>,com.aol.cyclops.control.Matchable.CheckValue1<PT,R>> case1, java.util.function.Supplier<? extends R> otherwise)
Either<ST,PT>	peek(java.util.function.Consumer<? super PT> action)
void	peek(java.util.function.Consumer<? super ST> stAction, java.util.function.Consumer<? super PT> ptAction) Deprecated.
static <ST,PT> Either<ST,PT>	right(PT value) Create an instance of the primary type.
static <LT,B,RT> Either<LT,RT>	rightEval(com.aol.cyclops.control.Eval<RT> right)
<LT1> Either<LT1,PT>	secondaryFlatMap(java.util.function.Function<? super ST,? extends com.aol.cyclops.control.Xor<LT1,PT>> mapper) Perform a flatMap operation on the Left type
ST	secondaryGet()
<R> Either<R,PT>	secondaryMap(java.util.function.Function<? super ST,? extends R> fn) Always map the Left type of this Either if it is present using the provided transformation function
Either<ST,PT>	secondaryPeek(java.util.function.Consumer<? super ST> action) Peek at the Left type value if present
java.util.Optional<ST>	secondaryToOptional()
Either<ST,PT>	secondaryToPrimayFlatMap(java.util.function.Function<? super ST,? extends com.aol.cyclops.control.Xor<ST,PT>> fn) A flatMap operation that keeps the Left and Right types the same
Either<ST,PT>	secondaryToPrimayMap(java.util.function.Function<? super ST,? extends PT> fn) If this Either contains the Left type, map it's value so that it contains the Right type
com.aol.cyclops.control.ReactiveSeq<ST>	secondaryToStream()
com.aol.cyclops.types.Value<ST>	secondaryValue()
static <LT1,PT> Either<com.aol.cyclops.data.collections.extensions.standard.ListX<LT1>,com.aol.cyclops.data.collections.extensions.standard.ListX<PT>>	sequence(com.aol.cyclops.data.collections.extensions.CollectionX<Either<LT1,PT>> xors) Turn a collection of Eithers into a single Either with Lists of values.
Either<PT,ST>	swap() Swap types so operations directly affect the current (pre-swap) Left type
com.aol.cyclops.control.Ior<ST,PT>	toIor()
default java.util.Optional<PT>	toOptional()
default com.aol.cyclops.control.Xor<ST,PT>	toXor()
default <ST2> com.aol.cyclops.control.Xor<ST2,PT>	toXor(ST2 secondary)
default <R> Either<ST,R>	trampoline(java.util.function.Function<? super PT,? extends com.aol.cyclops.control.Trampoline<? extends R>> mapper)
static <LT1,PT,R> Either<com.aol.cyclops.data.collections.extensions.standard.ListX<LT1>,com.aol.cyclops.data.collections.extensions.standard.ListX<R>>	traverse(com.aol.cyclops.data.collections.extensions.CollectionX<Either<LT1,PT>> xors, java.util.function.Function<? super PT,? extends R> fn) Traverse a Collection of Either producting an Either3 with a ListX, applying the transformation function to every element in the list
default <T> Either<ST,T>	unit(T unit)
<R> R	visit(java.util.function.Function<? super ST,? extends R> secondary, java.util.function.Function<? super PT,? extends R> primary) Visitor pattern for this Ior.
static <X,LT extends X,RT extends X> X	visitAny(java.util.function.Consumer<? super X> c, 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)
default <T2,R> Either<ST,R>	zip(java.util.function.BiFunction<? super PT,? super T2,? extends R> fn, org.reactivestreams.Publisher<? extends T2> app)
default <T2,R> Either<ST,R>	zip(java.lang.Iterable<? extends T2> app, java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)
default <U> Either<ST,org.jooq.lambda.tuple.Tuple2<PT,U>>	zip(java.lang.Iterable<? extends U> other)
default <U> Either<ST,org.jooq.lambda.tuple.Tuple2<PT,U>>	zip(org.jooq.lambda.Seq<? extends U> other)
default <U,R> Either<ST,R>	zip(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiFunction<? super PT,? super U,? extends R> zipper)
default <U> Either<ST,org.jooq.lambda.tuple.Tuple2<PT,U>>	zip(java.util.stream.Stream<? extends U> other)
default <U,R> Either<ST,R>	zip(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super PT,? super U,? extends R> zipper)

Methods inherited from interface com.aol.cyclops.control.Xor

accumulatePrimary, accumulatePrimary, accumulatePrimary, accumulateSecondary, accumulateSecondary, accumulateSecondary, primary, secondary, sequencePrimary, sequenceSecondary

Methods inherited from interface com.aol.cyclops.types.To

to

Methods inherited from interface com.aol.cyclops.types.applicative.ApplicativeFunctor

applyFunctions

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

collect, fold, fold, generate, iterate, iterator, mapReduce, mkString, newSubscriber, of, stream, subscribe, test, toDequeX, toEvalAlways, toEvalLater, toEvalNow, toFeatureToggle, toFutureStream, toFutureStream, toLazyImmutable, toList, toListX, toMaybe, toMutable, toPBagX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toTry, toTry, toTry, unapply

Methods inherited from interface com.aol.cyclops.types.Foldable

endsWith, endsWithIterable, findAny, findFirst, firstValue, foldable, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, join, join, join, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleOptional, startsWith, startsWithIterable, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, validate, xMatch

Methods inherited from interface com.aol.cyclops.types.Convertable

collect, fromSupplier, orElse, orElseGet, orElseThrow, toAtomicReference, toCompletableFuture, toCompletableFutureAsync, toCompletableFutureAsync, toFutureW, toFutureWAsync, toFutureWAsync, toOptionalAtomicReference, toStream, visit

Methods inherited from interface java.util.function.Predicate

and, isEqual, negate, or

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Method Detail

fromMonadicValue

static <LT1,RT> Either<LT1,RT> fromMonadicValue(com.aol.cyclops.types.MonadicValue<RT> mv2)

anyM

static <LT1,T> com.aol.cyclops.types.anyM.AnyMValue<T> anyM(Either<LT1,T> xor)

Create an AnyMValue instance that wraps an Either3

Parameters:

xor - Xor to wrap inside an AnyM

Returns:

AnyM instance that wraps the provided Either

anyMList

static <ST,T> com.aol.cyclops.data.collections.extensions.standard.ListX<com.aol.cyclops.types.anyM.AnyMValue<T>> anyMList(java.lang.Iterable<Either<ST,T>> anyM)

Take an iterable containing Either3s and convert them into a List of AnyMs e.g. List<AnyM<Integer>> anyMs = anyMList(Arrays.asList(Either.right(1),Either.left(10)); //List[AnyM[Either.right[1],Either:left[10]]]

Parameters:

anyM - Iterable containing Eithers

Returns:

List of AnyMs

sequence

static <LT1,PT> Either<com.aol.cyclops.data.collections.extensions.standard.ListX<LT1>,com.aol.cyclops.data.collections.extensions.standard.ListX<PT>> sequence(com.aol.cyclops.data.collections.extensions.CollectionX<Either<LT1,PT>> xors)

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<ListX<String>,ListX<Integer>> xors =Either.sequence(ListX.of(just,none,Either.right(1)));
       //Eitehr.right(ListX.of(10,1)));
 
 

Parameters:

Either - Either to sequence

Returns:

Either Sequenced

traverse

static <LT1,PT,R> Either<com.aol.cyclops.data.collections.extensions.standard.ListX<LT1>,com.aol.cyclops.data.collections.extensions.standard.ListX<R>> traverse(com.aol.cyclops.data.collections.extensions.CollectionX<Either<LT1,PT>> xors,
                                                                                                                                                                 java.util.function.Function<? super PT,? extends R> fn)

Traverse a Collection of Either producting an Either3 with a ListX, applying the transformation function to every element in the list

Parameters:

xors - Eithers to sequence and transform

fn - Transformation function

Returns:

An Either with a transformed list

accumulate

static <LT1,RT> Either<com.aol.cyclops.data.collections.extensions.standard.ListX<LT1>,RT> accumulate(com.aol.cyclops.Monoid<RT> reducer,
                                                                                                      com.aol.cyclops.data.collections.extensions.CollectionX<Either<LT1,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) Monoids.

  
 Either3<String,String,Integer> just  = Either3.right(10);
       Either3<String,String,Integer> none = Either3.left("none");
  
  Either3<ListX<String>,ListX<String>,Integer> xors = Either3.accumulatePrimary(Monoids.intSum,ListX.of(just,none,Either3.right(1)));
        //Either3.right(11);
 
 
 

Parameters:

xors - Collection of Eithers to accumulate primary values

reducer - Reducer to accumulate results

Returns:

Either populated with the accumulate primary operation

rightEval

static <LT,B,RT> Either<LT,RT> rightEval(com.aol.cyclops.control.Eval<RT> right)

leftEval

static <LT,B,RT> Either<LT,RT> leftEval(com.aol.cyclops.control.Eval<LT> left)

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

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

forEach4

default <T2,R1,R2,R3,R> Either<ST,R> forEach4(java.util.function.Function<? super PT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1,
                                              java.util.function.BiFunction<? super PT,? super R1,? extends com.aol.cyclops.types.MonadicValue<R2>> value2,
                                              com.aol.cyclops.util.function.TriFunction<? super PT,? super R1,? super R2,? extends com.aol.cyclops.types.MonadicValue<R3>> value3,
                                              com.aol.cyclops.util.function.QuadFunction<? super PT,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Specified by:

forEach4 in interface com.aol.cyclops.types.MonadicValue<PT>

Specified by:

forEach4 in interface com.aol.cyclops.control.Xor<ST,PT>

forEach4

default <T2,R1,R2,R3,R> Either<ST,R> forEach4(java.util.function.Function<? super PT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1,
                                              java.util.function.BiFunction<? super PT,? super R1,? extends com.aol.cyclops.types.MonadicValue<R2>> value2,
                                              com.aol.cyclops.util.function.TriFunction<? super PT,? super R1,? super R2,? extends com.aol.cyclops.types.MonadicValue<R3>> value3,
                                              com.aol.cyclops.util.function.QuadFunction<? super PT,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
                                              com.aol.cyclops.util.function.QuadFunction<? super PT,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Specified by:

forEach4 in interface com.aol.cyclops.types.MonadicValue<PT>

Specified by:

forEach4 in interface com.aol.cyclops.control.Xor<ST,PT>

forEach3

default <T2,R1,R2,R> Either<ST,R> forEach3(java.util.function.Function<? super PT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1,
                                           java.util.function.BiFunction<? super PT,? super R1,? extends com.aol.cyclops.types.MonadicValue<R2>> value2,
                                           com.aol.cyclops.util.function.TriFunction<? super PT,? super R1,? super R2,? extends R> yieldingFunction)

Specified by:

forEach3 in interface com.aol.cyclops.types.MonadicValue<PT>

Specified by:

forEach3 in interface com.aol.cyclops.control.Xor<ST,PT>

forEach3

default <T2,R1,R2,R> Either<ST,R> forEach3(java.util.function.Function<? super PT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1,
                                           java.util.function.BiFunction<? super PT,? super R1,? extends com.aol.cyclops.types.MonadicValue<R2>> value2,
                                           com.aol.cyclops.util.function.TriFunction<? super PT,? super R1,? super R2,java.lang.Boolean> filterFunction,
                                           com.aol.cyclops.util.function.TriFunction<? super PT,? super R1,? super R2,? extends R> yieldingFunction)

Specified by:

forEach3 in interface com.aol.cyclops.types.MonadicValue<PT>

Specified by:

forEach3 in interface com.aol.cyclops.control.Xor<ST,PT>

forEach2

default <R1,R> Either<ST,R> forEach2(java.util.function.Function<? super PT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1,
                                     java.util.function.BiFunction<? super PT,? super R1,? extends R> yieldingFunction)

Specified by:

forEach2 in interface com.aol.cyclops.types.MonadicValue<PT>

Specified by:

forEach2 in interface com.aol.cyclops.control.Xor<ST,PT>

forEach2

default <R1,R> Either<ST,R> forEach2(java.util.function.Function<? super PT,? extends com.aol.cyclops.types.MonadicValue<R1>> value1,
                                     java.util.function.BiFunction<? super PT,? super R1,java.lang.Boolean> filterFunction,
                                     java.util.function.BiFunction<? super PT,? super R1,? extends R> yieldingFunction)

Specified by:

forEach2 in interface com.aol.cyclops.types.MonadicValue<PT>

Specified by:

forEach2 in interface com.aol.cyclops.control.Xor<ST,PT>

combineToList

default <T2,R> Either<com.aol.cyclops.data.collections.extensions.persistent.PStackX<ST>,R> combineToList(com.aol.cyclops.control.Xor<ST,? extends T2> app,
                                                                                                          java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)

Specified by:

combineToList in interface com.aol.cyclops.control.Xor<ST,PT>

combine

default <T2,R> Either<ST,R> combine(com.aol.cyclops.control.Xor<? extends ST,? extends T2> app,
                                    java.util.function.BinaryOperator<ST> semigroup,
                                    java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)

Specified by:

combine in interface com.aol.cyclops.control.Xor<ST,PT>

fromPublisher

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

Lazily 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]
 
 
 

Specified by:

fromPublisher in interface com.aol.cyclops.control.Xor<ST,PT>

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.fromIterable(list);
        
         //Either[1]
 
 
 

Specified by:

fromIterable in interface com.aol.cyclops.control.Xor<ST,PT>

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 secondary type. Most methods are biased to the primary type, so you will need to use swap() or secondaryXXXX 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 primary type. Most methods are biased to the primary type, which means, for example, that the map method operates on the primary type but does nothing on secondary 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

anyM

default com.aol.cyclops.types.anyM.AnyMValue<PT> anyM()

Specified by:

anyM in interface com.aol.cyclops.types.MonadicValue<PT>

Specified by:

anyM in interface com.aol.cyclops.control.Xor<ST,PT>

combine

default Either<ST,PT> combine(java.util.function.BinaryOperator<com.aol.cyclops.types.Combiner<PT>> combiner,
                              com.aol.cyclops.types.Combiner<PT> app)

Specified by:

combine in interface com.aol.cyclops.types.Combiner<PT>

Specified by:

combine in interface com.aol.cyclops.control.Xor<ST,PT>

flatMapIterable

default <R> Either<ST,R> flatMapIterable(java.util.function.Function<? super PT,? extends java.lang.Iterable<? extends R>> mapper)

Specified by:

flatMapIterable in interface com.aol.cyclops.types.MonadicValue<PT>

Specified by:

flatMapIterable in interface com.aol.cyclops.control.Xor<ST,PT>

flatMapPublisher

default <R> Either<ST,R> flatMapPublisher(java.util.function.Function<? super PT,? extends org.reactivestreams.Publisher<? extends R>> mapper)

Specified by:

flatMapPublisher in interface com.aol.cyclops.types.MonadicValue<PT>

Specified by:

flatMapPublisher in interface com.aol.cyclops.control.Xor<ST,PT>

coflatMap

default <R> Either<ST,R> coflatMap(java.util.function.Function<? super com.aol.cyclops.types.MonadicValue<PT>,R> mapper)

Specified by:

coflatMap in interface com.aol.cyclops.types.MonadicValue<PT>

Specified by:

coflatMap in interface com.aol.cyclops.control.Xor<ST,PT>

nest

default Either<ST,com.aol.cyclops.types.MonadicValue<PT>> nest()

Specified by:

nest in interface com.aol.cyclops.types.MonadicValue<PT>

Specified by:

nest in interface com.aol.cyclops.control.Xor<ST,PT>

combineEager

default Either<ST,PT> combineEager(com.aol.cyclops.Monoid<PT> monoid,
                                   com.aol.cyclops.types.MonadicValue<? extends PT> v2)

Specified by:

combineEager in interface com.aol.cyclops.types.MonadicValue<PT>

Specified by:

combineEager in interface com.aol.cyclops.control.Xor<ST,PT>

unit

default <T> Either<ST,T> unit(T unit)

Specified by:

unit in interface com.aol.cyclops.types.MonadicValue<PT>

Specified by:

unit in interface com.aol.cyclops.types.Unit<PT>

Specified by:

unit in interface com.aol.cyclops.control.Xor<ST,PT>

toOptional

default java.util.Optional<PT> toOptional()

Specified by:

toOptional in interface com.aol.cyclops.types.Convertable<PT>

Specified by:

toOptional in interface com.aol.cyclops.control.Xor<ST,PT>

filter

Either<ST,PT> filter(java.util.function.Predicate<? super PT> test)

Specified by:

filter in interface com.aol.cyclops.types.Filterable<PT>

Specified by:

filter in interface com.aol.cyclops.types.MonadicValue<PT>

Specified by:

filter in interface com.aol.cyclops.control.Xor<ST,PT>

secondaryToPrimayMap

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

If this Either contains the Left type, map it's value so that it contains the Right type

Specified by:

secondaryToPrimayMap in interface com.aol.cyclops.control.Xor<ST,PT>

Parameters:

fn - Function to map secondary type to primary

Returns:

Either with secondary type mapped to primary

secondaryMap

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

Always map the Left type of this Either if it is present using the provided transformation function

Specified by:

secondaryMap in interface com.aol.cyclops.control.Xor<ST,PT>

Parameters:

fn - Transformation function for Left types

Returns:

Either with Left type transformed

map

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

Specified by:

map in interface com.aol.cyclops.types.ConvertableFunctor<PT>

Specified by:

map in interface com.aol.cyclops.types.Functor<PT>

Specified by:

map in interface com.aol.cyclops.types.MonadicValue<PT>

Specified by:

map in interface com.aol.cyclops.control.Xor<ST,PT>

secondaryPeek

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

Peek at the Left type value if present

Specified by:

secondaryPeek in interface com.aol.cyclops.control.Xor<ST,PT>

Parameters:

action - Consumer to peek at the Left type value

Returns:

Either with the same values as before

peek

Either<ST,PT> peek(java.util.function.Consumer<? super PT> action)

Specified by:

peek in interface com.aol.cyclops.types.Functor<PT>

Specified by:

peek in interface com.aol.cyclops.control.Xor<ST,PT>

swap

Either<PT,ST> 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"]
  
  

Specified by:

swap in interface com.aol.cyclops.control.Xor<ST,PT>

Returns:

Swap the primary and secondary types, allowing operations directly on what was the Left type

toIor

com.aol.cyclops.control.Ior<ST,PT> toIor()

Specified by:

toIor in interface com.aol.cyclops.types.Value<PT>

Specified by:

toIor in interface com.aol.cyclops.control.Xor<ST,PT>

isPresent

default boolean isPresent()

Specified by:

isPresent in interface com.aol.cyclops.types.Convertable<PT>

Specified by:

isPresent in interface com.aol.cyclops.control.Xor<ST,PT>

toXor

default com.aol.cyclops.control.Xor<ST,PT> toXor()

Specified by:

toXor in interface com.aol.cyclops.types.Value<PT>

Specified by:

toXor in interface com.aol.cyclops.control.Xor<ST,PT>

toXor

default <ST2> com.aol.cyclops.control.Xor<ST2,PT> toXor(ST2 secondary)

Specified by:

toXor in interface com.aol.cyclops.types.Value<PT>

Specified by:

toXor in interface com.aol.cyclops.control.Xor<ST,PT>

isSecondary

default boolean isSecondary()

Specified by:

isSecondary in interface com.aol.cyclops.control.Xor<ST,PT>

isPrimary

default boolean isPrimary()

Specified by:

isPrimary in interface com.aol.cyclops.control.Xor<ST,PT>

visit

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

Visitor pattern for this Ior. Execute the secondary function if this Either contains an element of the secondary type Execute the primary function if this Either contains an element of the primary type

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

Specified by:

visit in interface com.aol.cyclops.control.Xor<ST,PT>

Parameters:

secondary - Function to execute if this is a Left Either

primary - Function to execute if this is a Right Ior

both - Function to execute if this Ior contains both types

Returns:

Result of executing the appropriate function

mapBoth

@Deprecated
default <R1,R2> Either<R1,R2> mapBoth(java.util.function.Function<? super ST,? extends R1> secondary,
                                                  java.util.function.Function<? super PT,? extends R2> primary)

Deprecated.

Specified by:

mapBoth in interface com.aol.cyclops.control.Xor<ST,PT>

bimap

default <R1,R2> Either<R1,R2> bimap(java.util.function.Function<? super ST,? extends R1> secondary,
                                    java.util.function.Function<? super PT,? extends R2> primary)

Specified by:

bimap in interface com.aol.cyclops.types.BiFunctor<ST,PT>

Specified by:

bimap in interface com.aol.cyclops.control.Xor<ST,PT>

bipeek

default Either<ST,PT> bipeek(java.util.function.Consumer<? super ST> c1,
                             java.util.function.Consumer<? super PT> c2)

Specified by:

bipeek in interface com.aol.cyclops.types.BiFunctor<ST,PT>

Specified by:

bipeek in interface com.aol.cyclops.control.Xor<ST,PT>

bicast

default <U1,U2> Either<U1,U2> bicast(java.lang.Class<U1> type1,
                                     java.lang.Class<U2> type2)

Specified by:

bicast in interface com.aol.cyclops.types.BiFunctor<ST,PT>

Specified by:

bicast in interface com.aol.cyclops.control.Xor<ST,PT>

bitrampoline

default <R1,R2> Either<R1,R2> bitrampoline(java.util.function.Function<? super ST,? extends com.aol.cyclops.control.Trampoline<? extends R1>> mapper1,
                                           java.util.function.Function<? super PT,? extends com.aol.cyclops.control.Trampoline<? extends R2>> mapper2)

Specified by:

bitrampoline in interface com.aol.cyclops.types.BiFunctor<ST,PT>

Specified by:

bitrampoline in interface com.aol.cyclops.control.Xor<ST,PT>

patternMatch

default <R> Either<ST,R> patternMatch(java.util.function.Function<com.aol.cyclops.control.Matchable.CheckValue1<PT,R>,com.aol.cyclops.control.Matchable.CheckValue1<PT,R>> case1,
                                      java.util.function.Supplier<? extends R> otherwise)

Specified by:

patternMatch in interface com.aol.cyclops.types.Functor<PT>

Specified by:

patternMatch in interface com.aol.cyclops.control.Xor<ST,PT>

matches

<R> com.aol.cyclops.control.Eval<R> matches(java.util.function.Function<com.aol.cyclops.control.Matchable.CheckValue1<ST,R>,com.aol.cyclops.control.Matchable.CheckValue1<ST,R>> fn1,
                                            java.util.function.Function<com.aol.cyclops.control.Matchable.CheckValue1<PT,R>,com.aol.cyclops.control.Matchable.CheckValue1<PT,R>> fn2,
                                            java.util.function.Supplier<? extends R> otherwise)

Pattern match on the value/s inside this Either.

  
 
 import static com.aol.cyclops.control.Matchable.otherwise;
       import static com.aol.cyclops.control.Matchable.then;
       import static com.aol.cyclops.control.Matchable.when;
       import static com.aol.cyclops.util.function.Predicates.instanceOf;
 
 Either.right(10)
    .matches(c->c.is(when("10"),then("hello")),
                   c->c.is(when(instanceOf(Integer.class)), then("error")),
                   otherwise("miss"))
           .get()
       //"error" Note the second case, 'primary' case is the one that matches
 
 
 
 

Specified by:

matches in interface com.aol.cyclops.control.Xor<ST,PT>

Parameters:

fn1 - Pattern matching function executed if this Either has the secondary type

fn2 - Pattern matching function executed if this Either has the primary type

otherwise - Supplier used to provide a value if the selecting pattern matching function fails to find a match

Returns:

Lazy result of the pattern matching

get

PT get()

Specified by:

get in interface com.aol.cyclops.types.Convertable<PT>

Specified by:

get in interface java.util.function.Supplier<PT>

Specified by:

get in interface com.aol.cyclops.control.Xor<ST,PT>

secondaryValue

com.aol.cyclops.types.Value<ST> secondaryValue()

Specified by:

secondaryValue in interface com.aol.cyclops.control.Xor<ST,PT>

Returns:

A Value containing the secondary Value if present

secondaryGet

ST secondaryGet()

Specified by:

secondaryGet in interface com.aol.cyclops.control.Xor<ST,PT>

Returns:

The Left Value if present, otherwise null

secondaryToOptional

java.util.Optional<ST> secondaryToOptional()

Specified by:

secondaryToOptional in interface com.aol.cyclops.control.Xor<ST,PT>

Returns:

The Left value wrapped in an Optional if present, otherwise an empty Optional

secondaryToStream

com.aol.cyclops.control.ReactiveSeq<ST> secondaryToStream()

Specified by:

secondaryToStream in interface com.aol.cyclops.control.Xor<ST,PT>

Returns:

A Stream containing the secondary value if present, otherwise an empty Stream

flatMap

<RT1> Either<ST,RT1> flatMap(java.util.function.Function<? super PT,? extends com.aol.cyclops.types.MonadicValue<? extends RT1>> mapper)

Specified by:

flatMap in interface com.aol.cyclops.types.MonadicValue<PT>

Specified by:

flatMap in interface com.aol.cyclops.control.Xor<ST,PT>

secondaryFlatMap

<LT1> Either<LT1,PT> secondaryFlatMap(java.util.function.Function<? super ST,? extends com.aol.cyclops.control.Xor<LT1,PT>> mapper)

Perform a flatMap operation on the Left type

Specified by:

secondaryFlatMap in interface com.aol.cyclops.control.Xor<ST,PT>

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

secondaryToPrimayFlatMap

Either<ST,PT> secondaryToPrimayFlatMap(java.util.function.Function<? super ST,? extends com.aol.cyclops.control.Xor<ST,PT>> fn)

A flatMap operation that keeps the Left and Right types the same

Specified by:

secondaryToPrimayFlatMap in interface com.aol.cyclops.control.Xor<ST,PT>

Parameters:

fn - Transformation function

Returns:

Either

peek

@Deprecated
void peek(java.util.function.Consumer<? super ST> stAction,
                      java.util.function.Consumer<? super PT> ptAction)

Deprecated.

Specified by:

peek in interface com.aol.cyclops.control.Xor<ST,PT>

isRight

boolean isRight()

Returns:

True if this is a primary Either

isLeft

boolean isLeft()

Returns:

True if this is a secondary Either

combine

<T2,R> Either<ST,R> combine(com.aol.cyclops.types.Value<? extends T2> app,
                            java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)

Specified by:

combine in interface com.aol.cyclops.types.Combiner<PT>

Specified by:

combine in interface com.aol.cyclops.control.Xor<ST,PT>

list

default Either<com.aol.cyclops.data.collections.extensions.persistent.PStackX<ST>,PT> list()

Specified by:

list in interface com.aol.cyclops.control.Xor<ST,PT>

Returns:

An Either with the secondary type converted to a persistent list, for use with accumulating app function Either#combine(Either,BiFunction)

combineToList

default <T2,R> Either<com.aol.cyclops.data.collections.extensions.persistent.PStackX<ST>,R> combineToList(Either<ST,? extends T2> app,
                                                                                                          java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)

Accumulate secondarys into a PStackX (extended Persistent List) and Right with the supplied combiner function Right accumulation only occurs if all phases are primary

Parameters:

app - Value to combine with

fn - Combiner function for primary values

Returns:

Combined Either

combine

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

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

  
  Either<String,String> fail1 =  Either.left("failed1");
        Either<PStackX<String>,String> result = fail1.list().combine(Either.left("failed2").list(), Semigroups.collectionConcat(),(a,b)->a+b);
        
        //Left of [PStackX.of("failed1","failed2")))]
 
 

Parameters:

app - Value to combine with

semigroup - to combine secondary types

fn - To combine primary types

Returns:

Combined Either

zip

default <T2,R> Either<ST,R> zip(java.lang.Iterable<? extends T2> app,
                                java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)

Specified by:

zip in interface com.aol.cyclops.types.applicative.ApplicativeFunctor<PT>

Specified by:

zip in interface com.aol.cyclops.control.Xor<ST,PT>

Specified by:

zip in interface com.aol.cyclops.types.Zippable<PT>

zip

default <T2,R> Either<ST,R> zip(java.util.function.BiFunction<? super PT,? super T2,? extends R> fn,
                                org.reactivestreams.Publisher<? extends T2> app)

Specified by:

zip in interface com.aol.cyclops.types.applicative.ApplicativeFunctor<PT>

Specified by:

zip in interface com.aol.cyclops.control.Xor<ST,PT>

Specified by:

zip in interface com.aol.cyclops.types.Zippable<PT>

zip

default <U,R> Either<ST,R> zip(org.jooq.lambda.Seq<? extends U> other,
                               java.util.function.BiFunction<? super PT,? super U,? extends R> zipper)

Specified by:

zip in interface com.aol.cyclops.control.Xor<ST,PT>

Specified by:

zip in interface com.aol.cyclops.types.Zippable<PT>

zip

default <U,R> Either<ST,R> zip(java.util.stream.Stream<? extends U> other,
                               java.util.function.BiFunction<? super PT,? super U,? extends R> zipper)

Specified by:

zip in interface com.aol.cyclops.control.Xor<ST,PT>

Specified by:

zip in interface com.aol.cyclops.types.Zippable<PT>

zip

default <U> Either<ST,org.jooq.lambda.tuple.Tuple2<PT,U>> zip(java.util.stream.Stream<? extends U> other)

Specified by:

zip in interface com.aol.cyclops.control.Xor<ST,PT>

Specified by:

zip in interface com.aol.cyclops.types.Zippable<PT>

zip

default <U> Either<ST,org.jooq.lambda.tuple.Tuple2<PT,U>> zip(org.jooq.lambda.Seq<? extends U> other)

Specified by:

zip in interface com.aol.cyclops.control.Xor<ST,PT>

Specified by:

zip in interface com.aol.cyclops.types.Zippable<PT>

zip

default <U> Either<ST,org.jooq.lambda.tuple.Tuple2<PT,U>> zip(java.lang.Iterable<? extends U> other)

Specified by:

zip in interface com.aol.cyclops.control.Xor<ST,PT>

Specified by:

zip in interface com.aol.cyclops.types.Zippable<PT>

ofType

default <U> Either<ST,U> ofType(java.lang.Class<? extends U> type)

Specified by:

ofType in interface com.aol.cyclops.types.Filterable<PT>

Specified by:

ofType in interface com.aol.cyclops.control.Xor<ST,PT>

filterNot

default Either<ST,PT> filterNot(java.util.function.Predicate<? super PT> fn)

Specified by:

filterNot in interface com.aol.cyclops.types.Filterable<PT>

Specified by:

filterNot in interface com.aol.cyclops.control.Xor<ST,PT>

notNull

default Either<ST,PT> notNull()

Specified by:

notNull in interface com.aol.cyclops.types.Filterable<PT>

Specified by:

notNull in interface com.aol.cyclops.control.Xor<ST,PT>

cast

default <U> Either<ST,U> cast(java.lang.Class<? extends U> type)

Specified by:

cast in interface com.aol.cyclops.types.Functor<PT>

Specified by:

cast in interface com.aol.cyclops.control.Xor<ST,PT>

trampoline

default <R> Either<ST,R> trampoline(java.util.function.Function<? super PT,? extends com.aol.cyclops.control.Trampoline<? extends R>> mapper)

Specified by:

trampoline in interface com.aol.cyclops.types.Functor<PT>

Specified by:

trampoline in interface com.aol.cyclops.control.Xor<ST,PT>

narrow

static <ST,PT> Either<ST,PT> narrow(Either<? extends ST,? extends PT> broad)