cyclops.control.lazy

Interface Either4<LT1,LT2,LT3,RT>

Type Parameters:

LT1 - First type (Left type)

LT2 - Second type

LT3 - Third Type

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

All Superinterfaces:

BiTransformable<LT3,RT>, Convert<Higher<Higher<Higher<Higher<Witness.either4,LT1>,LT2>,LT3>,RT>>, Convertable<RT>, Filters<RT>, Fn0<RT>, Folds<RT>, Higher<Higher<Higher<Higher<Witness.either4,LT1>,LT2>,LT3>,RT>, Higher2<Higher<Higher<Witness.either4,LT1>,LT2>,LT3,RT>, Higher3<Higher<Witness.either4,LT1>,LT2,LT3,RT>, Higher4<Witness.either4,LT1,LT2,LT3,RT>, java.lang.Iterable<RT>, MonadicValue<RT>, java.util.function.Predicate<RT>, org.reactivestreams.Publisher<RT>, java.util.function.Supplier<RT>, To<Either4<LT1,LT2,LT3,RT>>, Transformable<RT>, Unit<RT>, Value<RT>, Visitable<RT>, Zippable<RT>

All Known Implementing Classes:

Either4.CompletableEither4, Either4.Lazy, Either4.Left1, Either4.Left2, Either4.Left3, Either4.Right

public interface Either4<LT1,LT2,LT3,RT>
extends Transformable<RT>, Filters<RT>, Higher4<Witness.either4,LT1,LT2,LT3,RT>, BiTransformable<LT3,RT>, To<Either4<LT1,LT2,LT3,RT>>, MonadicValue<RT>, java.util.function.Supplier<RT>

A right biased Lazy Either4 type. map / flatMap operators are tail-call optimized Can be one of 4 types Left1 Left2 Left3 Right

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	Either4.CompletableEither4<ORG,LT1,LT2,RT>
static class	Either4.Instances
static class	Either4.Lazy<ST,M,M2,PT>
static class	Either4.Left1<ST,M,M2,PT>
static class	Either4.Left2<ST,M,M2,PT>
static class	Either4.Left3<ST,M,M2,PT>
static class	Either4.Right<ST,M,M2,PT>

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

Value.ValueImpl<T>

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

Convertable.SupplierToConvertable<T>

Nested classes/interfaces inherited from interface cyclops.function.Fn0

Fn0.FunctionalOperations<R>, Fn0.SupplierKind<R>

Method Summary

