T
- Data type of element stored in Maybepublic interface Maybe<T> extends To<Maybe<T>>, MonadicValue<T>, Higher<Maybe.µ,T>
//eagerly load data
Optional.of(10)
.map(this::load);
//lazily tee up loading of data until needed
Maybe.of(10)
.map(this::load);
.
Maybe is tail recursive
{@code
Modifier and Type | Interface and Description |
---|---|
static class |
Maybe.µ |
static class |
Maybe.Instances
Companion class for creating Type Class instances for working with Maybes
|
static class |
Maybe.Just<T> |
static class |
Maybe.Lazy<T> |
static class |
Maybe.Nothing<T> |
Value.ValueImpl<T>
Convertable.SupplierToConvertable<T>
Fn0.FunctionalOperations<R>, Fn0.SupplierKind<R>
Modifier and Type | Method and Description |
---|---|
static <T,R> Maybe<R> |
accumulateJust(CollectionX<Maybe<T>> maybes,
java.util.function.Function<? super T,R> mapper,
Monoid<R> reducer)
Accumulate the results only from those Maybes which have a value present, using the supplied mapping function to
convert the data from each Maybe before reducing them using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two
input values of the same type and returns the combined result)
cyclops2.Monoids .. |
static <T,R> Maybe<R> |
accumulateJust(CollectionX<Maybe<T>> maybes,
Reducer<R> reducer)
Accummulating operation using the supplied Reducer (@see cyclops2.Reducers).
|
static <T> Maybe<T> |
accumulateJust(Monoid<T> reducer,
CollectionX<Maybe<T>> maybes)
Accumulate the results only from those Maybes which have a value present, using the supplied Monoid (a combining BiFunction/BinaryOperator and identity element that takes two
input values of the same type and returns the combined result)
cyclops2.Monoids . |
default AnyM<Witness.maybe,T> |
anyM() |
static <T,R> java.util.function.Function<? super T,? extends Maybe<R>> |
arrow(java.util.function.Function<? super T,? extends R> fn) |
default <U> Maybe<U> |
cast(java.lang.Class<? extends U> type)
Cast all elements in a stream to a given type, possibly throwing a
ClassCastException . |
default <R> Maybe<R> |
coflatMap(java.util.function.Function<? super MonadicValue<T>,R> mapper)
Perform a coflatMap operation.
|
default <T2,R> Maybe<R> |
combine(Value<? extends T2> app,
java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
Lazily combine this ApplicativeFunctor with the supplied value via the supplied BiFunction
Example
|
default Maybe<T> |
combineEager(Monoid<T> monoid,
MonadicValue<? extends T> v2)
Eagerly combine two MonadicValues using the supplied monoid (@see ApplicativeFunctor for type appropraite i.e.
|
Maybe<T> |
filter(java.util.function.Predicate<? super T> fn)
Keep only elements for which the supplied predicates hold
e.g.
|
default Maybe<T> |
filterNot(java.util.function.Predicate<? super T> fn)
Remove any elements for which the predicate holds (inverse operation to filter)
e.g.
|
<R> Maybe<R> |
flatMap(java.util.function.Function<? super T,? extends MonadicValue<? extends R>> mapper)
A flattening transformation operation (@see
Optional.flatMap(Function) |
default <R> Maybe<R> |
flatMapI(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
A flattening transformation operation that takes the first value from the returned Iterable.
|
default <R> Maybe<R> |
flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
A flattening transformation operation that takes the first value from the returned Publisher.
|
default <R> Maybe<R> |
flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> mapper) |
default <R1,R> Maybe<R> |
forEach2(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
Perform a two level nested internal iteration over this MonadicValue and the
supplied MonadicValue
|
default <R1,R> Maybe<R> |
forEach2(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction,
java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
Perform a two level nested internal iteration over this MonadicValue and the
supplied stream
|
default <T2,R1,R2,R> |
forEach3(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2,
Fn3<? super T,? 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> |
forEach3(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2,
Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction,
Fn3<? super T,? 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> |
forEach4(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2,
Fn3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3,
Fn4<? super T,? 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> |
forEach4(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1,
java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2,
Fn3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3,
Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
Fn4<? super T,? 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 <T> Maybe<T> |
fromEval(Eval<T> eval)
Construct a Maybe from the supplied Eval
|
static <T> Maybe<T> |
fromEvalNullable(Eval<T> eval) |
static <T> Maybe<T> |
fromEvalOf(Eval<T> eval)
Deprecated.
|
static <T> Maybe<T> |
fromEvalOptional(Eval<java.util.Optional<T>> value) |
static <T> Maybe<T> |
fromIterable(java.lang.Iterable<T> iterable)
Construct a Maybe that contains a single value extracted from the supplied Iterable
|
static <T> Maybe<T> |
fromLazy(Eval<Maybe<T>> lazy) |
static <T> Maybe<T> |
fromOptional(Higher<OptionalKind.µ,T> optional)
Construct an equivalent Maybe from the Supplied Optional
|
static <T> Maybe<T> |
fromOptional(java.util.Optional<T> opt)
Construct an equivalent Maybe from the Supplied Optional
|
static <T> Maybe<T> |
fromOptionalKind(OptionalKind<T> opt) |
static <T> Maybe<T> |
fromPublisher(org.reactivestreams.Publisher<T> pub)
Construct a Maybe that contains a single value extracted from the supplied reactive-streams Publisher
|
static <R> Maybe<R> |
fromStream(java.util.stream.Stream<? extends R> apply) |
boolean |
isPresent() |
static <T> Maybe<T> |
just(T value)
Construct an Maybe which contains the provided (non-null) value.
|
<R> Maybe<R> |
map(java.util.function.Function<? super T,? extends R> mapper)
Transform this functor using the supplied transformation function
|
static <T> Maybe<T> |
narrow(Maybe<? extends T> broad)
Narrow covariant type parameter
|
static <T> Maybe<T> |
narrowK(Higher<Maybe.µ,T> future)
Convert the raw Higher Kinded Type for MaybeType types into the MaybeType type definition class
|
static <T> java.util.Optional<T> |
narrowOptional(Higher<Maybe.µ,T> maybe)
Convert the HigherKindedType definition for a Maybe into
|
default Maybe<MonadicValue<T>> |
nest()
cojoin pattern.
|
static <T> Maybe<T> |
none() |
default Maybe<T> |
notNull()
Filter elements retaining only values which are not null
|
static <T> Maybe<T> |
of(T value)
Construct an Maybe which contains the provided (non-null) value
Equivalent to @see
just(Object) |
static <T> Maybe<T> |
ofNullable(T value)
Maybe<Integer> maybe = Maybe.ofNullable(null);
//None
Maybe<Integer> maybe = Maybe.ofNullable(10);
//Maybe[10], Some[10]
|
default <U> Maybe<U> |
ofType(java.lang.Class<? extends U> type)
Keep only those elements in a stream that are of a given type.
|
default Maybe<T> |
peek(java.util.function.Consumer<? super T> c)
Peek at the current value of this Transformable, without transforming it
|
Maybe<T> |
recover(java.util.function.Supplier<T> value) |
Maybe<T> |
recover(T value) |
Maybe<T> |
recoverWith(java.util.function.Supplier<? extends Maybe<T>> fn) |
default <R> Maybe<R> |
retry(java.util.function.Function<? super T,? extends R> fn)
Retry a transformation if it fails.
|
default <R> Maybe<R> |
retry(java.util.function.Function<? super T,? extends R> fn,
int retries,
long delay,
java.util.concurrent.TimeUnit timeUnit)
Retry a transformation if it fails.
|
static <T> Maybe<ListX<T>> |
sequence(CollectionX<Maybe<T>> maybes)
Sequence operation, take a Collection of Maybes and turn it into a Maybe with a Collection
By constrast with
sequenceJust(CollectionX) if any Maybe types are None / empty
the return type will be an empty Maybe / None |
static <T> Maybe<ReactiveSeq<T>> |
sequence(java.util.stream.Stream<Maybe<T>> maybes)
Sequence operation, take a Stream of Maybes and turn it into a Maybe with a Stream
By constrast with
sequenceJust(CollectionX) Maybe#empty/ None types are
result in the returned Maybe being Maybe.empty / None |
static <T> Maybe<ListX<T>> |
sequenceJust(CollectionX<Maybe<T>> maybes)
Sequence operation, take a Collection of Maybes and turn it into a Maybe with a Collection
Only successes are retained.
|
default Maybe<T> |
toMaybe()
Returns a function result or a supplier result.
|
default <R> Maybe<R> |
trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)
Performs a map operation that can call a recursive method without running out of stack space
|
default <T> Maybe<T> |
unit(T unit) |
<R> R |
visit(java.util.function.Function<? super T,? extends R> some,
java.util.function.Supplier<? extends R> none)
The provided function is executed with the value stored in this Visitable if one is present,
otherwise the provided Supplier is executed instead.
|
static <C2,T> Higher<C2,Higher<Maybe.µ,T>> |
widen2(Higher<C2,Maybe<T>> nestedMaybe) |
default Maybe<T> |
zip(java.util.function.BinaryOperator<Zippable<T>> combiner,
Zippable<T> 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).
|
default <T2,R> Maybe<R> |
zip(java.lang.Iterable<? extends T2> app,
java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
|
default <U> Maybe<org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(java.lang.Iterable<? extends U> other)
Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2
|
default <S,U> Maybe<org.jooq.lambda.tuple.Tuple3<T,S,U>> |
zip3(java.lang.Iterable<? extends S> second,
java.lang.Iterable<? extends U> third)
zip 3 Streams into one
|
default <S,U,R> Maybe<R> |
zip3(java.lang.Iterable<? extends S> second,
java.lang.Iterable<? extends U> third,
Fn3<? super T,? super S,? super U,? extends R> fn3) |
default <T2,T3,T4> Maybe<org.jooq.lambda.tuple.Tuple4<T,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> |
zip4(java.lang.Iterable<? extends T2> second,
java.lang.Iterable<? extends T3> third,
java.lang.Iterable<? extends T4> fourth,
Fn4<? super T,? super T2,? super T3,? super T4,? extends R> fn) |
default <T2,R> Maybe<R> |
zipP(org.reactivestreams.Publisher<? extends T2> app,
java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
|
default <U> Maybe<org.jooq.lambda.tuple.Tuple2<T,U>> |
zipP(org.reactivestreams.Publisher<? extends U> other) |
default <U> Maybe<org.jooq.lambda.tuple.Tuple2<T,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> Maybe<R> |
zipS(java.util.stream.Stream<? extends U> other,
java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
|
default <R> Maybe<R> |
zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn) |
default <R> Maybe<R> |
zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn) |
default <R> Maybe<R> |
zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn) |
apply, generate, iterate, iterator, mkString, newSubscriber, stream, subscribe, test, toEvalAlways, toEvalLater, toEvalNow, toIor, toTry, toTry, toTry, toXor, toXor
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, singleOptional, startsWith, startsWithIterable, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, xMatch
futureStream, getStreamable, isEmpty, jdkStream, reactiveSeq, reveresedJDKStream, reveresedStream
collect, fromSupplier, get, orElse, orElseGet, orElseThrow, toCompletableFuture, toCompletableFutureAsync, toCompletableFutureAsync, toFuture, toFutureWAsync, toFutureWAsync, toOptional, toStream
static final Maybe EMPTY
default AnyM<Witness.maybe,T> anyM()
static <T,R> java.util.function.Function<? super T,? extends Maybe<R>> arrow(java.util.function.Function<? super T,? extends R> fn)
static <T> Maybe<T> fromOptional(Higher<OptionalKind.µ,T> optional)
MaybeType<Integer> some = MaybeType.fromOptional(Optional.of(10));
//Maybe[10], Some[10]
MaybeType<Integer> none = MaybeType.fromOptional(Optional.empty());
//Maybe.empty, None[]
opt
- Optional to construct Maybe fromstatic <T> Maybe<T> narrowK(Higher<Maybe.µ,T> future)
future
- HKT encoded list into a MaybeTypestatic <T> java.util.Optional<T> narrowOptional(Higher<Maybe.µ,T> maybe)
MaybeType
- Constructor to convert back into narrowed typestatic <T> Maybe<T> none()
default <R> Maybe<R> flatMapI(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
MonadicValue
Maybe.just(1).map(i->i+2).flatMapI(i->Arrays.asList(()->i*3,20);
//Maybe[9]
flatMapI
in interface MonadicValue<T>
mapper
- transformation functiondefault <R> Maybe<R> flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
MonadicValue
FutureW.ofResult(1).map(i->i+2).flatMapP(i->Flux.just(()->i*3,20);
//FutureW[9]
flatMapP
in interface MonadicValue<T>
mapper
- transformation functionstatic <T> Maybe<T> fromPublisher(org.reactivestreams.Publisher<T> pub)
ReactiveSeq<Integer> stream = ReactiveSeq.of(1,2,3);
Maybe<Integer> maybe = Maybe.fromPublisher(stream);
//Maybe[1]
pub
- Publisher to extract value fromstatic <T> Maybe<T> fromIterable(java.lang.Iterable<T> iterable)
ReactiveSeq<Integer> stream = ReactiveSeq.of(1,2,3);
Maybe<Integer> maybe = Maybe.fromIterable(stream);
//Maybe[1]
iterable
- Iterable to extract value fromstatic <R> Maybe<R> fromStream(java.util.stream.Stream<? extends R> apply)
static <T> Maybe<T> fromOptional(java.util.Optional<T> opt)
Maybe<Integer> some = Maybe.fromOptional(Optional.of(10));
//Maybe[10], Some[10]
Maybe<Integer> none = Maybe.fromOptional(Optional.empty());
//Maybe.empty, None[]
opt
- Optional to construct Maybe fromstatic <T> Maybe<T> fromOptionalKind(OptionalKind<T> opt)
static <T> Maybe<T> fromEval(Eval<T> eval)
Maybe<Integer> maybe = Maybe.fromEval(Eval.now(10));
//Maybe[10]
eval
- Eval to construct Maybe fromstatic <T> Maybe<T> just(T value)
of(Object)
Maybe<Integer> some = Maybe.just(10);
some.map(i->i*2);
value
- Value to wrap inside a Maybestatic <T> Maybe<T> of(T value)
just(Object)
Maybe<Integer> some = Maybe.of(10);
some.map(i->i*2);
static <T> Maybe<T> ofNullable(T value)
Maybe<Integer> maybe = Maybe.ofNullable(null);
//None
Maybe<Integer> maybe = Maybe.ofNullable(10);
//Maybe[10], Some[10]
value
- static <T> Maybe<T> narrow(Maybe<? extends T> broad)
broad
- Maybe with covariant type parameterstatic <T> Maybe<ListX<T>> sequenceJust(CollectionX<Maybe<T>> maybes)
sequence(CollectionX)
Maybe#empty/ None types are
tolerated and ignored.
Maybe<Integer> just = Maybe.of(10);
Maybe<Integer> none = Maybe.none();
Maybe<ListX<Integer>> maybes = Maybe.sequenceJust(ListX.of(just, none, Maybe.of(1)));
//Maybe.of(ListX.of(10, 1));
maybes
- Maybes to Sequencestatic <T> Maybe<ListX<T>> sequence(CollectionX<Maybe<T>> maybes)
sequenceJust(CollectionX)
if any Maybe types are None / empty
the return type will be an empty Maybe / None
Maybe<Integer> just = Maybe.of(10);
Maybe<Integer> none = Maybe.none();
Maybe<ListX<Integer>> maybes = Maybe.sequence(ListX.of(just, none, Maybe.of(1)));
//Maybe.none();
maybes
- Maybes to Sequencestatic <T> Maybe<ReactiveSeq<T>> sequence(java.util.stream.Stream<Maybe<T>> maybes)
sequenceJust(CollectionX)
Maybe#empty/ None types are
result in the returned Maybe being Maybe.empty / None
Maybe<Integer> just = Maybe.of(10);
Maybe<Integer> none = Maybe.none();
Maybe<ReactiveSeq<Integer>> maybes = Maybe.sequence(Stream.of(just, none, Maybe.of(1)));
//Maybe.none();
maybes
- Maybes to Sequencestatic <T,R> Maybe<R> accumulateJust(CollectionX<Maybe<T>> maybes, Reducer<R> reducer)
Maybe<Integer> just = Maybe.of(10);
Maybe<Integer> none = Maybe.none();
Maybe<PSetX<Integer>> maybes = Maybe.accumulateJust(ListX.of(just, none, Maybe.of(1)), Reducers.toPSetX());
//Maybe.of(PSetX.of(10, 1)));
maybes
- Maybes to accumulatereducer
- Reducer to accumulate values withstatic <T,R> Maybe<R> accumulateJust(CollectionX<Maybe<T>> maybes, java.util.function.Function<? super T,R> mapper, Monoid<R> reducer)
cyclops2.Monoids
..
Maybe<Integer> just = Maybe.of(10);
Maybe<Integer> none = Maybe.none();
Maybe<String> maybes = Maybe.accumulateJust(ListX.of(just, none, Maybe.of(1)), i -> "" + i,
Semigroups.stringConcat);
//Maybe.of("101")
maybes
- Maybes to accumulatemapper
- Mapping function to be applied to the result of each Maybereducer
- Monoid to combine values from each Maybestatic <T> Maybe<T> accumulateJust(Monoid<T> reducer, CollectionX<Maybe<T>> maybes)
cyclops2.Monoids
.
Maybe<Integer> maybes = Maybe.accumulateJust(Monoids.intSum,ListX.of(just, none, Maybe.of(1)));
//Maybe.of(11)
maybes
- Maybes to accumulatereducer
- Monoid to combine values from each Maybedefault <R> Maybe<R> zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn)
default <R> Maybe<R> zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn)
default <R> Maybe<R> zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn)
default <R> Maybe<R> retry(java.util.function.Function<? super T,? extends R> fn)
Transformable
given(serviceMock.apply(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
retry
in interface Transformable<T>
fn
- Function to retry if failsdefault <U> Maybe<org.jooq.lambda.tuple.Tuple2<T,U>> zipP(org.reactivestreams.Publisher<? extends U> other)
default <R> Maybe<R> retry(java.util.function.Function<? super T,? extends R> fn, int retries, long delay, java.util.concurrent.TimeUnit timeUnit)
Transformable
given(serviceMock.apply(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
retry
in interface Transformable<T>
fn
- Function to retry if failsretries
- Number of retriesdelay
- Delay in TimeUnitstimeUnit
- TimeUnit to use for delaydefault <S,U> Maybe<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third)
Zippable
List<Tuple3<Integer, Integer, Character>> list = of(1, 2, 3, 4, 5, 6).zip3(of(100, 200, 300, 400), of('a', 'b', 'c')).collect(Collectors.toList());
// [[1,100,'a'],[2,200,'b'],[3,300,'c']]
default <S,U,R> Maybe<R> zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third, Fn3<? super T,? super S,? super U,? extends R> fn3)
default <T2,T3,T4> Maybe<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth)
Zippable
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(Collectors.toList());
// [[1,100,'a',"hello"],[2,200,'b',"world"]]
default <T2,T3,T4,R> Maybe<R> zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth, Fn4<? super T,? super T2,? super T3,? super T4,? extends R> fn)
default <R> Maybe<R> flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> mapper)
flatMapS
in interface MonadicValue<T>
default <T2,R1,R2,R3,R> Maybe<R> forEach4(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2, Fn3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
MonadicValue
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
forEach4
in interface MonadicValue<T>
value1
- Nested MonadicValue to iterate overvalue2
- Nested MonadicValue to iterate overvalue3
- Nested MonadicValue to iterate overyieldingFunction
- Function with pointers to the current element from both
MonadicValue that generates the new elementsdefault <T2,R1,R2,R3,R> Maybe<R> forEach4(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2, Fn3<? super T,? super R1,? super R2,? extends MonadicValue<R3>> value3, Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
MonadicValue
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
forEach4
in interface MonadicValue<T>
value1
- Nested MonadicValue to iterate overvalue2
- Nested MonadicValue to iterate overvalue3
- Nested MonadicValue to iterate overfilterFunction
- Filter to apply over elements before passing non-filtered
values to the yielding functionyieldingFunction
- Function with pointers to the current element from both
MonadicValue that generates the new elementsdefault <T2,R1,R2,R> Maybe<R> forEach3(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
MonadicValue
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]
forEach3
in interface MonadicValue<T>
value1
- Nested MonadicValue to iterate overvalue2
- Nested MonadicValue to iterate overyieldingFunction
- Function with pointers to the current element from both
MonadicValue that generates the new elementsdefault <T2,R1,R2,R> Maybe<R> forEach3(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends MonadicValue<R2>> value2, Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
MonadicValue
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]
forEach3
in interface MonadicValue<T>
value1
- Nested MonadicValue to iterate overvalue2
- Nested MonadicValue to iterate overfilterFunction
- Filter to apply over elements before passing non-filtered
values to the yielding functionyieldingFunction
- Function with pointers to the current element from both
MonadicValue that generates the new elementsdefault <R1,R> Maybe<R> forEach2(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
MonadicValue
Maybe.of(3)
.forEach2(a->Maybe.none(),
(a,b)->a+b);
//Maybe.none()
forEach2
in interface MonadicValue<T>
value1
- Nested Monadic Type to iterate overyieldingFunction
- Function with pointers to the current element from both
monad types that generates the new elementsdefault <R1,R> Maybe<R> forEach2(java.util.function.Function<? super T,? extends MonadicValue<R1>> value1, java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
MonadicValue
Maybe.of(3)
.forEach2(a->Maybe.none(),
a->b-> a<3 && b>10,
(a,b)->a+b);
//Maybe.none()
forEach2
in interface MonadicValue<T>
filterFunction
- Filter to apply over elements before passing non-filtered
values to the yielding functionyieldingFunction
- Function with pointers to the current element from both
Streams that generates the new elementsdefault <T2,R> Maybe<R> combine(Value<? extends T2> app, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
MonadicValue
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
combine
in interface MonadicValue<T>
app
- Value to combine with this one.fn
- BiFunction to combine themdefault <T2,R> Maybe<R> zip(java.lang.Iterable<? extends T2> app, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
Zippable
default <T2,R> Maybe<R> zipP(org.reactivestreams.Publisher<? extends T2> app, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
Zippable
default Maybe<T> zip(java.util.function.BinaryOperator<Zippable<T>> combiner, Zippable<T> app)
Zippable
zip
in interface Zippable<T>
Semigroup
,
Semigroups
,
Monoid
,
To lift any Semigroup (or monoid) up to handling Applicatives use the combineApplicatives operator in Semigroups
{@see com.aol.cyclops2.Semigroups#combineApplicatives(BiFunction) } or Monoids
{ {@see com.aol.cyclops2.Monoids#combineApplicatives(java.util.function.Function, com.aol.cyclops2.function.Monoid)
}
{@code
BinaryOperator> sumMaybes = Semigroups.combineScalarFunctors(Semigroups.intSum);
Maybe.just(1).zip(sumMaybes, Maybe.just(5))
//Maybe.just(6));
}
default <U,R> Maybe<R> zipS(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zippable
default <U> Maybe<org.jooq.lambda.tuple.Tuple2<T,U>> zipS(java.util.stream.Stream<? extends U> other)
Zippable
default <U> Maybe<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
Zippable
default <T> Maybe<T> unit(T unit)
default <R> Maybe<R> coflatMap(java.util.function.Function<? super MonadicValue<T>,R> mapper)
MonadicValue
Maybe.none().coflatMap(m -> m.isPresent() ? m.get() : 10);
//Maybe[10]
coflatMap
in interface MonadicValue<T>
mapper
- Mapping / transformation functiondefault Maybe<MonadicValue<T>> nest()
MonadicValue
nest
in interface MonadicValue<T>
default Maybe<T> combineEager(Monoid<T> monoid, MonadicValue<? extends T> v2)
MonadicValue
Monoid<Integer> add = Monoid.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 MonadicValue<T>
default Maybe<T> toMaybe()
Value
boolean isPresent()
isPresent
in interface Convertable<T>
<R> Maybe<R> map(java.util.function.Function<? super T,? extends R> mapper)
Transformable
of(1,2,3).map(i->i*2)
//[2,4,6]
map
in interface MonadicValue<T>
map
in interface Transformable<T>
mapper
- Transformation function<R> Maybe<R> flatMap(java.util.function.Function<? super T,? extends MonadicValue<? extends R>> mapper)
MonadicValue
Optional.flatMap(Function)
Eval.now(1).map(i->i+2).flatMap(i->Eval.later(()->i*3);
//Eval[9]
flatMap
in interface MonadicValue<T>
mapper
- transformation function<R> R visit(java.util.function.Function<? super T,? extends R> some, java.util.function.Supplier<? extends R> none)
Visitable
Maybe<T> filter(java.util.function.Predicate<? super T> fn)
Filters
of(1,2,3).filter(i->i>2);
//[3]
default <U> Maybe<U> ofType(java.lang.Class<? extends U> type)
Filters
// (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)
default Maybe<T> filterNot(java.util.function.Predicate<? super T> fn)
Filters
of(1,2,3).filter(i->i>2);
//[1,2]
default Maybe<T> notNull()
Filters
of(1,2,null,4).nonNull();
//[1,2,4]
default <U> Maybe<U> cast(java.lang.Class<? extends U> type)
Transformable
ClassCastException
.
// ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)cast
in interface Transformable<T>
default Maybe<T> peek(java.util.function.Consumer<? super T> c)
Transformable
of(1,2,3).map(System.out::println)
1
2
3
peek
in interface Transformable<T>
c
- Consumer that recieves each element from this Transformabledefault <R> Maybe<R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)
Transformable
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 Transformable<T>
mapper
- TCO Transformation function