ST
- Secondary typePT
- Primary typepublic interface Xor<ST,PT> extends To<Xor<ST,PT>>, java.util.function.Supplier<PT>, MonadicValue2<ST,PT>, Functor<PT>, BiFunctor<ST,PT>, Filterable<PT>, ApplicativeFunctor<PT>
public class Member{ Xorteam; } Rather than public class Member{
Modifier and Type | Interface and Description |
---|---|
static class |
Xor.Primary<ST,PT> |
static class |
Xor.Secondary<ST,PT> |
ApplicativeFunctor.Applicatives, ApplicativeFunctor.ApplyFunctions<T>
Value.ValueImpl<T>
Convertable.SupplierToConvertable<T>
Modifier and Type | Method and Description |
---|---|
static <ST,PT,R> Xor<?,R> |
accumulatePrimary(CollectionX<Xor<ST,PT>> xors,
java.util.function.Function<? super PT,R> mapper,
Monoid<R> reducer)
Accumulate the results only from those Iors which have a Primary type present, using the supplied mapping function to
convert the data from each Xor 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)
Monoids .. |
static <ST,PT,R> Xor<?,R> |
accumulatePrimary(CollectionX<Xor<ST,PT>> xors,
Reducer<R> reducer)
Accumulate the result of the Primary types in the Collection of Xors provided using the supplied Reducer
Reducers . |
static <ST,PT> Xor<?,PT> |
accumulatePrimary(Monoid<PT> reducer,
CollectionX<Xor<ST,PT>> xors)
Accumulate the results only from those Xors which have a Primary 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 . |
static <ST,PT,R> Xor<?,R> |
accumulateSecondary(CollectionX<Xor<ST,PT>> xors,
java.util.function.Function<? super ST,R> mapper,
Monoid<R> reducer)
Accumulate the results only from those Xors which have a Secondary type present, using the supplied mapping function to
convert the data from each Xor 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)
Monoids .. |
static <ST,PT,R> Xor<?,R> |
accumulateSecondary(CollectionX<Xor<ST,PT>> xors,
Reducer<R> reducer)
Accumulate the result of the Secondary types in the Collection of Xors provided using the supplied Reducer
Reducers . |
static <ST,PT> Xor<?,ST> |
accumulateSecondary(Monoid<ST> reducer,
CollectionX<Xor<ST,PT>> xors)
Accumulate the results only from those Xors which have a Secondary type present, using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two
input values of the same type and returns the combined result)
Monoids . |
default AnyMValue<PT> |
anyM() |
default <U1,U2> Xor<U1,U2> |
bicast(java.lang.Class<U1> type1,
java.lang.Class<U2> type2)
Cast two data types simulatanously.
|
default <R1,R2> Xor<R1,R2> |
bimap(java.util.function.Function<? super ST,? extends R1> secondary,
java.util.function.Function<? super PT,? extends R2> primary)
Transform this BiFunctor, changing two value types at once.
|
default Xor<ST,PT> |
bipeek(java.util.function.Consumer<? super ST> c1,
java.util.function.Consumer<? super PT> c2)
Peek at two data types simulatanously (typically to perform a side-effect with each data point)
|
default <R1,R2> Xor<R1,R2> |
bitrampoline(java.util.function.Function<? super ST,? extends Trampoline<? extends R1>> mapper1,
java.util.function.Function<? super PT,? extends Trampoline<? extends R2>> mapper2)
Perform a tail-call optimized recursive transformation operation across two data points simultaneously
|
default <U> Xor<ST,U> |
cast(java.lang.Class<? extends U> type)
Cast all elements in a stream to a given type, possibly throwing a
ClassCastException . |
default <R> Xor<ST,R> |
coflatMap(java.util.function.Function<? super MonadicValue<PT>,R> mapper)
Perform a coflatMap operation.
|
default Xor<ST,PT> |
combine(java.util.function.BinaryOperator<Combiner<PT>> combiner,
Combiner<PT> app)
Combine two applicatives together using the provided BinaryOperator (Semigroup, Monoid and Reducer all
extend BinaryOperator - checkout Semigroups and Monoids for a large number of canned combinations).
|
<T2,R> Xor<ST,R> |
combine(Value<? extends T2> app,
java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)
Lazily combine this ApplicativeFunctor with the supplied value via the supplied BiFunction
Example
|
default <T2,R> Xor<ST,R> |
combine(Xor<? 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
Primary accumulation only occurs if all phases are primary |
default Xor<ST,PT> |
combineEager(Monoid<PT> monoid,
MonadicValue2<? extends ST,? extends PT> v2)
Eagerly combine two MonadicValues using the supplied monoid
|
default <T2,R> Xor<PStackX<ST>,R> |
combineToList(Xor<ST,? extends T2> app,
java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)
Accumulate secondarys into a PStackX (extended Persistent List) and Primary with the supplied combiner function
Primary accumulation only occurs if all phases are primary
|
Xor<ST,PT> |
filter(java.util.function.Predicate<? super PT> test)
Keep only elements for which the supplied predicates hold
e.g.
|
default Xor<ST,PT> |
filterNot(java.util.function.Predicate<? super PT> fn)
Remove any elements for which the predicate holds (inverse operation to filter)
e.g.
|
<LT1,RT1> Xor<LT1,RT1> |
flatMap(java.util.function.Function<? super PT,? extends MonadicValue2<? extends LT1,? extends RT1>> mapper)
Perform a flattening transformation of this Monadicvalue2
|
default <R> Xor<ST,R> |
flatMapIterable(java.util.function.Function<? super PT,? extends java.lang.Iterable<? extends R>> mapper)
A flattening transformation operation that takes the first value from the returned Publisher.
|
default <R> Xor<ST,R> |
flatMapPublisher(java.util.function.Function<? super PT,? extends org.reactivestreams.Publisher<? extends R>> mapper)
A flattening transformation operation that takes the first value from the returned Publisher.
|
static <ST,T> Xor<ST,T> |
fromIterable(java.lang.Iterable<T> iterable)
Construct a Primary Xor from the supplied Iterable
|
static <T> Xor<java.lang.Throwable,T> |
fromPublisher(org.reactivestreams.Publisher<T> pub)
Construct a Primary Xor from the supplied publisher
|
PT |
get() |
default boolean |
isPresent() |
boolean |
isPrimary() |
boolean |
isSecondary() |
default Xor<PStackX<ST>,PT> |
list() |
<R> Xor<ST,R> |
map(java.util.function.Function<? super PT,? extends R> fn)
Transform this functor using the supplied transformation function
|
default <R1,R2> Xor<R1,R2> |
mapBoth(java.util.function.Function<? super ST,? extends R1> secondary,
java.util.function.Function<? super PT,? extends R2> primary)
Deprecated.
|
<R> Eval<R> |
matches(java.util.function.Function<Matchable.CheckValue1<ST,R>,Matchable.CheckValue1<ST,R>> fn1,
java.util.function.Function<Matchable.CheckValue1<PT,R>,Matchable.CheckValue1<PT,R>> fn2,
java.util.function.Supplier<? extends R> otherwise)
Pattern match on the value/s inside this Xor.
|
default Xor<ST,MonadicValue<PT>> |
nest()
cojoin pattern.
|
default Xor<ST,PT> |
notNull()
Filter elements retaining only values which are not null
|
default <U> Xor<ST,U> |
ofType(java.lang.Class<? extends U> type)
Keep only those elements in a stream that are of a given type.
|
default <R> Xor<ST,R> |
patternMatch(java.util.function.Function<Matchable.CheckValue1<PT,R>,Matchable.CheckValue1<PT,R>> case1,
java.util.function.Supplier<? extends R> otherwise)
Transform the elements of this Stream with a Pattern Matching case and default value
|
Xor<ST,PT> |
peek(java.util.function.Consumer<? super PT> action)
Peek at the current value of this Functor, without transforming it
|
void |
peek(java.util.function.Consumer<? super ST> stAction,
java.util.function.Consumer<? super PT> ptAction)
Deprecated.
|
static <ST,PT> Xor<ST,PT> |
primary(PT value)
Create an instance of the primary type.
|
static <ST,PT> Xor<ST,PT> |
secondary(ST value)
Create an instance of the secondary type.
|
<LT1,RT1> Xor<LT1,RT1> |
secondaryFlatMap(java.util.function.Function<? super ST,? extends Xor<LT1,RT1>> mapper)
Perform a flatMap operation on the Secondary type
|
ST |
secondaryGet() |
<R> Xor<R,PT> |
secondaryMap(java.util.function.Function<? super ST,? extends R> fn)
Always map the Secondary type of this Xor if it is present using the provided transformation function
|
Xor<ST,PT> |
secondaryPeek(java.util.function.Consumer<? super ST> action)
Peek at the Secondary type value if present
|
java.util.Optional<ST> |
secondaryToOptional() |
Xor<ST,PT> |
secondaryToPrimayFlatMap(java.util.function.Function<? super ST,? extends Xor<ST,PT>> fn)
A flatMap operation that keeps the Secondary and Primary types the same
|
Xor<ST,PT> |
secondaryToPrimayMap(java.util.function.Function<? super ST,? extends PT> fn)
If this Xor contains the Secondary type, map it's value so that it contains the Primary type
|
ReactiveSeq<ST> |
secondaryToStream() |
Value<ST> |
secondaryValue() |
static <ST,PT> Xor<ListX<ST>,ListX<PT>> |
sequencePrimary(CollectionX<Xor<ST,PT>> xors)
Turn a collection of Xors into a single Ior with Lists of values.
|
static <ST,PT> Xor<ListX<PT>,ListX<ST>> |
sequenceSecondary(CollectionX<Xor<ST,PT>> xors)
Turn a collection of Xors into a single Xor with Lists of values.
|
Xor<PT,ST> |
swap()
Swap types so operations directly affect the current (pre-swap) Secondary type
|
Ior<ST,PT> |
toIor()
Return an Ior that can be this object or a Ior.primary or Ior.secondary
|
default java.util.Optional<PT> |
toOptional() |
default Xor<ST,PT> |
toXor() |
default <ST2> Xor<ST2,PT> |
toXor(ST2 secondary)
Convert to an Xor where the secondary value will be used if no primary value is present
|
default <R> Xor<ST,R> |
trampoline(java.util.function.Function<? super PT,? extends Trampoline<? extends R>> mapper)
Performs a map operation that can call a recursive method without running out of stack space
|
default <T> Xor<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.
|
default <T2,R> Xor<ST,R> |
zip(java.util.function.BiFunction<? super PT,? super T2,? extends R> fn,
org.reactivestreams.Publisher<? extends T2> app)
Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
|
default <T2,R> Xor<ST,R> |
zip(java.lang.Iterable<? extends T2> app,
java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)
Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
|
default <U> Xor<ST,org.jooq.lambda.tuple.Tuple2<PT,U>> |
zip(java.lang.Iterable<? extends U> other)
Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2
|
default <U> Xor<ST,org.jooq.lambda.tuple.Tuple2<PT,U>> |
zip(org.jooq.lambda.Seq<? extends U> other)
Zip (combine) this Zippable with the supplied Seq combining both into a Tuple2
|
default <U,R> Xor<ST,R> |
zip(org.jooq.lambda.Seq<? extends U> other,
java.util.function.BiFunction<? super PT,? super U,? extends R> zipper)
Zip (combine) this Zippable with the supplied Seq, using the supplied combining function
|
default <U> Xor<ST,org.jooq.lambda.tuple.Tuple2<PT,U>> |
zip(java.util.stream.Stream<? extends U> other)
Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2
|
default <U,R> Xor<ST,R> |
zip(java.util.stream.Stream<? extends U> other,
java.util.function.BiFunction<? super PT,? super U,? extends R> zipper)
Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
|
applyFunctions
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
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
collect, fromSupplier, orElse, orElseGet, orElseThrow, toAtomicReference, toCompletableFuture, toCompletableFutureAsync, toCompletableFutureAsync, toFutureW, toFutureWAsync, toFutureWAsync, toOptionalAtomicReference, toStream, visit
static <T> Xor<java.lang.Throwable,T> fromPublisher(org.reactivestreams.Publisher<T> pub)
ReactiveSeq<Integer> stream = ReactiveSeq.of(1,2,3);
Xor<Throwable,Integer> future = Xor.fromPublisher(stream);
//Xor[1]
pub
- Publisher to construct an Xor fromstatic <ST,T> Xor<ST,T> fromIterable(java.lang.Iterable<T> iterable)
List<Integer> list = Arrays.asList(1,2,3);
Xor<Throwable,Integer> future = Xor.fromPublisher(stream);
//Xor[1]
iterable
- Iterable to construct an Xor fromstatic <ST,PT> Xor<ST,PT> secondary(ST value)
Xor.<Integer,Integer>secondary(10).map(i->i+1);
//Xor.secondary[10]
Xor.<Integer,Integer>secondary(10).swap().map(i->i+1);
//Xor.primary[11]
value
- to wrapstatic <ST,PT> Xor<ST,PT> primary(PT value)
Xor.<Integer,Integer>primary(10).map(i->i+1);
//Xor.primary[11]
value
- To construct an Xor fromdefault AnyMValue<PT> anyM()
anyM
in interface MonadicValue<PT>
default Xor<ST,PT> combine(java.util.function.BinaryOperator<Combiner<PT>> combiner, Combiner<PT> app)
Combiner
combine
in interface Combiner<PT>
Semigroup
,
Semigroups
,
Monoid
,
To lift any Semigroup (or monoid) up to handling Applicatives use the combineApplicatives operator in Semigroups
{@see com.aol.cyclops.Semigroups#combineApplicatives(BiFunction) } or Monoids
{ {@see com.aol.cyclops.Monoids#combineApplicatives(java.util.function.Function, com.aol.cyclops.Monoid)
}
{@code
BinaryOperator> sumMaybes = Semigroups.combineScalarFunctors(Semigroups.intSum);
Maybe.just(1)
.combine(sumMaybes, Maybe.just(5))
//Maybe.just(6));
}
default <R> Xor<ST,R> flatMapIterable(java.util.function.Function<? super PT,? extends java.lang.Iterable<? extends R>> mapper)
MonadicValue2
Xor.primary(1).map(i->i+2).flatMapPublisher(i->Arrays.asList(()->i*3,20);
//Xor[9]
flatMapIterable
in interface MonadicValue2<ST,PT>
mapper
- transformation functiondefault <R> Xor<ST,R> flatMapPublisher(java.util.function.Function<? super PT,? extends org.reactivestreams.Publisher<? extends R>> mapper)
MonadicValue2
Ior.primary(1).map(i->i+2).flatMapPublisher(i->Flux.just(()->i*3,20);
//Xor[9]
flatMapPublisher
in interface MonadicValue2<ST,PT>
mapper
- FlatMap transformation functiondefault <R> Xor<ST,R> coflatMap(java.util.function.Function<? super MonadicValue<PT>,R> mapper)
MonadicValue
Maybe.none().coflatMap(m -> m.isPresent() ? m.get() : 10);
//Maybe[10]
coflatMap
in interface MonadicValue<PT>
mapper
- Mapping / transformation functiondefault Xor<ST,MonadicValue<PT>> nest()
MonadicValue
nest
in interface MonadicValue<PT>
default Xor<ST,PT> combineEager(Monoid<PT> monoid, MonadicValue2<? extends ST,? extends PT> v2)
MonadicValue2
Monoid<Integer> add = Mondoid.of(1,Semigroups.intSum);
Maybe.of(10).combineEager(add,Maybe.none());
//Maybe[10]
Maybe.none().combineEager(add,Maybe.of(10));
//Maybe[10]
Maybe.none().combineEager(add,Maybe.none());
//Maybe.none()
Maybe.of(10).combineEager(add,Maybe.of(10));
//Maybe[20]
Monoid
<Integer> firstNonNull = Monoid.of(null , Semigroups.firstNonNull());
Maybe.of(10).combineEager(firstNonNull,Maybe.of(10));
//Maybe[10]
combineEager
in interface MonadicValue2<ST,PT>
monoid
- Monoid to be used to combine valuesv2
- MonadicValue to combine withdefault <T> Xor<ST,T> unit(T unit)
unit
in interface MonadicValue<PT>
unit
in interface MonadicValue2<ST,PT>
unit
in interface Unit<PT>
default java.util.Optional<PT> toOptional()
toOptional
in interface Convertable<PT>
Xor<ST,PT> filter(java.util.function.Predicate<? super PT> test)
Filterable
of(1,2,3).filter(i->i>2);
//[3]
filter
in interface Filterable<PT>
test
- to filter elements by, retaining matchesXor<ST,PT> secondaryToPrimayMap(java.util.function.Function<? super ST,? extends PT> fn)
fn
- Function to map secondary type to primary<R> Xor<R,PT> secondaryMap(java.util.function.Function<? super ST,? extends R> fn)
fn
- Transformation function for Secondary types<R> Xor<ST,R> map(java.util.function.Function<? super PT,? extends R> fn)
Functor
of(1,2,3).map(i->i*2)
//[2,4,6]
map
in interface ConvertableFunctor<PT>
map
in interface Functor<PT>
map
in interface MonadicValue<PT>
map
in interface MonadicValue2<ST,PT>
fn
- Transformation functionXor<ST,PT> secondaryPeek(java.util.function.Consumer<? super ST> action)
action
- Consumer to peek at the Secondary type valueXor<ST,PT> peek(java.util.function.Consumer<? super PT> action)
Functor
of(1,2,3).map(System.out::println)
1
2
3
Xor<PT,ST> swap()
Xor.secondary("hello")
.map(v->v+" world")
//Xor.seconary["hello"]
Xor.secondary("hello")
.swap()
.map(v->v+" world")
.swap()
//Xor.seconary["hello world"]
Ior<ST,PT> toIor()
Value
default boolean isPresent()
isPresent
in interface Convertable<PT>
default <ST2> Xor<ST2,PT> toXor(ST2 secondary)
Value
static <ST,PT> Xor<ListX<PT>,ListX<ST>> sequenceSecondary(CollectionX<Xor<ST,PT>> xors)
Xor<String,Integer> just = Xor.primary(10);
Xor<String,Integer> none = Xor.secondary("none");
Xor<ListX<Integer>,ListX<String>> xors =Xor.sequenceSecondary(ListX.of(just,none,Xor.primary(1)));
//Xor.primary(ListX.of("none")))
xors
- Xors to sequencestatic <ST,PT,R> Xor<?,R> accumulateSecondary(CollectionX<Xor<ST,PT>> xors, Reducer<R> reducer)
Reducers
.
Xor<String,Integer> just = Xor.primary(10);
Xor<String,Integer> none = Xor.secondary("none");
Xor<?,PSetX<String>> xors = Xor.accumulateSecondary(ListX.of(just,none,Xor.primary(1)),Reducers.<String>toPSetX());
//Xor.primary(PSetX.of("none"))));
xors
- Collection of Iors to accumulate secondary valuesreducer
- Reducer to accumulate resultsstatic <ST,PT,R> Xor<?,R> accumulateSecondary(CollectionX<Xor<ST,PT>> xors, java.util.function.Function<? super ST,R> mapper, Monoid<R> reducer)
Monoids
..
Xor<String,Integer> just = Xor.primary(10);
Xor<String,Integer> none = Xor.secondary("none");
Xor<?,String> xors = Xor.accumulateSecondary(ListX.of(just,none,Xor.secondary("1")),i->""+i,Monoids.stringConcat);
//Xor.primary("none1")
xors
- Collection of Iors to accumulate secondary valuesmapper
- Mapping function to be applied to the result of each Iorreducer
- Semigroup to combine values from each Iorstatic <ST,PT> Xor<ListX<ST>,ListX<PT>> sequencePrimary(CollectionX<Xor<ST,PT>> xors)
Xor<String,Integer> just = Xor.primary(10);
Xor<String,Integer> none = Xor.secondary("none");
Xor<ListX<String>,ListX<Integer>> xors =Xor.sequencePrimary(ListX.of(just,none,Xor.primary(1)));
//Xor.primary(ListX.of(10,1)));
iors
- Xors to sequencestatic <ST,PT,R> Xor<?,R> accumulatePrimary(CollectionX<Xor<ST,PT>> xors, Reducer<R> reducer)
Reducers
.
Xor<String,Integer> just = Xor.primary(10);
Xor<String,Integer> none = Xor.secondary("none");
Xor<?,PSetX<Integer>> xors =Xor.accumulatePrimary(ListX.of(just,none,Xor.primary(1)),Reducers.toPSetX());
//Xor.primary(PSetX.of(10,1))));
Xors
- Collection of Iors to accumulate primary valuesreducer
- Reducer to accumulate resultsstatic <ST,PT,R> Xor<?,R> accumulatePrimary(CollectionX<Xor<ST,PT>> xors, java.util.function.Function<? super PT,R> mapper, Monoid<R> reducer)
Monoids
..
Xor<String,Integer> just = Xor.primary(10);
Xor<String,Integer> none = Xor.secondary("none");
Xor<?,String> iors = Xor.accumulatePrimary(ListX.of(just,none,Xor.primary(1)),i->""+i,Monoids.stringConcat);
//Xor.primary("101"));
xors
- Collection of Iors to accumulate primary valuesmapper
- Mapping function to be applied to the result of each Iorreducer
- Reducer to accumulate resultsstatic <ST,PT> Xor<?,PT> accumulatePrimary(Monoid<PT> reducer, CollectionX<Xor<ST,PT>> xors)
Monoids
.
Xor<String,Integer> just = Xor.primary(10);
Xor<String,Integer> none = Xor.secondary("none");
Xor<?,Integer> xors XIor.accumulatePrimary(Monoids.intSum,ListX.of(just,none,Ior.primary(1)));
//Ior.primary(11);
xors
- Collection of Xors to accumulate primary valuesreducer
- Reducer to accumulate resultsstatic <ST,PT> Xor<?,ST> accumulateSecondary(Monoid<ST> reducer, CollectionX<Xor<ST,PT>> xors)
Monoids
.
Xor.accumulateSecondary(ListX.of(Xor.secondary("failed1"),
Xor.secondary("failed2"),
Xor.primary("success")),
Semigroups.stringConcat)
//Xors.Primary[failed1failed2]
Xor<String,Integer> just = Xor.primary(10);
Xor<String,Integer> none = Xor.secondary("none");
Xor<?,Integer> iors = Xor.accumulateSecondary(Monoids.intSum,ListX.of(Xor.both(2, "boo!"),Xor.secondary(1)));
//Xor.primary(3); 2+1
xors
- Collection of Xors to accumulate secondary valuesreducer
- Semigroup to combine values from each Xor<R> R visit(java.util.function.Function<? super ST,? extends R> secondary, java.util.function.Function<? super PT,? extends R> primary)
Xor.primary(10)
.visit(secondary->"no", primary->"yes")
//Xor["yes"]
Xor.secondary(90)
.visit(secondary->"no", primary->"yes")
//Xor["no"]
secondary
- Function to execute if this is a Secondary Xorprimary
- Function to execute if this is a Primary Iorboth
- Function to execute if this Ior contains both types@Deprecated default <R1,R2> Xor<R1,R2> mapBoth(java.util.function.Function<? super ST,? extends R1> secondary, java.util.function.Function<? super PT,? extends R2> primary)
default <R1,R2> Xor<R1,R2> bimap(java.util.function.Function<? super ST,? extends R1> secondary, java.util.function.Function<? super PT,? extends R2> primary)
BiFunctor
MapX<String,Integer> map = MapXs.of("hello",2);
MapX<String,Integer> transformedMap = map.bimap(s->s+" world",i->i*4);
//["hello world",8]
default Xor<ST,PT> bipeek(java.util.function.Consumer<? super ST> c1, java.util.function.Consumer<? super PT> c2)
BiFunctor
MapX<String,Integer> map = MapXs.of("hello",2);
map.bipeek(s->System.out.pritnln("key = " + s),System.out::println);
default <U1,U2> Xor<U1,U2> bicast(java.lang.Class<U1> type1, java.lang.Class<U2> type2)
BiFunctor
MapX<Animal,Food> map = MapXs.of(cow,grass);
MapX<Mamaml,Vegitation> herbervoreMammals = map.bicast(Mammal.class,Vegitation.class);
default <R1,R2> Xor<R1,R2> bitrampoline(java.util.function.Function<? super ST,? extends Trampoline<? extends R1>> mapper1, java.util.function.Function<? super PT,? extends Trampoline<? extends R2>> mapper2)
BiFunctor
bitrampoline
in interface BiFunctor<ST,PT>
mapper1
- transformation function for the first typemapper2
- transformation function for the second typedefault <R> Xor<ST,R> patternMatch(java.util.function.Function<Matchable.CheckValue1<PT,R>,Matchable.CheckValue1<PT,R>> case1, java.util.function.Supplier<? extends R> otherwise)
Functor
List<String> result = CollectionX.of(1,2,3,4)
.patternMatch(
c->c.valuesWhere(i->"even", (Integer i)->i%2==0 )
)
// CollectionX["odd","even","odd","even"]
patternMatch
in interface Functor<PT>
case1
- Function to generate a case (or chain of cases as a single case)otherwise
- Value if supplied case doesn't match<R> Eval<R> matches(java.util.function.Function<Matchable.CheckValue1<ST,R>,Matchable.CheckValue1<ST,R>> fn1, java.util.function.Function<Matchable.CheckValue1<PT,R>,Matchable.CheckValue1<PT,R>> fn2, java.util.function.Supplier<? extends R> otherwise)
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;
Xor.primary(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
fn1
- Pattern matching function executed if this Xor has the secondary typefn2
- Pattern matching function executed if this Xor has the primary typeotherwise
- Supplier used to provide a value if the selecting pattern matching function fails to find a matchPT get()
get
in interface Convertable<PT>
get
in interface java.util.function.Supplier<PT>
Value<ST> secondaryValue()
ST secondaryGet()
java.util.Optional<ST> secondaryToOptional()
ReactiveSeq<ST> secondaryToStream()
<LT1,RT1> Xor<LT1,RT1> flatMap(java.util.function.Function<? super PT,? extends MonadicValue2<? extends LT1,? extends RT1>> mapper)
MonadicValue2
flatMap
in interface MonadicValue2<ST,PT>
mapper
- transformation function<LT1,RT1> Xor<LT1,RT1> secondaryFlatMap(java.util.function.Function<? super ST,? extends Xor<LT1,RT1>> mapper)
mapper
- Flattening transformation functionXor<ST,PT> secondaryToPrimayFlatMap(java.util.function.Function<? super ST,? extends Xor<ST,PT>> fn)
fn
- Transformation function@Deprecated void peek(java.util.function.Consumer<? super ST> stAction, java.util.function.Consumer<? super PT> ptAction)
boolean isPrimary()
boolean isSecondary()
<T2,R> Xor<ST,R> combine(Value<? extends T2> app, java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)
Combiner
Maybe<Integer> some = Maybe.just(10);
just.combine(Eval.now(20), this::add);
//Some[30]
Maybe<Integer> none = Maybe.none();
none.combine(Eval.now(20), this::add);
//None
default Xor<PStackX<ST>,PT> list()
Xor#combine(Xor,BiFunction)
default <T2,R> Xor<PStackX<ST>,R> combineToList(Xor<ST,? extends T2> app, java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)
app
- Value to combine withfn
- Combiner function for primary valuesdefault <T2,R> Xor<ST,R> combine(Xor<? extends ST,? extends T2> app, java.util.function.BinaryOperator<ST> semigroup, java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)
Semigroups
Primary accumulation only occurs if all phases are primary
Xor<String,String> fail1 = Xor.secondary("failed1");
Xor<PStackX<String>,String> result = fail1.list().combine(Xor.secondary("failed2").list(), Semigroups.collectionConcat(),(a,b)->a+b);
//Secondary of [PStackX.of("failed1","failed2")))]
app
- Value to combine withsemigroup
- to combine secondary typesfn
- To combine primary typesdefault <T2,R> Xor<ST,R> zip(java.lang.Iterable<? extends T2> app, java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)
Zippable
default <T2,R> Xor<ST,R> zip(java.util.function.BiFunction<? super PT,? super T2,? extends R> fn, org.reactivestreams.Publisher<? extends T2> app)
Zippable
default <U,R> Xor<ST,R> zip(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiFunction<? super PT,? super U,? extends R> zipper)
Zippable
default <U,R> Xor<ST,R> zip(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super PT,? super U,? extends R> zipper)
Zippable
default <U> Xor<ST,org.jooq.lambda.tuple.Tuple2<PT,U>> zip(java.util.stream.Stream<? extends U> other)
Zippable
default <U> Xor<ST,org.jooq.lambda.tuple.Tuple2<PT,U>> zip(org.jooq.lambda.Seq<? extends U> other)
Zippable
default <U> Xor<ST,org.jooq.lambda.tuple.Tuple2<PT,U>> zip(java.lang.Iterable<? extends U> other)
Zippable
default <U> Xor<ST,U> ofType(java.lang.Class<? extends U> type)
Filterable
// (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)
ofType
in interface Filterable<PT>
default Xor<ST,PT> filterNot(java.util.function.Predicate<? super PT> fn)
Filterable
of(1,2,3).filter(i->i>2);
//[1,2]
filterNot
in interface Filterable<PT>
fn
- to filter elements by, retaining matchesdefault Xor<ST,PT> notNull()
Filterable
of(1,2,null,4).nonNull();
//[1,2,4]
notNull
in interface Filterable<PT>
default <U> Xor<ST,U> cast(java.lang.Class<? extends U> type)
Functor
ClassCastException
.
// ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)default <R> Xor<ST,R> trampoline(java.util.function.Function<? super PT,? extends Trampoline<? extends R>> mapper)
Functor
ReactiveSeq.of(10,20,30,40)
.trampoline(i-> fibonacci(i))
.forEach(System.out::println);
Trampoline<Long> fibonacci(int i){
return fibonacci(i,1,0);
}
Trampoline<Long> fibonacci(int n, long a, long b) {
return n == 0 ? Trampoline.done(b) : Trampoline.more( ()->fibonacci(n-1, a+b, a));
}
55
6765
832040
102334155
ReactiveSeq.of(10_000,200_000,3_000_000,40_000_000)
.trampoline(i-> fibonacci(i))
.forEach(System.out::println);
completes successfully
trampoline
in interface Functor<PT>
mapper
- TCO Transformation function