Modifier and Type	Method and Description
static <LT1,LT2,LT3,RT> Either4<ListX<LT1>,ListX<LT2>,ListX<LT3>,RT>	accumulate(Monoid<RT> reducer, CollectionX<Either4<LT1,LT2,LT3,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.aol.cyclops2.Monoids .
default Active<Higher<Higher<Higher<Witness.either4,LT1>,LT2>,LT3>,RT>	allTypeclasses()
static <X,LT1 extends X,LT2 extends X,LT3 extends X,RT extends X,R> java.util.function.Function<java.util.function.Function<? super X,R>,R>	applyAny(Either4<LT1,LT2,LT3,RT> either)
default int	arity()
default <U1,U2> Either4<LT1,LT2,U1,U2>	bicast(java.lang.Class<U1> type1, java.lang.Class<U2> type2) Cast two data types simulatanously.
<R1,R2> Either4<LT1,LT2,R1,R2>	bimap(java.util.function.Function<? super LT3,? extends R1> fn1, java.util.function.Function<? super RT,? extends R2> fn2) Transform this BiTransformable, changing two value types at once.
default Either4<LT1,LT2,LT3,RT>	bipeek(java.util.function.Consumer<? super LT3> 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 <R1,R2> Either4<LT1,LT2,R1,R2>	bitrampoline(java.util.function.Function<? super LT3,? extends Trampoline<? extends R1>> mapper1, java.util.function.Function<? super RT,? extends Trampoline<? extends R2>> mapper2) Perform a tail-call optimized recursive transformation operation across two data points simultaneously
default <U> Either4<LT1,LT2,LT3,U>	cast(java.lang.Class<? extends U> type) Cast all elements in a reactiveStream to a given type, possibly throwing a ClassCastException.
default <R> Either4<LT1,LT2,LT3,R>	coflatMap(java.util.function.Function<? super MonadicValue<RT>,R> mapper) Perform a coflatMap operation.
default <T2,R> Either4<LT1,LT2,LT3,R>	combine(Value<? extends T2> app, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn) Lazily combine this ApplicativeFunctor with the supplied value via the supplied BiFunction Example
default Either4<LT1,LT2,LT3,RT>	combineEager(Monoid<RT> monoid, MonadicValue<? extends RT> v2) Eagerly combine two MonadicValues using the supplied monoid (@see ApplicativeFunctor for type appropraite i.e.
static <X,LT1 extends X,LT2 extends X,LT3 extends X,RT extends X> java.util.function.Consumer<java.util.function.Consumer<? super X>>	consumeAny(Either4<LT1,LT2,LT3,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,LT3,RT> Either4.CompletableEither4<RT,LT2,LT3,RT>	either4() Create a reactiveBuffer CompletableEither
Maybe<RT>	filter(java.util.function.Predicate<? super RT> test) Filter this Either4 resulting in a Maybe#none if it is not a Right instance or if the predicate does not hold.
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.
<RT1> Either4<LT1,LT2,LT3,RT1>	flatMap(java.util.function.Function<? super RT,? extends MonadicValue<? extends RT1>> mapper) Flattening transformation on this Either4.
default <RT1> Either4<LT1,LT2,LT3,RT1>	flatMapI(java.util.function.Function<? super RT,? extends java.lang.Iterable<? extends RT1>> mapper) A flattening transformation operation that takes the first value from the returned Iterable.
default <RT1> Either4<LT1,LT2,LT3,RT1>	flatMapP(java.util.function.Function<? super RT,? extends org.reactivestreams.Publisher<? extends RT1>> mapper) A flattening transformation operation that takes the first value from the returned Publisher.
default <R> Either4<LT1,LT2,LT3,R>	flatMapS(java.util.function.Function<? super RT,? extends java.util.stream.Stream<? extends R>> mapper)
default <R1,R> Either4<LT1,LT2,LT3,R>	forEach2(java.util.function.Function<? super RT,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends R> yieldingFunction) Perform a two level nested internal iteration over this MonadicValue and the supplied MonadicValue
default <R1,R> Either4<LT1,LT2,LT3,R>	forEach2(java.util.function.Function<? super RT,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super RT,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super RT,? super R1,? extends R> yieldingFunction) Perform a two level nested internal iteration over this MonadicValue and the supplied reactiveStream
default <T2,R1,R2,R> Either4<LT1,LT2,LT3,R>	forEach3(java.util.function.Function<? super RT,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends MonadicValue<R2>> value2, Fn3<? super RT,? super R1,? super R2,? extends R> yieldingFunction) Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues
default <T2,R1,R2,R> Either4<LT1,LT2,LT3,R>	forEach3(java.util.function.Function<? super RT,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends MonadicValue<R2>> value2, Fn3<? super RT,? super R1,? super R2,java.lang.Boolean> filterFunction, Fn3<? super RT,? super R1,? super R2,? extends R> yieldingFunction) Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues
default <T2,R1,R2,R3,R> Either4<LT1,LT2,LT3,R>	forEach4(java.util.function.Function<? super RT,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends MonadicValue<R2>> value2, Fn3<? super RT,? super R1,? super R2,? extends MonadicValue<R3>> value3, Fn4<? super RT,? super R1,? super R2,? super R3,? extends R> yieldingFunction) Perform a four level nested internal iteration over this MonadicValue and the supplied MonadicValues
default <T2,R1,R2,R3,R> Either4<LT1,LT2,LT3,R>	forEach4(java.util.function.Function<? super RT,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super RT,? super R1,? extends MonadicValue<R2>> value2, Fn3<? super RT,? super R1,? super R2,? extends MonadicValue<R3>> value3, Fn4<? super RT,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, Fn4<? super RT,? super R1,? super R2,? super R3,? extends R> yieldingFunction) Perform a four level nested internal iteration over this MonadicValue and the supplied MonadicValues Maybe.of(3) .forEach4(a->Maybe.just(a+10), (a,b)->Maybe.just(a+b), (a,b,c)->Maybe.none(), (a,b,c,d)->a+b+c<100, (a,b,c,d)->a+b+c+d); //Maybe.none
static <LT2,LT3,RT> Either4<java.lang.Throwable,LT2,LT3,RT>	fromFuture(Future<RT> future)
static <ST,T,T2,RT> Either4<ST,T,T2,RT>	fromIterable(java.lang.Iterable<RT> iterable) Construct a Right Either4 from the supplied Iterable
static <LT1,LT2,LT3,RT> Either4<LT1,LT2,LT3,RT>	fromLazy(Eval<Either4<LT1,LT2,LT3,RT>> lazy)
static <LT1,LT2,LT3,RT> Either4<LT1,LT2,LT3,RT>	fromMonadicValue(MonadicValue<RT> mv4)
static <T1,T2,T> Either4<java.lang.Throwable,T1,T2,T>	fromPublisher(org.reactivestreams.Publisher<T> pub) Lazily construct a Right Either from the supplied publisher
boolean	isLeft1()
boolean	isLeft2()
boolean	isLeft3()
boolean	isRight()
static <LT1,LT2,LT3,T> Cokleisli<Higher<Higher<Higher<Witness.either4,LT1>,LT2>,LT3>,T,Either4<LT1,LT2,LT3,T>>	kindCokleisli()
static <LT1,LT2,LT3,T> Kleisli<Higher<Higher<Higher<Witness.either4,LT1>,LT2>,LT3>,Either4<LT1,LT2,LT3,T>,T>	kindKleisli()
static <LT,M1,B,RT> Either4<LT,M1,B,RT>	left1(LT left) Construct a Either4#Left1
static <LT,M1,B,RT> Either4<LT,M1,B,RT>	left1Eval(Eval<LT> left) Construct a Either4#Left1 from an Eval
static <LT,M1,B,RT> Either4<LT,M1,B,RT>	left2(M1 middle) Construct a Either4#Second
static <LT,M1,B,RT> Either4<LT,M1,B,RT>	left2Eval(Eval<M1> middle) Construct a Either4#Second from an Eval
static <LT,M1,B,RT> Either4<LT,M1,B,RT>	left3(B middle) Construct a Either4#Third
static <LT,M1,B,RT> Either4<LT,M1,B,RT>	left3Eval(Eval<B> middle) Construct a Either4#Third from an Eval
<R> Either4<LT1,LT2,LT3,R>	map(java.util.function.Function<? super RT,? extends R> fn) Transform this functor using the supplied transformation function
default <W2,R> Nested<Higher<Higher<Higher<Witness.either4,LT1>,LT2>,LT3>,W2,R>	mapM(java.util.function.Function<? super RT,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs)
static <L1,L2,L3,T> Either4<L1,L2,L3,T>	narrowK(Higher<Higher<Higher<Higher<Witness.either4,L1>,L2>,L3>,T> xor)
static <L1,L2,L3,T> Either4<L1,L2,L3,T>	narrowK3(Higher4<Witness.either4,L1,L2,L3,T> xor)
default Either4<LT1,LT2,LT3,MonadicValue<RT>>	nest() cojoin pattern.
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 reactiveStream that are of a given type.
default Either4<LT1,LT2,LT3,RT>	peek(java.util.function.Consumer<? super RT> c) Peek at the current value of this Transformable, without transforming it
default <R> Either4<LT1,LT2,LT3,R>	retry(java.util.function.Function<? super RT,? extends R> fn) Retry a transformation if it fails.
default <R> Either4<LT1,LT2,LT3,R>	retry(java.util.function.Function<? super RT,? extends R> fn, int retries, long delay, java.util.concurrent.TimeUnit timeUnit) Retry a transformation if it fails.
static <LT,M1,B,RT> Either4<LT,M1,B,RT>	right(RT right) Construct a Either4#Right
static <LT,M1,B,RT> Either4<LT,M1,B,RT>	rightEval(Eval<RT> right) Construct a Either4#Right from an Eval
static <LT1,LT2,LT3,PT> Either4<ListX<LT1>,ListX<LT2>,ListX<LT3>,ListX<PT>>	sequence(CollectionX<Either4<LT1,LT2,LT3,PT>> xors) Turn a toX of Either3 into a singleUnsafe Either with Lists of values.
Either4<RT,LT2,LT3,LT1>	swap1()
Either4<LT1,RT,LT3,LT2>	swap2()
Either4<LT1,LT2,RT,LT3>	swap3()
default Ior<LT1,RT>	toIor() Return an Ior that can be this object or a Ior.primary or Ior.secondary
default Trampoline<Either4<LT1,LT2,LT3,RT>>	toTrampoline()
default Xor<LT1,RT>	toXor()
default <R> Either4<LT1,LT2,LT3,R>	trampoline(java.util.function.Function<? super RT,? extends Trampoline<? extends R>> mapper) Performs a map operation that can call a recursive method without running out of stack space
static <LT1,LT2,LT3,PT,R> Either4<ListX<LT1>,ListX<LT2>,ListX<LT3>,ListX<R>>	traverse(CollectionX<Either4<LT1,LT2,LT3,PT>> xors, java.util.function.Function<? super PT,? extends R> fn) TraverseOps a Collection of Either3 producing an Either4 with a ListX, applying the transformation function to every element in the list
<T> Either4<LT1,LT2,LT3,T>	unit(T unit)
<R> R	visit(java.util.function.Function<? super LT1,? extends R> left1, java.util.function.Function<? super LT2,? extends R> left2, java.util.function.Function<? super LT3,? extends R> left3, java.util.function.Function<? super RT,? extends R> right) Visit the types in this Either4, only one user supplied function is executed depending on the type
static <X,LT1 extends X,LT2 extends X,LT3 extends X,RT extends X> X	visitAny(java.util.function.Consumer<? super X> c, Either4<LT1,LT2,LT3,RT> either)
static <X,LT1 extends X,LT2 extends X,LT3 extends X,RT extends X,R> R	visitAny(Either4<LT1,LT2,LT3,RT> either, java.util.function.Function<? super X,? extends R> fn)
static <LT1,LT2,LT3,T> Higher<Higher<Higher<Higher<Witness.either4,LT1>,LT2>,LT3>,T>	widen(Either4<LT1,LT2,LT3,T> narrow)
default Either4<LT1,LT2,LT3,RT>	zip(java.util.function.BinaryOperator<Zippable<RT>> combiner, Zippable<RT> app) Combine two applicatives together using the provided BinaryOperator (Semigroup, Monoid and Reducer all extend BinaryOperator - checkout SemigroupK and Monoids for a large number of canned combinations).
default <T2,R> Either4<LT1,LT2,LT3,R>	zip(java.lang.Iterable<? extends T2> app, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn) Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
default <U> Either4<LT1,LT2,LT3,org.jooq.lambda.tuple.Tuple2<RT,U>>	zip(java.lang.Iterable<? extends U> other) Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2
default <S,U> Either4<LT1,LT2,LT3,org.jooq.lambda.tuple.Tuple3<RT,S,U>>	zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third) zip 3 Streams into one
default <S,U,R> Either4<LT1,LT2,LT3,R>	zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third, Fn3<? super RT,? super S,? super U,? extends R> fn3)
default <T2,T3,T4> Either4<LT1,LT2,LT3,org.jooq.lambda.tuple.Tuple4<RT,T2,T3,T4>>	zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth) zip 4 Streams into 1
default <T2,T3,T4,R> Either4<LT1,LT2,LT3,R>	zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth, Fn4<? super RT,? super T2,? super T3,? super T4,? extends R> fn)
default <T2,R> Either4<LT1,LT2,LT3,R>	zipP(org.reactivestreams.Publisher<? extends T2> app, java.util.function.BiFunction<? super RT,? super T2,? extends R> fn) Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
default <U> Either4<LT1,LT2,LT3,org.jooq.lambda.tuple.Tuple2<RT,U>>	zipP(org.reactivestreams.Publisher<? extends U> other)
default <U> Either4<LT1,LT2,LT3,org.jooq.lambda.tuple.Tuple2<RT,U>>	zipS(java.util.stream.Stream<? extends U> other) Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2
default <U,R> Either4<LT1,LT2,LT3,R>	zipS(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super RT,? super U,? extends R> zipper) Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
default <R> Either4<LT1,LT2,LT3,R>	zipWith(java.lang.Iterable<java.util.function.Function<? super RT,? extends R>> fn)
default <R> Either4<LT1,LT2,LT3,R>	zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super RT,? extends R>> fn)
default <R> Either4<LT1,LT2,LT3,R>	zipWithS(java.util.stream.Stream<java.util.function.Function<? super RT,? extends R>> fn)

