public interface AnyMSeq<T> extends AnyM<T>, ConvertableSequence<T>, ExtendedTraversable<T>, Sequential<T>, CyclopsCollectable<T>, IterableCollectable<T>, FilterableFunctor<T>, ZippingApplicativable<T>, org.reactivestreams.Publisher<T>
AnyM.AnyMFactory
Modifier and Type | Method and Description |
---|---|
AnyMSeq<java.util.List<T>> |
aggregate(AnyM<T> next)
Aggregate the contents of this Monad and the supplied Monad
|
default <R> ZippingApplicativable<R> |
ap1(java.util.function.Function<? super T,? extends R> fn) |
default <R> ApplyingZippingApplicativeBuilder<T,R,ZippingApplicativable<R>> |
applicatives() |
<R> AnyMSeq<R> |
applyM(AnyM<java.util.function.Function<? super T,? extends R>> fn)
Apply function/s inside supplied Monad to data in current Monad
e.g.
|
<R> AnyMSeq<R> |
bind(java.util.function.Function<? super T,?> fn)
Perform a looser typed flatMap / bind operation
The return type can be another type other than the host type
Note the modified javaslang monad laws are not applied during the looser typed bind operation
The modification being used to work around the limits of the Java type system.
|
default <U> AnyMSeq<U> |
cast(java.lang.Class<U> type)
Cast all elements in a stream to a given type, possibly throwing a
ClassCastException . |
default <R,A> R |
collect(java.util.stream.Collector<? super T,A,R> collector)
Collect the contents of the monad wrapped by this AnyM into supplied collector
|
default org.jooq.lambda.Collectable<T> |
collectable()
Narrow this class to a Collectable
|
default AnyMSeq<ReactiveSeq<T>> |
combinations()
ReactiveSeq.of(1,2,3).combinations()
//SequenceM[SequenceM[],SequenceM[1],SequenceM[2],SequenceM[3].SequenceM[1,2],SequenceM[1,3],SequenceM[2,3]
,SequenceM[1,2,3]]
|
default AnyMSeq<ReactiveSeq<T>> |
combinations(int size)
ReactiveSeq.of(1,2,3).combinations(2)
//SequenceM[SequenceM[1,2],SequenceM[1,3],SequenceM[2,3]]
|
default AnyMSeq<T> |
combine(java.util.function.BiPredicate<? super T,? super T> predicate,
java.util.function.BinaryOperator<T> op)
Combine two adjacent elements in a traversable using the supplied BinaryOperator
This is a stateful grouping & reduction operation.
|
default AnyMSeq<T> |
cycle(int times)
Convert to a Stream with the values repeated specified times
|
default AnyMSeq<T> |
cycle(Monoid<T> m,
int times)
Convert to a Stream with the result of a reduction operation repeated
specified times
|
default AnyMSeq<T> |
cycleUntil(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream until specified predicate holds
|
default AnyMSeq<T> |
cycleWhile(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream while specified predicate holds
|
default AnyMSeq<T> |
distinct() |
default AnyMSeq<T> |
dropRight(int num) |
default AnyMSeq<T> |
dropUntil(java.util.function.Predicate<? super T> p) |
default AnyMSeq<T> |
dropWhile(java.util.function.Predicate<? super T> p) |
<T> AnyMSeq<T> |
empty()
Construct an AnyM wrapping an empty instance of the wrapped type
e.g.
|
<T> AnyMSeq<T> |
emptyUnit() |
AnyMSeq<T> |
filter(java.util.function.Predicate<? super T> p)
Perform a filter operation on the wrapped monad instance e.g.
|
default AnyMSeq<T> |
filterNot(java.util.function.Predicate<? super T> fn) |
<R> AnyMSeq<R> |
flatMap(java.util.function.Function<? super T,? extends AnyM<? extends R>> fn)
flatMap operation
AnyM follows the javaslang modified 'monad' laws https://gist.github.com/danieldietrich/71be006b355d6fbc0584
In particular left-identity becomes
Left identity: unit(a).flatMap(f) ≡ select(f.apply(a))
Or in plain English, if your flatMap function returns multiple values (such as flatMap by Stream) but the current Monad only can only hold one value,
only the first value is accepted.
|
<T1> AnyMSeq<T1> |
flatten()
join / flatten one level of a nested hierarchy
|
<R1,R> AnyMSeq<R> |
forEach2(java.util.function.Function<? super T,? extends AnyM<R1>> monad,
java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)
Perform a two level nested internal iteration over this Stream and the supplied monad (allowing null handling, exception handling
etc to be injected, for example)
|
<R1,R> AnyMSeq<R> |
forEach2(java.util.function.Function<? super T,? extends AnyM<R1>> monad,
java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Boolean>> filterFunction,
java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)
Perform a two level nested internal iteration over this Stream and the supplied monad (allowing null handling, exception handling
etc to be injected, for example)
|
<R1,R2,R> AnyMSeq<R> |
forEach3(java.util.function.Function<? super T,? extends AnyM<R1>> monad1,
java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends AnyM<R2>>> monad2,
java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)
Perform a three level nested internal iteration over this AnyM and the supplied monads
|
<R1,R2,R> AnyMSeq<R> |
forEach3(java.util.function.Function<? super T,? extends AnyM<R1>> monad1,
java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends AnyM<R2>>> monad2,
java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,java.lang.Boolean>>> filterFunction,
java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)
Perform a three level nested internal iteration over this Stream and the supplied streams
|
default <K> AnyMSeq<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>> |
grouped(java.util.function.Function<? super T,? extends K> classifier) |
default <K,A,D> AnyMSeq<org.jooq.lambda.tuple.Tuple2<K,D>> |
grouped(java.util.function.Function<? super T,? extends K> classifier,
java.util.stream.Collector<? super T,A,D> downstream) |
default AnyMSeq<ListX<T>> |
grouped(int groupSize)
Group elements in a Stream
|
default <C extends java.util.Collection<? super T>> |
grouped(int size,
java.util.function.Supplier<C> supplier)
Batch elements in a Stream by size into a collection created by the
supplied factory
|
default AnyMSeq<ListX<T>> |
groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
Create SequenceM of Streamables (replayable Streams / Sequences) where
each Streamable is populated while the supplied bipredicate holds.
|
default AnyMSeq<ListX<T>> |
groupedUntil(java.util.function.Predicate<? super T> predicate)
Create a SequenceM batched by List, where each batch is populated until
the predicate holds
|
default <C extends java.util.Collection<? super T>> |
groupedUntil(java.util.function.Predicate<? super T> predicate,
java.util.function.Supplier<C> factory)
Create a SequenceM batched by a Collection, where each batch is populated
until the predicate holds
|
default AnyMSeq<ListX<T>> |
groupedWhile(java.util.function.Predicate<? super T> predicate)
Create a SequenceM batched by List, where each batch is populated while
the predicate holds
|
default <C extends java.util.Collection<? super T>> |
groupedWhile(java.util.function.Predicate<? super T> predicate,
java.util.function.Supplier<C> factory)
Create a SequenceM batched by a Collection, where each batch is populated
while the predicate holds
|
default AnyMSeq<T> |
intersperse(T value)
Returns a stream with a given value interspersed between any two values
of this stream.
|
static <U,R> java.util.function.Function<AnyMSeq<U>,AnyMSeq<R>> |
liftM(java.util.function.Function<? super U,? extends R> fn)
Lift a function so it accepts an AnyM and returns an AnyM (any monad)
AnyM view simplifies type related challenges.
|
static <U1,U2,R> java.util.function.BiFunction<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<R>> |
liftM2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)
Lift a function so it accepts a Monad and returns a Monad (simplex view of a wrapped Monad)
AnyM view simplifies type related challenges.
|
static <U1,U2,R> java.util.function.Function<AnyMSeq<U1>,java.util.function.Function<AnyMSeq<U2>,AnyMSeq<R>>> |
liftM2(java.util.function.Function<U1,java.util.function.Function<U2,R>> fn)
Lift a Curried Function into Monadic form
|
static <U1,U2,U3,R> |
liftM3(java.util.function.Function<? super U1,java.util.function.Function<? super U2,java.util.function.Function<? super U3,? extends R>>> fn)
Lift a Curried Function into Monadic form
|
static <U1,U2,U3,R> |
liftM3(org.jooq.lambda.function.Function3<? super U1,? super U2,? super U3,? extends R> fn)
Lift a jOOλ Function3 into Monadic form.
|
static <U1,U2,U3,R> |
liftM3Cyclops(TriFunction<? super U1,? super U2,? super U3,? extends R> fn)
Lift a TriFunction into Monadic form.
|
static <U1,U2,U3,U4,R> |
liftM4(java.util.function.Function<? super U1,java.util.function.Function<? super U2,java.util.function.Function<? super U3,java.util.function.Function<? super U4,? extends R>>>> fn)
Lift a Curried Function into Monadic form
|
static <U1,U2,U3,U4,R> |
liftM4(org.jooq.lambda.function.Function4<? super U1,? super U2,? super U3,? super U4,? extends R> fn)
Lift a jOOλ Function4 into Monadic form.
|
static <U1,U2,U3,U4,R> |
liftM4Cyclops(QuadFunction<? super U1,? super U2,? super U3,? super U4,? extends R> fn)
Lift a QuadFunction into Monadic form.
|
static <U1,U2,U3,U4,U5,R> |
liftM5(java.util.function.Function<? super U1,java.util.function.Function<? super U2,java.util.function.Function<? super U3,java.util.function.Function<? super U4,java.util.function.Function<? super U5,? extends R>>>>> fn)
Lift a Curried Function
(5 levels a->b->c->d->e->fn.apply(a,b,c,d,e) ) into Monadic form |
static <U1,U2,U3,U4,U5,R> |
liftM5(org.jooq.lambda.function.Function5<? super U1,? super U2,? super U3,? super U4,? super U5,? extends R> fn)
Lift a jOOλ Function5 (5 parameters) into Monadic form
|
static <U1,U2,U3,U4,U5,R> |
liftM5Cyclops(QuintFunction<? super U1,? super U2,? super U3,? super U4,? super U5,? extends R> fn)
Lift a QuintFunction (5 parameters) into Monadic form
|
<R> AnyMSeq<R> |
map(java.util.function.Function<? super T,? extends R> fn)
Perform a map operation on the wrapped monad instance e.g.
|
default <U> AnyMSeq<U> |
ofType(java.lang.Class<U> type)
Keep only those elements in a stream that are of a given type.
|
default <R> AnyMSeq<R> |
patternMatch(java.util.function.Function<Matchable.CheckValues<T,R>,Matchable.CheckValues<T,R>> case1,
java.util.function.Supplier<? extends R> otherwise)
Transform the elements of this Stream with a Pattern Matching case and default value
|
default AnyMSeq<T> |
peek(java.util.function.Consumer<? super T> c)
Perform a peek operation on the wrapped monad e.g.
|
default AnyMSeq<ReactiveSeq<T>> |
permutations()
Generate the permutations based on values in the SequenceM Makes use of
Streamable to store intermediate stages in a collection
|
AnyMSeq<T> |
replicateM(int times) |
default AnyMSeq<T> |
reverse() |
default AnyMSeq<T> |
scanLeft(Monoid<T> monoid)
Scan left using supplied Monoid
|
default <U> AnyMSeq<U> |
scanLeft(U seed,
java.util.function.BiFunction<U,? super T,U> function)
Scan left
|
default AnyMSeq<T> |
scanRight(Monoid<T> monoid)
Scan right
|
default <U> AnyMSeq<U> |
scanRight(U identity,
java.util.function.BiFunction<? super T,U,U> combiner)
Scan right
|
static <T1> AnyMSeq<ListX<T1>> |
sequence(java.util.Collection<? extends AnyMSeq<T1>> seq)
Convert a Collection of Monads to a Monad with a List
|
static <T1> AnyMSeq<ListX<T1>> |
sequence(java.util.stream.Stream<? extends AnyMSeq<T1>> seq)
Convert a Stream of Monads to a Monad with a List
|
default AnyMSeq<T> |
shuffle() |
default AnyMSeq<T> |
shuffle(java.util.Random random) |
default AnyMSeq<T> |
skip(long num)
assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); |
default AnyMSeq<T> |
skipLast(int num)
assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2)
.collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
|
default AnyMSeq<T> |
skipUntil(java.util.function.Predicate<? super T> p)
Drop elements from the Stream until the predicate returns true, after
which all elements are included
|
default AnyMSeq<T> |
skipWhile(java.util.function.Predicate<? super T> p)
SkipWhile drops elements from the Stream while the predicate holds, once
the predicte returns true all subsequent elements are included *
|
default AnyMSeq<T> |
slice(long from,
long to) |
default AnyMSeq<ListX<T>> |
sliding(int windowSize)
Create a sliding view over this Sequence
|
default AnyMSeq<ListX<T>> |
sliding(int windowSize,
int increment)
Create a sliding view over this Sequence
|
default AnyMSeq<T> |
sorted()
assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); |
default AnyMSeq<T> |
sorted(java.util.Comparator<? super T> c)
assertThat(ReactiveSeq.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));
|
default <U extends java.lang.Comparable<? super U>> |
sorted(java.util.function.Function<? super T,? extends U> function) |
ReactiveSeq<T> |
stream() |
default void |
subscribe(org.reactivestreams.Subscriber<? super T> sub) |
default AnyMSeq<T> |
takeRight(int num) |
default AnyMSeq<T> |
takeUntil(java.util.function.Predicate<? super T> p) |
default AnyMSeq<T> |
takeWhile(java.util.function.Predicate<? super T> p) |
default Value<T> |
toFirstValue() |
default Xor<?,ListX<T>> |
toXor() |
default Xor<ListX<T>,?> |
toXorSecondary() |
default <R> AnyMSeq<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
|
static <T,R> AnyMSeq<ListX<R>> |
traverse(java.util.Collection<? extends AnyMSeq<T>> seq,
java.util.function.Function<? super T,? extends R> fn)
Convert a Stream of Monads to a Monad with a List applying the supplied function in the process
|
<T> AnyMSeq<T> |
unit(T value)
Construct a new instanceof AnyM using the type of the underlying wrapped monad
|
<R> R |
unwrap() |
default <U,R> AnyMSeq<R> |
zip(java.lang.Iterable<U> other,
java.util.function.BiFunction<? super T,? super U,? extends R> zipper) |
default <U> AnyMSeq<org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(org.jooq.lambda.Seq<U> other)
Zip 2 streams into one
|
default <S,U> AnyMSeq<org.jooq.lambda.tuple.Tuple3<T,S,U>> |
zip3(java.util.stream.Stream<? extends S> second,
java.util.stream.Stream<? extends U> third)
zip 3 Streams into one
|
default <T2,T3,T4> AnyMSeq<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> |
zip4(java.util.stream.Stream<T2> second,
java.util.stream.Stream<T3> third,
java.util.stream.Stream<T4> fourth)
zip 4 Streams into 1
|
default <U> AnyMSeq<org.jooq.lambda.tuple.Tuple2<T,U>> |
zipStream(java.util.stream.Stream<U> other)
Zip 2 streams into one
|
default AnyMSeq<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> |
zipWithIndex()
Add an index to the current Stream
|
fromArray, fromCollection, fromCompletableFuture, fromDoubleStream, fromEval, fromFeatureToggle, fromFile, fromFutureW, fromIntStream, fromIor, fromIterable, fromList, fromLongStream, fromMaybe, fromOptional, fromOptionalDouble, fromOptionalInt, fromOptionalLong, fromRange, fromRangeLong, fromSet, fromStream, fromStreamable, fromTry, fromURL, fromXor, listFromCollection, listFromCompletableFuture, listFromEval, listFromFutureW, listFromIor, listFromIterable, listFromIterator, listFromMaybe, listFromOptional, listFromStream, listFromStreamable, listFromXor, matchable, ofConvertableSeq, ofConvertableValue, ofNullable, ofSeq, ofValue, reduceMSeq, reduceMValue, sequence, sequence, streamOf, toSequence, toString, traverse, traverse
getStreamable, isEmpty, iterator, jdkStream, reactiveSeq, reveresedJDKStream, reveresedStream
fixedDelay, onePer, xPer
allMatch, anyMatch, avg, avg, avgDouble, avgInt, avgLong, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, max, max, max, max, maxBy, maxBy, median, median, medianBy, medianBy, min, min, min, min, minBy, minBy, mode, noneMatch, percentile, percentile, percentileBy, percentileBy, sum, sum, sumDouble, sumInt, sumLong, toCollection, toList, toList, toMap, toSet, toSet, toString, toString
collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect
xMatch
notNull
ap2, ap3, ap4, ap5
flatMapPublisher, flatMapPublisher, flatMapPublisher, mergePublisher, mergePublisher, unitIterator
endsWith, endsWithIterable, findAny, findFirst, firstValue, futureOperations, get, groupBy, headAndTail, join, join, join, lazyOperations, limit, limitLast, limitUntil, limitWhile, onEmpty, onEmptyGet, onEmptyThrow, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleOptional, startsWith, startsWithIterable, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, validate, visit, visit
default <R,A> R collect(java.util.stream.Collector<? super T,A,R> collector)
AnyM
default <R> ApplyingZippingApplicativeBuilder<T,R,ZippingApplicativable<R>> applicatives()
applicatives
in interface ZippingApplicativable<T>
default <R> ZippingApplicativable<R> ap1(java.util.function.Function<? super T,? extends R> fn)
ap1
in interface ZippingApplicativable<T>
default void subscribe(org.reactivestreams.Subscriber<? super T> sub)
subscribe
in interface org.reactivestreams.Publisher<T>
subscribe
in interface Traversable<T>
default org.jooq.lambda.Collectable<T> collectable()
CyclopsCollectable
collectable
in interface CyclopsCollectable<T>
collectable
in interface IterableFunctor<T>
default Xor<ListX<T>,?> toXorSecondary()
toXorSecondary
in interface ConvertableSequence<T>
default <U> AnyMSeq<U> cast(java.lang.Class<U> type)
Functor
ClassCastException
.
// ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)default <R> AnyMSeq<R> trampoline(java.util.function.Function<? super T,? 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<T>
default <R> AnyMSeq<R> patternMatch(java.util.function.Function<Matchable.CheckValues<T,R>,Matchable.CheckValues<T,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<T>
case1
- Function to generate a case (or chain of cases as a single case)otherwise
- Value if supplied case doesn't matchdefault AnyMSeq<T> cycle(int times)
Traversable
ReactiveSeq.of(1,2,2)
.cycle(3)
.collect(Collectors.toList());
//List[1,2,2,1,2,2,1,2,2]
cycle
in interface Traversable<T>
times
- Times values should be repeated within a Streamdefault AnyMSeq<T> cycle(Monoid<T> m, int times)
Traversable
List<Integer> list = ReactiveSeq.of(1,2,2))
.cycle(Reducers.toCountInt(),3)
.collect(Collectors.toList());
//List[3,3,3];
cycle
in interface Traversable<T>
m
- Monoid to be used in reductiontimes
- Number of times value should be repeateddefault AnyMSeq<T> cycleWhile(java.util.function.Predicate<? super T> predicate)
Traversable
{ @code MutableInt count = MutableInt.of(0); ReactiveSeq.of(1, 2, 2).cycleWhile(next -> count++ < 6).collect(Collectors.toList()); // List(1,2,2,1,2,2) }
cycleWhile
in interface Traversable<T>
predicate
- repeat while truedefault AnyMSeq<T> cycleUntil(java.util.function.Predicate<? super T> predicate)
Traversable
MutableInt count =MutableInt.of(0);
ReactiveSeq.of(1,2,2)
.cycleUntil(next -> count.get()>6)
.peek(i-> count.mutate(i->i+1))
.collect(Collectors.toList());
//List[1,2,2,1,2,2,1]
cycleUntil
in interface Traversable<T>
predicate
- repeat while truedefault <U,R> AnyMSeq<R> zip(java.lang.Iterable<U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
zip
in interface Traversable<T>
default <U> AnyMSeq<org.jooq.lambda.tuple.Tuple2<T,U>> zipStream(java.util.stream.Stream<U> other)
Traversable
{ @code List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList(); // [[1,"a"],[2,"b"]] }
zipStream
in interface Traversable<T>
default <U> AnyMSeq<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<U> other)
Traversable
{ @code List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList(); // [[1,"a"],[2,"b"]] }
zip
in interface Traversable<T>
default <S,U> AnyMSeq<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.util.stream.Stream<? extends S> second, java.util.stream.Stream<? extends U> third)
Traversable
{ @code 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']] }
zip3
in interface Traversable<T>
default <T2,T3,T4> AnyMSeq<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.util.stream.Stream<T2> second, java.util.stream.Stream<T3> third, java.util.stream.Stream<T4> fourth)
Traversable
{ @code 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"]]
zip4
in interface Traversable<T>
default AnyMSeq<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()
Traversable
assertEquals(asList(new Tuple2("a", 0L), new Tuple2("b", 1L)), of("a", "b").zipWithIndex().toList());
zipWithIndex
in interface Traversable<T>
default AnyMSeq<ListX<T>> sliding(int windowSize)
Traversable
{ @code List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(2).collect(Collectors.toList()); assertThat(list.get(0), hasItems(1, 2)); assertThat(list.get(1), hasItems(2, 3)); }
sliding
in interface Traversable<T>
windowSize
- Size of sliding windowdefault AnyMSeq<ListX<T>> sliding(int windowSize, int increment)
Traversable
{ @code List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(3, 2).collect(Collectors.toList()); assertThat(list.get(0), hasItems(1, 2, 3)); assertThat(list.get(1), hasItems(3, 4, 5)); }
sliding
in interface Traversable<T>
windowSize
- number of elements in each batchincrement
- for each windowdefault <C extends java.util.Collection<? super T>> AnyMSeq<C> grouped(int size, java.util.function.Supplier<C> supplier)
Traversable
assertThat(ReactiveSeq.of(1,1,1,1,1,1)
.batchBySize(3,()->new TreeSet<>())
.toList()
.get(0)
.size(),is(1));
grouped
in interface Traversable<T>
size
- batch sizesupplier
- Collection factorydefault AnyMSeq<ListX<T>> groupedUntil(java.util.function.Predicate<? super T> predicate)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5,6)
.batchUntil(i->i%3==0)
.toList()
.size(),equalTo(2));
groupedUntil
in interface Traversable<T>
predicate
- Batch until predicate holds, then open next batchdefault AnyMSeq<ListX<T>> groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5,6)
.windowStatefullyWhile((s,i)->s.sequenceM().toList().contains(4) ? true : false)
.toList().size(),equalTo(5));
groupedStatefullyWhile
in interface Traversable<T>
predicate
- Window while truedefault AnyMSeq<T> combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)
Traversable
ReactiveSeq.of(1,1,2,3)
.combine((a, b)->a.equals(b),Semigroups.intSum)
.toListX()
//ListX(3,4)
combine
in interface Traversable<T>
predicate
- Test to see if two neighbours should be joinedop
- Reducer to combine neighboursdefault AnyMSeq<ListX<T>> groupedWhile(java.util.function.Predicate<? super T> predicate)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5,6)
.batchWhile(i->i%3!=0)
.toList().size(),equalTo(2));
groupedWhile
in interface Traversable<T>
predicate
- Batch while predicate holds, then open next batchdefault <C extends java.util.Collection<? super T>> AnyMSeq<C> groupedWhile(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5,6)
.batchWhile(i->i%3!=0)
.toList()
.size(),equalTo(2));
groupedWhile
in interface Traversable<T>
predicate
- Batch while predicate holds, then open next batchfactory
- Collection factorydefault <C extends java.util.Collection<? super T>> AnyMSeq<C> groupedUntil(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5,6)
.batchUntil(i->i%3!=0)
.toList()
.size(),equalTo(2));
groupedUntil
in interface Traversable<T>
predicate
- Batch until predicate holds, then open next batchfactory
- Collection factorydefault AnyMSeq<ListX<T>> grouped(int groupSize)
Traversable
{ @code List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).grouped(3).collect(Collectors.toList()); assertThat(list.get(0), hasItems(1, 2, 3)); assertThat(list.get(1), hasItems(4, 5, 6)); }
grouped
in interface Traversable<T>
groupSize
- Size of each Groupdefault <K,A,D> AnyMSeq<org.jooq.lambda.tuple.Tuple2<K,D>> grouped(java.util.function.Function<? super T,? extends K> classifier, java.util.stream.Collector<? super T,A,D> downstream)
grouped
in interface Traversable<T>
default <K> AnyMSeq<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)
grouped
in interface Traversable<T>
default AnyMSeq<T> takeWhile(java.util.function.Predicate<? super T> p)
takeWhile
in interface Traversable<T>
default AnyMSeq<T> dropWhile(java.util.function.Predicate<? super T> p)
dropWhile
in interface Traversable<T>
default AnyMSeq<T> takeUntil(java.util.function.Predicate<? super T> p)
takeUntil
in interface Traversable<T>
default AnyMSeq<T> dropUntil(java.util.function.Predicate<? super T> p)
dropUntil
in interface Traversable<T>
default AnyMSeq<T> dropRight(int num)
dropRight
in interface Traversable<T>
default AnyMSeq<T> takeRight(int num)
takeRight
in interface Traversable<T>
default AnyMSeq<T> reverse()
reverse
in interface Traversable<T>
default AnyMSeq<T> shuffle()
shuffle
in interface Traversable<T>
default AnyMSeq<T> shuffle(java.util.Random random)
shuffle
in interface Traversable<T>
default AnyMSeq<T> distinct()
distinct
in interface Traversable<T>
default AnyMSeq<T> scanLeft(Monoid<T> monoid)
Traversable
assertEquals(asList("", "a", "ab", "abc"),ReactiveSeq.of("a", "b", "c")
.scanLeft(Reducers.toString("")).toList());
scanLeft
in interface Traversable<T>
default <U> AnyMSeq<U> scanLeft(U seed, java.util.function.BiFunction<U,? super T,U> function)
Traversable
assertThat(of("a", "b", "c").scanLeft("", String::concat).toList().size(),
is(4));
scanLeft
in interface Traversable<T>
default AnyMSeq<T> scanRight(Monoid<T> monoid)
Traversable
assertThat(of("a", "b", "c").scanRight(Monoid.of("", String::concat)).toList().size(),
is(asList("", "c", "bc", "abc").size()));
scanRight
in interface Traversable<T>
default <U> AnyMSeq<U> scanRight(U identity, java.util.function.BiFunction<? super T,U,U> combiner)
Traversable
assertThat(of("a", "ab", "abc").map(str->str.length()).scanRight(0, (t, u) -> u + t).toList().size(),
is(asList(0, 3, 5, 6).size()));
scanRight
in interface Traversable<T>
default AnyMSeq<T> sorted()
Traversable
assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));
sorted
in interface Traversable<T>
default AnyMSeq<T> sorted(java.util.Comparator<? super T> c)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));
sorted
in interface Traversable<T>
c
- Compartor to sort withdefault AnyMSeq<T> skip(long num)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));
skip
in interface Traversable<T>
num
- Number of elemenets to skipdefault AnyMSeq<T> skipWhile(java.util.function.Predicate<? super T> p)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));
skipWhile
in interface Traversable<T>
p
- Predicate to skip while truedefault AnyMSeq<T> skipUntil(java.util.function.Predicate<? super T> p)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));
skipUntil
in interface Traversable<T>
p
- Predicate to skip until truedefault AnyMSeq<T> intersperse(T value)
Traversable
intersperse
in interface Traversable<T>
default AnyMSeq<T> skipLast(int num)
Traversable
skipLast
in interface Traversable<T>
default AnyMSeq<T> slice(long from, long to)
slice
in interface Traversable<T>
default <U extends java.lang.Comparable<? super U>> AnyMSeq<T> sorted(java.util.function.Function<? super T,? extends U> function)
sorted
in interface Traversable<T>
default AnyMSeq<ReactiveSeq<T>> permutations()
ExtendedTraversable
permutations
in interface ExtendedTraversable<T>
default AnyMSeq<ReactiveSeq<T>> combinations(int size)
ExtendedTraversable
ReactiveSeq.of(1,2,3).combinations(2)
//SequenceM[SequenceM[1,2],SequenceM[1,3],SequenceM[2,3]]
combinations
in interface ExtendedTraversable<T>
size
- of combinationsdefault AnyMSeq<ReactiveSeq<T>> combinations()
ExtendedTraversable
ReactiveSeq.of(1,2,3).combinations()
//SequenceM[SequenceM[],SequenceM[1],SequenceM[2],SequenceM[3].SequenceM[1,2],SequenceM[1,3],SequenceM[2,3]
,SequenceM[1,2,3]]
combinations
in interface ExtendedTraversable<T>
default <U> AnyMSeq<U> ofType(java.lang.Class<U> type)
Filterable
ofType
in interface Filterable<T>
default AnyMSeq<T> filterNot(java.util.function.Predicate<? super T> fn)
filterNot
in interface Filterable<T>
ReactiveSeq<T> stream()
stream
in interface AnyM<T>
stream
in interface ConvertableSequence<T>
stream
in interface Foldable<T>
stream
in interface IterableCollectable<T>
stream
in interface IterableFunctor<T>
stream
in interface ToStream<T>
stream
in interface Traversable<T>
<R> R unwrap()
unwrap
in interface AnyM<T>
unwrap
in interface Unwrapable
AnyMSeq<T> filter(java.util.function.Predicate<? super T> p)
AnyM
AnyM.fromOptional(Optional.of(10)).filter(i->i<10);
//AnyM[Optional.empty()]
AnyM.fromStream(Stream.of(5,10)).filter(i->i<10);
//AnyM[Stream[5]]
filter
in interface AnyM<T>
filter
in interface Filterable<T>
filter
in interface FilterableFunctor<T>
p
- Filtering predicate<R> AnyMSeq<R> map(java.util.function.Function<? super T,? extends R> fn)
AnyM
AnyM.fromIterable(Try.runWithCatch(this::loadData))
.map(data->transform(data))
AnyM.fromStream(Stream.of(1,2,3))
.map(i->i+2);
AnyM[Stream[3,4,5]]
default AnyMSeq<T> peek(java.util.function.Consumer<? super T> c)
AnyM
AnyM.fromCompletableFuture(CompletableFuture.supplyAsync(()->loadData())
.peek(System.out::println)
<T1> AnyMSeq<T1> flatten()
AnyM
AnyMSeq<java.util.List<T>> aggregate(AnyM<T> next)
AnyM
AnyM.fromStream(Stream.of(1,2,3,4))
.aggregate(anyM(Optional.of(5)))
AnyM[Stream[List[1,2,3,4,5]]
List<Integer> result = AnyM.fromStream(Stream.of(1,2,3,4))
.aggregate(anyM(Optional.of(5)))
.toSequence()
.flatten()
.toList();
assertThat(result,equalTo(Arrays.asList(1,2,3,4,5)));
<R1,R> AnyMSeq<R> forEach2(java.util.function.Function<? super T,? extends AnyM<R1>> monad, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)
AnyM.fromArray(1,2,3)
.forEachAnyM2(a->AnyM.fromIntStream(IntStream.range(10,13)),
a->b->a+b);
//AnyM[11,14,12,15,13,16]
monad
- Nested Monad to iterate overyieldingFunction
- Function with pointers to the current element from both Streams that generates the new elements<R1,R> AnyMSeq<R> forEach2(java.util.function.Function<? super T,? extends AnyM<R1>> monad, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Boolean>> filterFunction, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)
AnyM.fromArray(1,2,3)
.forEach2(a->AnyM.fromIntStream(IntStream.range(10,13)),
a->b-> a<3 && b>10,
a->b->a+b);
//AnyM[14,15]
monad
- Nested Monad 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 monads that generates the new elements<R1,R2,R> AnyMSeq<R> forEach3(java.util.function.Function<? super T,? extends AnyM<R1>> monad1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends AnyM<R2>>> monad2, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,java.lang.Boolean>>> filterFunction, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)
AnyM.fromArray(1,2)
.forEach2(a->AnyM.fromIntStream(IntStream.range(10,13)),
(a->b->AnyM.fromArray(""+(a+b),"hello world"),
a->b->c->c+":"a+":"+b);
//AnyM[11:1:2,hello world:1:2,14:1:4,hello world:1:4,12:1:2,hello world:1:2,15:1:5,hello world:1:5]
monad1
- Nested monad to flatMap overstream2
- Nested monad to flatMap overyieldingFunction
- Function with pointers to the current element from both monads that generates the new elements<R1,R2,R> AnyMSeq<R> forEach3(java.util.function.Function<? super T,? extends AnyM<R1>> monad1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends AnyM<R2>>> monad2, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)
AnyM.fromArray(1,2,3)
.forEach3(a->AnyM.fromStream(IntStream.range(10,13)),
a->b->AnyM.fromArray(""+(a+b),"hello world"),
a->b->c-> c!=3,
a->b->c->c+":"a+":"+b);
//SequenceM[11:1:2,hello world:1:2,14:1:4,hello world:1:4,12:1:2,hello world:1:2,15:1:5,hello world:1:5]
monad1
- Nested Stream to iterate overmonad2
- Nested Stream 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 Monads that generates the new elements<R> AnyMSeq<R> flatMap(java.util.function.Function<? super T,? extends AnyM<? extends R>> fn)
AnyM<Integer> anyM = AnyM.fromStream(Stream.of(1,2,3)).flatMap(i->AnyM.fromArray(i+1,i+2));
//AnyM[Stream[2,3,3,4,4,5]]
Example 2 : multi-values are not supported (AnyM wraps a Stream, List, Set etc)
AnyM<Integer> anyM = AnyM.fromOptional(Optional.of(1)).flatMap(i->AnyM.fromArray(i+1,i+2));
//AnyM[Optional[2]]
fn
- flatMap function<R> AnyMSeq<R> applyM(AnyM<java.util.function.Function<? super T,? extends R>> fn)
AnyM<Integer> applied =AnyM.fromStream(Stream.of(1,2,3))
.applyM(AnyM.fromStreamable(Streamable.of( (Integer a)->a+1 ,(Integer a) -> a*2)));
assertThat(applied.toList(),equalTo(Arrays.asList(2, 2, 3, 4, 4, 6)));
with Optionals
Any<Integer> applied =AnyM.fromOptional(Optional.of(2)).applyM(AnyM.fromOptional(Optional.of( (Integer a)->a+1)) );
assertThat(applied.toList(),equalTo(Arrays.asList(3)));
fn
- <T> AnyMSeq<T> unit(T value)
AnyM
AnyM<Integer> ints = AnyM.fromList(Arrays.asList(1,2,3);
AnyM<String> string = ints.unit("hello");
<T> AnyMSeq<T> empty()
AnyM
Any<Integer> ints = AnyM.fromStream(Stream.of(1,2,3));
AnyM<Integer> empty=ints.empty();
<R> AnyMSeq<R> bind(java.util.function.Function<? super T,?> fn)
AnyM
AnyM<List<Integer>> m = AnyM.fromStream(Stream.of(Arrays.asList(1,2,3),Arrays.asList(1,2,3)));
AnyM<Integer> intM = m.bind(Collection::stream);
static <T,R> AnyMSeq<ListX<R>> traverse(java.util.Collection<? extends AnyMSeq<T>> seq, java.util.function.Function<? super T,? extends R> fn)
Stream<CompletableFuture<Integer>> futures = createFutures();
AnyMSeq<List<String>> futureList = AnyMonads.traverse(AsAnyMList.anyMList(futures), (Integer i) -> "hello" +i);
seq
- Stream of Monadsfn
- Function to applystatic <T1> AnyMSeq<ListX<T1>> sequence(java.util.Collection<? extends AnyMSeq<T1>> seq)
List<CompletableFuture<Integer>> futures = createFutures();
AnyMSeq<List<Integer>> futureList = AnyMonads.sequence(AsAnyMList.anyMList(futures));
//where AnyM wraps CompletableFuture<List<Integer>>
seq
- Collection of monads to convertfor helper methods to convert a List of Monads / Collections to List of AnyM
static <T1> AnyMSeq<ListX<T1>> sequence(java.util.stream.Stream<? extends AnyMSeq<T1>> seq)
Stream<CompletableFuture<Integer>> futures = createFutures();
AnyMSeq<List<Integer>> futureList = AnyMonads.sequence(AsAnyMList.anyMList(futures));
//where AnyM wraps CompletableFuture<List<Integer>>
seq
- Stream of monads to convertfor helper methods to convert a List of Monads / Collections to List of AnyM
static <U,R> java.util.function.Function<AnyMSeq<U>,AnyMSeq<R>> liftM(java.util.function.Function<? super U,? extends R> fn)
static <U1,U2,R> java.util.function.BiFunction<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<R>> liftM2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)
BiFunction<AnyMSeq<Integer>,AnyMSeq<Integer>,AnyMSeq<Integer>> add = Monads.liftM2(this::add);
Optional<Integer> result = add.apply(getBase(),getIncrease());
private Integer add(Integer a, Integer b){
return a+b;
}
The add method has no null handling, but we can lift the method to Monadic form, and use Optionals to automatically handle null / empty value cases.static <U1,U2,U3,R> org.jooq.lambda.function.Function3<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<U3>,AnyMSeq<R>> liftM3(org.jooq.lambda.function.Function3<? super U1,? super U2,? super U3,? extends R> fn)
Function3 <AnyMSeq<Double>,AnyMSeq<Entity>,AnyMSeq<String>,AnyMSeq<Integer>> fn = liftM3(this::myMethod);
Now we can execute the Method with Streams, Optional, Futures, Try's etc to transparently inject iteration, null handling, async execution and / or error handlingstatic <U1,U2,U3,R> TriFunction<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<U3>,AnyMSeq<R>> liftM3Cyclops(TriFunction<? super U1,? super U2,? super U3,? extends R> fn)
TriFunction<AnyMSeq<Double>,AnyMSeq<Entity>,AnyMSeq<String>,AnyMSeq<Integer>> fn = liftM3(this::myMethod);
Now we can execute the Method with Streams, Optional, Futures, Try's etc to transparently inject iteration, null handling, async execution and / or error handlingliftM3Cyclops
in interface AnyM<T>
fn
- Function to liftstatic <U1,U2,U3,U4,R> org.jooq.lambda.function.Function4<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<U3>,AnyMSeq<U4>,AnyMSeq<R>> liftM4(org.jooq.lambda.function.Function4<? super U1,? super U2,? super U3,? super U4,? extends R> fn)
static <U1,U2,U3,U4,R> QuadFunction<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<U3>,AnyMSeq<U4>,AnyMSeq<R>> liftM4Cyclops(QuadFunction<? super U1,? super U2,? super U3,? super U4,? extends R> fn)
liftM4Cyclops
in interface AnyM<T>
fn
- Quad funciton to liftstatic <U1,U2,U3,U4,U5,R> org.jooq.lambda.function.Function5<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<U3>,AnyMSeq<U4>,AnyMSeq<U5>,AnyMSeq<R>> liftM5(org.jooq.lambda.function.Function5<? super U1,? super U2,? super U3,? super U4,? super U5,? extends R> fn)
static <U1,U2,U3,U4,U5,R> QuintFunction<AnyMSeq<U1>,AnyMSeq<U2>,AnyMSeq<U3>,AnyMSeq<U4>,AnyMSeq<U5>,AnyMSeq<R>> liftM5Cyclops(QuintFunction<? super U1,? super U2,? super U3,? super U4,? super U5,? extends R> fn)
liftM5Cyclops
in interface AnyM<T>
fn
- Function to liftstatic <U1,U2,R> java.util.function.Function<AnyMSeq<U1>,java.util.function.Function<AnyMSeq<U2>,AnyMSeq<R>>> liftM2(java.util.function.Function<U1,java.util.function.Function<U2,R>> fn)
static <U1,U2,U3,R> java.util.function.Function<AnyMSeq<U1>,java.util.function.Function<AnyMSeq<U2>,java.util.function.Function<AnyMSeq<U3>,AnyMSeq<R>>>> liftM3(java.util.function.Function<? super U1,java.util.function.Function<? super U2,java.util.function.Function<? super U3,? extends R>>> fn)
static <U1,U2,U3,U4,R> java.util.function.Function<AnyMSeq<U1>,java.util.function.Function<AnyMSeq<U2>,java.util.function.Function<AnyMSeq<U3>,java.util.function.Function<AnyMSeq<U4>,AnyMSeq<R>>>>> liftM4(java.util.function.Function<? super U1,java.util.function.Function<? super U2,java.util.function.Function<? super U3,java.util.function.Function<? super U4,? extends R>>>> fn)
static <U1,U2,U3,U4,U5,R> java.util.function.Function<AnyMSeq<U1>,java.util.function.Function<AnyMSeq<U2>,java.util.function.Function<AnyMSeq<U3>,java.util.function.Function<AnyMSeq<U4>,java.util.function.Function<AnyMSeq<U5>,AnyMSeq<R>>>>>> liftM5(java.util.function.Function<? super U1,java.util.function.Function<? super U2,java.util.function.Function<? super U3,java.util.function.Function<? super U4,java.util.function.Function<? super U5,? extends R>>>>> fn)
(5 levels a->b->c->d->e->fn.apply(a,b,c,d,e) )
into Monadic form