Methods inherited from interface com.aol.cyclops2.hkt.Higher

applyHKT_, applyHKT, applyHKT

Methods inherited from interface com.aol.cyclops2.hkt.Convert

convert

Methods inherited from interface com.aol.cyclops2.types.foldable.To

to

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

apply, generate, iterate, iterator, mkString, newSubscriber, of, stream, subscribe, test, toEither, toEval, toEvalAlways, toEvalLater, toEvalNow, toLeft, toMaybe, toMaybeEager, toRight, toTry, toTry, toTry, toXor

Methods inherited from interface com.aol.cyclops2.types.foldable.Folds

endsWith, endsWithIterable, findAny, findFirst, firstValue, foldLeft, foldLeft, foldLeft, foldLeft, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, join, join, join, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleUnsafe, startsWith, startsWithIterable, takeOne, xMatch

Methods inherited from interface com.aol.cyclops2.types.foldable.Convertable

collect, fromSupplier, get, isPresent, orElse, orElseGet, orElseThrow, toCompletableFuture, toCompletableFutureAsync, toFuture, toFutureAsync, toOptional, toStream, visit

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Methods inherited from interface cyclops.function.Fn0

andThen, fnTo, functionOps, future, lift, lift, liftF, liftOpt, liftTry, memoize, memoize, memoizeAsync, memoizeAsync, run, suspend, λ, λv

Methods inherited from interface java.util.function.Predicate

and, isEqual, negate, or

Method Detail

kindKleisli

static <LT1,LT2,LT3,T> Kleisli<Higher<Higher<Higher<Witness.either4,LT1>,LT2>,LT3>,Either4<LT1,LT2,LT3,T>,T> kindKleisli()

widen

static <LT1,LT2,LT3,T> Higher<Higher<Higher<Higher<Witness.either4,LT1>,LT2>,LT3>,T> widen(Either4<LT1,LT2,LT3,T> narrow)

kindCokleisli

static <LT1,LT2,LT3,T> Cokleisli<Higher<Higher<Higher<Witness.either4,LT1>,LT2>,LT3>,T,Either4<LT1,LT2,LT3,T>> kindCokleisli()

either4

static <LT2,LT3,RT> Either4.CompletableEither4<RT,LT2,LT3,RT> either4()

Create a reactiveBuffer CompletableEither

  
      ___Example 1___

      CompletableEither<Integer,Integer> completable = Either4.either4();
            Either4<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 = Either4.either4();
            Either4<Throwable,String,Integer> mapped = completable.map(i->i*2)
                                                                .flatMap(i->Eval.later(()->i+1));


            completable.complete(null);

            //Either4:Left4[NoSuchElementException]

            ___Example 3___

            CompletableEither<Integer,Integer> completable = Either4.either4();
            Either4<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:

consumeAny

static <X,LT1 extends X,LT2 extends X,LT3 extends X,RT extends X> java.util.function.Consumer<java.util.function.Consumer<? super X>> consumeAny(Either4<LT1,LT2,LT3,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(Either4::consumeAny)
                 .accept(System.out::println);
 
 

Parameters:

either - Either to consume value for

Returns:

Consumer we can applyHKT to consume value

applyAny

static <X,LT1 extends X,LT2 extends X,LT3 extends X,RT extends X,R> java.util.function.Function<java.util.function.Function<? super X,R>,R> applyAny(Either4<LT1,LT2,LT3,RT> either)

visitAny

static <X,LT1 extends X,LT2 extends X,LT3 extends X,RT extends X,R> R visitAny(Either4<LT1,LT2,LT3,RT> either,
                                                                               java.util.function.Function<? super X,? extends R> fn)

visitAny

static <X,LT1 extends X,LT2 extends X,LT3 extends X,RT extends X> X visitAny(java.util.function.Consumer<? super X> c,
                                                                             Either4<LT1,LT2,LT3,RT> either)

fromMonadicValue

static <LT1,LT2,LT3,RT> Either4<LT1,LT2,LT3,RT> fromMonadicValue(MonadicValue<RT> mv4)

fromLazy

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

fromFuture

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

sequence

static <LT1,LT2,LT3,PT> Either4<ListX<LT1>,ListX<LT2>,ListX<LT3>,ListX<PT>> sequence(CollectionX<Either4<LT1,LT2,LT3,PT>> xors)

Turn a toX of Either3 into a singleUnsafe Either with Lists of values.

 

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


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

 

Parameters:

Either3 - Either3 to sequence

Returns:

Either3 Sequenced

traverse

static <LT1,LT2,LT3,PT,R> Either4<ListX<LT1>,ListX<LT2>,ListX<LT3>,ListX<R>> traverse(CollectionX<Either4<LT1,LT2,LT3,PT>> xors,
                                                                                      java.util.function.Function<? super PT,? extends R> fn)

TraverseOps a Collection of Either3 producing an Either4 with a ListX, applying the transformation function to every element in the list

Parameters:

xors - Either4s to sequence and transform

fn - Transformation function

Returns:

An Either4 with a transformed list

accumulate

static <LT1,LT2,LT3,RT> Either4<ListX<LT1>,ListX<LT2>,ListX<LT3>,RT> accumulate(Monoid<RT> reducer,
                                                                                CollectionX<Either4<LT1,LT2,LT3,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.aol.cyclops2.Monoids .

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

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

 
 

Parameters:

xors - Collection of Eithers to accumulate primary values

reducer - Reducer to accumulate results

Returns:

Either4 populated with the accumulate primary operation

fromPublisher

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

Lazily construct a Right Either from the supplied publisher

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

         Either4<Throwable,String,String,Integer> lazy = Either4.fromPublisher(reactiveStream);

         //Either[1]

 
 

Parameters:

pub - Publisher to construct an Either from

Returns:

Either constructed from the supplied Publisher

fromIterable

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

Construct a Right Either4 from the supplied Iterable

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

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

         //Either4[1]

 
 

Parameters:

iterable - Iterable to construct an Either from

Returns:

Either constructed from the supplied Iterable

rightEval

static <LT,M1,B,RT> Either4<LT,M1,B,RT> rightEval(Eval<RT> right)

Construct a Either4#Right from an Eval

Parameters:

right - Eval to construct Either4#Right from

Returns:

Either4 right instance

left1Eval

static <LT,M1,B,RT> Either4<LT,M1,B,RT> left1Eval(Eval<LT> left)

Construct a Either4#Left1 from an Eval

Parameters:

left - Eval to construct Either4#Left1 from

Returns:

Either4 Left1 instance

right

static <LT,M1,B,RT> Either4<LT,M1,B,RT> right(RT right)

Construct a Either4#Right

Parameters:

right - Value to store

Returns:

Either4 Right instance

left1

static <LT,M1,B,RT> Either4<LT,M1,B,RT> left1(LT left)

Construct a Either4#Left1

Parameters:

left - Value to store

Returns:

Left1 instance

left2

static <LT,M1,B,RT> Either4<LT,M1,B,RT> left2(M1 middle)

Construct a Either4#Second

Parameters:

middle - Value to store

Returns:

Second instance

left3

static <LT,M1,B,RT> Either4<LT,M1,B,RT> left3(B middle)

Construct a Either4#Third

Parameters:

middle - Value to store

Returns:

Third instance

left2Eval

static <LT,M1,B,RT> Either4<LT,M1,B,RT> left2Eval(Eval<M1> middle)

Construct a Either4#Second from an Eval

Parameters:

second - Eval to construct Either4#middle from

Returns:

Either4 second instance

left3Eval

static <LT,M1,B,RT> Either4<LT,M1,B,RT> left3Eval(Eval<B> middle)

Construct a Either4#Third from an Eval

Parameters:

third - Eval to construct Either4#middle from

Returns:

Either4 third instance

zipWith

default <R> Either4<LT1,LT2,LT3,R> zipWith(java.lang.Iterable<java.util.function.Function<? super RT,? extends R>> fn)

Specified by:

zipWith in interface Zippable<RT>

zipWithS

default <R> Either4<LT1,LT2,LT3,R> zipWithS(java.util.stream.Stream<java.util.function.Function<? super RT,? extends R>> fn)

Specified by:

zipWithS in interface Zippable<RT>

zipWithP

default <R> Either4<LT1,LT2,LT3,R> zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super RT,? extends R>> fn)

Specified by:

zipWithP in interface Zippable<RT>

retry

default <R> Either4<LT1,LT2,LT3,R> retry(java.util.function.Function<? super RT,? extends R> fn)

Description copied from interface: Transformable

Retry a transformation if it fails. Default settings are to retry up to 7 times, with an doubling backoff period starting @ 2 seconds delay before retry.

 
 given(serviceMock.applyHKT(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");


 		String result = ReactiveSeq.of( 1,  2, 3)
 				.retry(serviceMock)
 				.firstValue();

 		//result = 42
 
 

Specified by:

retry in interface Transformable<RT>

Parameters:

fn - Function to retry if fails

zipP

default <U> Either4<LT1,LT2,LT3,org.jooq.lambda.tuple.Tuple2<RT,U>> zipP(org.reactivestreams.Publisher<? extends U> other)

Specified by:

zipP in interface Zippable<RT>

retry

default <R> Either4<LT1,LT2,LT3,R> retry(java.util.function.Function<? super RT,? extends R> fn,
                                         int retries,
                                         long delay,
                                         java.util.concurrent.TimeUnit timeUnit)

Description copied from interface: Transformable

Retry a transformation if it fails. Retries up to retries times, with an doubling backoff period starting @ delay TimeUnits delay before retry.

 
 given(serviceMock.applyHKT(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");


 		String result = ReactiveSeq.of( 1,  2, 3)
 				.retry(serviceMock, 7, 2, TimeUnit.SECONDS)
 				.firstValue();

 		//result = 42
 
 

Specified by:

retry in interface Transformable<RT>

Parameters:

fn - Function to retry if fails

retries - Number of retries

delay - Delay in TimeUnits

timeUnit - TimeUnit to use for delay

zip3

default <S,U> Either4<LT1,LT2,LT3,org.jooq.lambda.tuple.Tuple3<RT,S,U>> zip3(java.lang.Iterable<? extends S> second,
                                                                             java.lang.Iterable<? extends U> third)

Description copied from interface: Zippable

zip 3 Streams into one

 
  List<Tuple3<Integer, Integer, Character>> list = of(1, 2, 3, 4, 5, 6).zip3(of(100, 200, 300, 400), of('a', 'b', 'c')).collect(CyclopsCollectors.toList());

  // [[1,100,'a'],[2,200,'b'],[3,300,'c']]
 

 

Specified by:

zip3 in interface Zippable<RT>

zip3

default <S,U,R> Either4<LT1,LT2,LT3,R> zip3(java.lang.Iterable<? extends S> second,
                                            java.lang.Iterable<? extends U> third,
                                            Fn3<? super RT,? super S,? super U,? extends R> fn3)

Specified by:

zip3 in interface Zippable<RT>

zip4

default <T2,T3,T4> Either4<LT1,LT2,LT3,org.jooq.lambda.tuple.Tuple4<RT,T2,T3,T4>> zip4(java.lang.Iterable<? extends T2> second,
                                                                                       java.lang.Iterable<? extends T3> third,
                                                                                       java.lang.Iterable<? extends T4> fourth)

Description copied from interface: Zippable

zip 4 Streams into 1

 
  List<Tuple4<Integer, Integer, Character, String>> list = of(1, 2, 3, 4, 5, 6).zip4(of(100, 200, 300, 400), of('a', 'b', 'c'), of("hello", "world"))
          .collect(CyclopsCollectors.toList());

 
 // [[1,100,'a',"hello"],[2,200,'b',"world"]]
 

Specified by:

zip4 in interface Zippable<RT>

zip4

default <T2,T3,T4,R> Either4<LT1,LT2,LT3,R> zip4(java.lang.Iterable<? extends T2> second,
                                                 java.lang.Iterable<? extends T3> third,
                                                 java.lang.Iterable<? extends T4> fourth,
                                                 Fn4<? super RT,? super T2,? super T3,? super T4,? extends R> fn)

Specified by:

zip4 in interface Zippable<RT>

flatMapS

default <R> Either4<LT1,LT2,LT3,R> flatMapS(java.util.function.Function<? super RT,? extends java.util.stream.Stream<? extends R>> mapper)

Specified by:

flatMapS in interface MonadicValue<RT>

flatMapI

default <RT1> Either4<LT1,LT2,LT3,RT1> flatMapI(java.util.function.Function<? super RT,? extends java.lang.Iterable<? extends RT1>> mapper)

Description copied from interface: MonadicValue

A flattening transformation operation that takes the first value from the returned Iterable.

  
   Maybe.just(1).map(i->i+2).flatMapI(i->Arrays.asList(()->i*3,20);
   //Maybe[9]
 
 

Specified by:

flatMapI in interface MonadicValue<RT>

Parameters:

mapper - transformation function

Returns:

MonadicValue

toTrampoline

default Trampoline<Either4<LT1,LT2,LT3,RT>> toTrampoline()

arity

default int arity()

Specified by:

arity in interface MonadicValue<RT>

flatMapP

default <RT1> Either4<LT1,LT2,LT3,RT1> flatMapP(java.util.function.Function<? super RT,? extends org.reactivestreams.Publisher<? extends RT1>> mapper)

Description copied from interface: MonadicValue

A flattening transformation operation that takes the first value from the returned Publisher.

  
   Future.ofResult(1).map(i->i+2).flatMapP(i->Flux.just(()->i*3,20);
   //Future[9]
 
 

Specified by:

flatMapP in interface MonadicValue<RT>

Parameters:

mapper - transformation function

Returns:

MonadicValue

visit

<R> R visit(java.util.function.Function<? super LT1,? extends R> left1,
            java.util.function.Function<? super LT2,? extends R> left2,
            java.util.function.Function<? super LT3,? extends R> left3,
            java.util.function.Function<? super RT,? extends R> right)

Visit the types in this Either4, only one user supplied function is executed depending on the type

Parameters:

left1 - Function to execute if this Either4 is a Left1 instance

left2 - Function to execute if this Either4 is a Left2 instance

left3 - Function to execute if this Either4 is a Left3 instance

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

Returns:

Result of executed function

filter

Maybe<RT> filter(java.util.function.Predicate<? super RT> test)

Filter this Either4 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>

Specified by:

filter in interface MonadicValue<RT>

Parameters:

test - Predicate to applyHKT to filter this Either4

Returns:

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

flatMap

<RT1> Either4<LT1,LT2,LT3,RT1> flatMap(java.util.function.Function<? super RT,? extends MonadicValue<? extends RT1>> mapper)

Flattening transformation on this Either4. Contains an internal trampoline so will convert tail-recursive calls to iteration.

Specified by:

flatMap in interface MonadicValue<RT>

Parameters:

mapper - Mapping function

Returns:

Mapped Either4

swap3

Either4<LT1,LT2,RT,LT3> swap3()

Returns:

Swap the third and the right types

swap2

Either4<LT1,RT,LT3,LT2> swap2()

Returns:

Swap the second and the right types

swap1

Either4<RT,LT2,LT3,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

isLeft3

boolean isLeft3()

Returns:

True if this lazy contains the left3 type

ofType

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

Description copied from interface: Filters

Keep only those elements in a reactiveStream 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

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

bimap

<R1,R2> Either4<LT1,LT2,R1,R2> bimap(java.util.function.Function<? super LT3,? 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<LT3,RT>

Parameters:

fn1 - transformation function for the first type

fn2 - transformation function for the second type

Returns:

New BiTransformable containing transformed data

map

<R> Either4<LT1,LT2,LT3,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 MonadicValue<RT>

Specified by:

map in interface Transformable<RT>

Parameters:

fn - Transformation function

Returns:

Transformed Transformable

toIor

default Ior<LT1,RT> toIor()

Return an Ior that can be this object or a Ior.primary or Ior.secondary

Specified by:

toIor in interface Value<RT>

Returns:

new Ior

toXor

default Xor<LT1,RT> toXor()

Specified by:

toXor in interface Value<RT>

Returns:

Primary Xor that has the same value as this Value

coflatMap

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

Description copied from interface: MonadicValue

Perform a coflatMap operation. The mapping function accepts this MonadicValue and returns a singleUnsafe value to be wrapped inside a Monad.

  
   Maybe.none().coflatMap(m -> m.isPresent() ? m.get() : 10);
   //Maybe[10]
 
 

Specified by:

coflatMap in interface MonadicValue<RT>

Parameters:

mapper - Mapping / transformation function

Returns:

MonadicValue wrapping return value from transformation function applied to the value inside this MonadicValue

nest

default Either4<LT1,LT2,LT3,MonadicValue<RT>> nest()

Description copied from interface: MonadicValue

cojoin pattern. Nests this Monad inside another.

Specified by:

nest in interface MonadicValue<RT>

Returns:

Nested Monad

forEach4

default <T2,R1,R2,R3,R> Either4<LT1,LT2,LT3,R> forEach4(java.util.function.Function<? super RT,? extends MonadicValue<R1>> value1,
                                                        java.util.function.BiFunction<? super RT,? super R1,? extends MonadicValue<R2>> value2,
                                                        Fn3<? super RT,? super R1,? super R2,? extends MonadicValue<R3>> value3,
                                                        Fn4<? super RT,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Description copied from interface: MonadicValue

Perform a four level nested internal iteration over this MonadicValue and the supplied MonadicValues

  
  Maybe.of(3)
       .forEach4(a->Maybe.just(a+10),
                 (a,b)->Maybe.just(a+b),
                 (a,b,c)->Maybe.none(),
                 (a,b,c,d)->a+b+c+d);
                                  
  
  //Maybe.none
 
 

Specified by:

forEach4 in interface MonadicValue<RT>

Parameters:

value1 - Nested MonadicValue to iterate over

value2 - Nested MonadicValue to iterate over

value3 - Nested MonadicValue to iterate over

yieldingFunction - Function with pointers to the current element from both MonadicValue that generates the new elements

Returns:

MonadicValue with elements generated via nested iteration

forEach4

default <T2,R1,R2,R3,R> Either4<LT1,LT2,LT3,R> forEach4(java.util.function.Function<? super RT,? extends MonadicValue<R1>> value1,
                                                        java.util.function.BiFunction<? super RT,? super R1,? extends MonadicValue<R2>> value2,
                                                        Fn3<? super RT,? super R1,? super R2,? extends MonadicValue<R3>> value3,
                                                        Fn4<? super RT,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
                                                        Fn4<? super RT,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Description copied from interface: MonadicValue

Perform a four level nested internal iteration over this MonadicValue and the supplied MonadicValues Maybe.of(3) .forEach4(a->Maybe.just(a+10), (a,b)->Maybe.just(a+b), (a,b,c)->Maybe.none(), (a,b,c,d)->a+b+c<100, (a,b,c,d)->a+b+c+d); //Maybe.none

Specified by:

forEach4 in interface MonadicValue<RT>

Parameters:

value1 - Nested MonadicValue to iterate over

value2 - Nested MonadicValue to iterate over

value3 - Nested MonadicValue to iterate over

filterFunction - Filter to applyHKT over elements before passing non-filtered values to the yielding function

yieldingFunction - Function with pointers to the current element from both MonadicValue that generates the new elements

Returns:

MonadicValue with elements generated via nested iteration

forEach3

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

Description copied from interface: MonadicValue

Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues

  
  Maybe.of(3)
       .forEach3(a->Maybe.just(a+10),
                 (a,b)->Maybe.just(a+b),
                 (a,b,c)->a+b+c<100,
                 (a,b,c)->a+b+c);
                                  
  
  //Maybe[32]
 
 

Specified by:

forEach3 in interface MonadicValue<RT>

Parameters:

value1 - Nested MonadicValue to iterate over

value2 - Nested MonadicValue to iterate over

yieldingFunction - Function with pointers to the current element from both MonadicValue that generates the new elements

Returns:

MonadicValue with elements generated via nested iteration

forEach3

default <T2,R1,R2,R> Either4<LT1,LT2,LT3,R> forEach3(java.util.function.Function<? super RT,? extends MonadicValue<R1>> value1,
                                                     java.util.function.BiFunction<? super RT,? super R1,? extends MonadicValue<R2>> value2,
                                                     Fn3<? super RT,? super R1,? super R2,java.lang.Boolean> filterFunction,
                                                     Fn3<? super RT,? super R1,? super R2,? extends R> yieldingFunction)

Description copied from interface: MonadicValue

Perform a three level nested internal iteration over this MonadicValue and the supplied MonadicValues

  
  Maybe.of(3)
       .forEach3(a->Maybe.just(a+10),
                 (a,b)->Maybe.just(a+b),
                 (a,b,c)->a+b+c<100,
                 (a,b,c)->a+b+c);
                                  
  
  //Maybe[32]
 
 

Specified by:

forEach3 in interface MonadicValue<RT>

Parameters:

value1 - Nested MonadicValue to iterate over

value2 - Nested MonadicValue to iterate over

filterFunction - Filter to applyHKT over elements before passing non-filtered values to the yielding function

yieldingFunction - Function with pointers to the current element from both MonadicValue that generates the new elements

Returns:

MonadicValue with elements generated via nested iteration

forEach2

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

Description copied from interface: MonadicValue

Perform a two level nested internal iteration over this MonadicValue and the supplied MonadicValue

  
  Maybe.of(3)
       .forEach2(a->Maybe.none(),
                 (a,b)->a+b);
                                  
 
  //Maybe.none()
 
 

Specified by:

forEach2 in interface MonadicValue<RT>

Parameters:

value1 - Nested Monadic Type to iterate over

yieldingFunction - Function with pointers to the current element from both monad types that generates the new elements

Returns:

MonadicValue with elements generated via nested iteration

forEach2

default <R1,R> Either4<LT1,LT2,LT3,R> forEach2(java.util.function.Function<? super RT,? extends MonadicValue<R1>> value1,
                                               java.util.function.BiFunction<? super RT,? super R1,java.lang.Boolean> filterFunction,
                                               java.util.function.BiFunction<? super RT,? super R1,? extends R> yieldingFunction)

Description copied from interface: MonadicValue

Perform a two level nested internal iteration over this MonadicValue and the supplied reactiveStream

  
  Maybe.of(3)
       .forEach2(a->Maybe.none(),
                 a->b-> a<3 && b>10,
                 (a,b)->a+b);
                                  
 
  //Maybe.none()
 
 

Specified by:

forEach2 in interface MonadicValue<RT>

filterFunction - Filter to applyHKT over elements before passing non-filtered values to the yielding function

yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements

Returns:

MonadicValue with elements generated via nested iteration

combineEager

default Either4<LT1,LT2,LT3,RT> combineEager(Monoid<RT> monoid,
                                             MonadicValue<? extends RT> v2)

Description copied from interface: MonadicValue

Eagerly combine two MonadicValues using the supplied monoid (@see ApplicativeFunctor for type appropraite i.e. maybe / async alternatives)

  
 
  Monoid<Integer> add = Monoid.of(1,SemigroupK.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 , SemigroupK.firstNonNull());
  Maybe.of(10).combineEager(firstNonNull,Maybe.of(10));
  //Maybe[10]
 

Specified by:

combineEager in interface MonadicValue<RT>

Returns:

combine

default <T2,R> Either4<LT1,LT2,LT3,R> combine(Value<? extends T2> app,
                                              java.util.function.BiFunction<? super RT,? super T2,? extends R> fn)

Description copied from interface: MonadicValue

Lazily combine this ApplicativeFunctor with the supplied value via the supplied BiFunction Example

 
   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

 
 

Specified by:

combine in interface MonadicValue<RT>

Parameters:

app - Value to combine with this one.

fn - BiFunction to combine them

Returns:

New Applicativefunctor that represents the combined values

zip

default Either4<LT1,LT2,LT3,RT> zip(java.util.function.BinaryOperator<Zippable<RT>> combiner,
                                    Zippable<RT> app)

Description copied from interface: Zippable

Combine two applicatives together using the provided BinaryOperator (Semigroup, Monoid and Reducer all extend BinaryOperator - checkout SemigroupK and Monoids for a large number of canned combinations). If this Applicative is a scalar value the provided value is combined with that value, otherwise the value is combined pair wise with all value in a non-scalar datastructure

Specified by:

zip in interface Zippable<RT>

Returns:

See Also:

Semigroup, Semigroups, Monoid, To lift any Semigroup (or monoid) up to handling Applicatives use the combineApplicatives operator in SemigroupK {@see com.aol.cyclops2.SemigroupK#combineApplicatives(BiFunction) } or Monoids { {@see com.aol.cyclops2.Monoids#combineApplicatives(java.util.function.Function, com.aol.cyclops2.function.Monoid) }

 {@code


  BinaryOperator> sumMaybes = SemigroupK.combineScalarFunctors(SemigroupK.intSum);
        Maybe.just(1).zip(sumMaybes, Maybe.just(5))
       //Maybe.just(6));
 }
 

zipS

default <U,R> Either4<LT1,LT2,LT3,R> zipS(java.util.stream.Stream<? extends U> other,
                                          java.util.function.BiFunction<? super RT,? super U,? extends R> zipper)

Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Stream, using the supplied combining function

Specified by:

zipS in interface Zippable<RT>

Parameters:

other - Stream to combine with

zipper - Zip / combining function

Returns:

Combined zippable

zipS

default <U> Either4<LT1,LT2,LT3,org.jooq.lambda.tuple.Tuple2<RT,U>> zipS(java.util.stream.Stream<? extends U> other)

Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2

Specified by:

zipS in interface Zippable<RT>

Parameters:

other - Stream to combine with

Returns:

Combined Zippable

zip

default <U> Either4<LT1,LT2,LT3,org.jooq.lambda.tuple.Tuple2<RT,U>> zip(java.lang.Iterable<? extends U> other)

Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2

Specified by:

zip in interface Zippable<RT>

Parameters:

other - Iterable to combine with

Returns:

unit

<T> Either4<LT1,LT2,LT3,T> unit(T unit)

Specified by:

unit in interface MonadicValue<RT>

Specified by:

unit in interface Unit<RT>

zip

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

Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Iterable using the supplied combining function

Specified by:

zip in interface MonadicValue<RT>

Specified by:

zip in interface Zippable<RT>

Parameters:

app - to zip with

fn - Zip function

Returns:

Combined zippable

zipP

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

Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function

Specified by:

zipP in interface MonadicValue<RT>

Specified by:

zipP in interface Zippable<RT>

Parameters:

app - to combine with

fn - Zip / combining function

Returns:

Combined zippable

bipeek

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

Parameters:

c1 - consumer for the first type

c2 - consumer for the second type

Returns:

New BiTransformable with the same data

bicast

default <U1,U2> Either4<LT1,LT2,U1,U2> bicast(java.lang.Class<U1> type1,
                                              java.lang.Class<U2> type2)

Description copied from interface: BiTransformable

Cast two data types simulatanously.

 
     MapX<Animal,Food> map = MapXs.of(cow,grass);
     MapX<Mamaml,Vegitation> herbervoreMammals = map.bicast(Mammal.class,Vegitation.class);
 
 

Specified by:

bicast in interface BiTransformable<LT3,RT>

Returns:

bitrampoline

default <R1,R2> Either4<LT1,LT2,R1,R2> bitrampoline(java.util.function.Function<? super LT3,? extends Trampoline<? extends R1>> mapper1,
                                                    java.util.function.Function<? super RT,? extends Trampoline<? extends R2>> mapper2)

Description copied from interface: BiTransformable

Perform a tail-call optimized recursive transformation operation across two data points simultaneously

Specified by:

bitrampoline in interface BiTransformable<LT3,RT>

Parameters:

mapper1 - transformation function for the first type

mapper2 - transformation function for the second type

Returns:

New BiTransformable containing transformed data

cast

default <U> Either4<LT1,LT2,LT3,U> cast(java.lang.Class<? extends U> type)

Description copied from interface: Transformable

Cast all elements in a reactiveStream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)

Specified by:

cast in interface Transformable<RT>

peek

default Either4<LT1,LT2,LT3,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

trampoline

default <R> Either4<LT1,LT2,LT3,R> trampoline(java.util.function.Function<? super RT,? extends Trampoline<? extends R>> mapper)

Description copied from interface: Transformable

Performs a map operation that can call a recursive method without running out of stack space

 
 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
 
 

Specified by:

trampoline in interface Transformable<RT>

Parameters:

mapper - TCO Transformation function

Returns:

Transformable transformed by the supplied transformation function

narrowK3

static <L1,L2,L3,T> Either4<L1,L2,L3,T> narrowK3(Higher4<Witness.either4,L1,L2,L3,T> xor)

narrowK

static <L1,L2,L3,T> Either4<L1,L2,L3,T> narrowK(Higher<Higher<Higher<Higher<Witness.either4,L1>,L2>,L3>,T> xor)

allTypeclasses

default Active<Higher<Higher<Higher<Witness.either4,LT1>,LT2>,LT3>,RT> allTypeclasses()

mapM

default <W2,R> Nested<Higher<Higher<Higher<Witness.either4,LT1>,LT2>,LT3>,W2,R> mapM(java.util.function.Function<? super RT,? extends Higher<W2,R>> fn,
                                                                                     InstanceDefinitions<W2> defs)