T
- The type contained on the Xor withinpublic class XorTSeq<ST,T> extends java.lang.Object implements XorT<ST,T>, ValueTransformerSeq<T>, IterableFoldable<T>, ConvertableSequence<T>, CyclopsCollectable<T>, Sequential<T>
Modifier and Type | Method and Description |
---|---|
org.jooq.lambda.Collectable<T> |
collectable()
Narrow this class to a Collectable
|
XorTSeq<ST,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 and reduction operation.
|
XorTSeq<ST,T> |
cycle(int times)
Convert to a Stream with the values repeated specified times
|
XorTSeq<ST,T> |
cycle(Monoid<T> m,
int times)
Convert to a Stream with the result of a reduction operation repeated
specified times
|
XorTSeq<ST,T> |
cycleUntil(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream until specified predicate holds
|
XorTSeq<ST,T> |
cycleWhile(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream while specified predicate holds
|
XorTSeq<ST,T> |
distinct() |
XorTSeq<ST,T> |
dropRight(int num)
Generate a new Traversable that drops the specified number elements from the end of this Traversable
|
XorTSeq<ST,T> |
dropUntil(java.util.function.Predicate<? super T> p)
Generate a new Traversable that drops elements from this Traversable until the predicate holds
|
XorTSeq<ST,T> |
dropWhile(java.util.function.Predicate<? super T> p)
Generate a new Traversable that drops elements from this Traversable as long as the predicate holds
|
<R> XorTSeq<ST,R> |
empty() |
static <ST,T> XorTSeq<ST,T> |
emptyList() |
boolean |
equals(java.lang.Object o) |
XorTSeq<ST,T> |
filter(java.util.function.Predicate<? super T> test)
Filter the wrapped Xor
|
<B> XorTSeq<ST,B> |
flatMap(java.util.function.Function<? super T,? extends MonadicValue<? extends B>> f) |
<ST2,B> XorTSeq<ST,B> |
flatMapT(java.util.function.Function<? super T,XorTSeq<ST2,? extends B>> f)
Flat Map the wrapped Xor
|
static <ST,A> XorTSeq<ST,A> |
fromAnyM(AnyMSeq<A> anyM)
|
<K> XorTSeq<ST,org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>> |
grouped(java.util.function.Function<? super T,? extends K> classifier)
Group this Traversable by the provided classifying function and collected by the provided Collector
|
<K,A,D> XorTSeq<ST,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)
Group this Traversable by the provided classifying function and collected by the provided Collector
|
XorTSeq<ST,ListX<T>> |
grouped(int groupSize)
Group elements in a Stream
|
<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
|
XorTSeq<ST,ListX<T>> |
groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
Create Travesable of Lists where
each List is populated while the supplied bipredicate holds.
|
XorTSeq<ST,ListX<T>> |
groupedUntil(java.util.function.Predicate<? super T> predicate)
Create a Traversable batched by List, where each batch is populated until
the predicate holds
|
<C extends java.util.Collection<? super T>> |
groupedUntil(java.util.function.Predicate<? super T> predicate,
java.util.function.Supplier<C> factory)
Create a ReactiveSeq batched by a Collection, where each batch is populated
until the predicate holds
|
XorTSeq<ST,ListX<T>> |
groupedWhile(java.util.function.Predicate<? super T> predicate)
Create a Traversable batched by List, where each batch is populated while
the predicate holds
|
<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
|
int |
hashCode() |
XorTSeq<ST,T> |
intersperse(T value)
Returns a stream with a given value interspersed between any two values
of this stream.
|
boolean |
isPrimary() |
boolean |
isSecondary() |
boolean |
isSeqPresent() |
java.util.Iterator<T> |
iterator() |
static <ST,U,R> java.util.function.Function<XorTSeq<ST,U>,XorTSeq<ST,R>> |
lift(java.util.function.Function<? super U,? extends R> fn)
Lift a function into one that accepts and returns an XorT This allows
multiple monad types to add functionality to existing functions and
methods
e.g.
|
static <ST,U1,U2,R> |
lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)
Lift a BiFunction into one that accepts and returns XorTs This allows
multiple monad types to add functionality to existing functions and
methods
e.g.
|
XorTSeq<ST,T> |
limit(long num)
assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3)); |
XorTSeq<ST,T> |
limitLast(int num)
Limit results to the last x elements in a SequenceM
|
XorTSeq<ST,T> |
limitUntil(java.util.function.Predicate<? super T> p)
Take elements from the Stream until the predicate returns true, after
which all elements are excluded.
|
XorTSeq<ST,T> |
limitWhile(java.util.function.Predicate<? super T> p)
Take elements from the Stream while the predicate holds, once the
predicate returns false all subsequent elements are excluded
|
<B> XorTSeq<ST,B> |
map(java.util.function.Function<? super T,? extends B> f)
Map the wrapped Xor
|
static <ST,A> XorTSeq<ST,A> |
of(AnyMSeq<Xor<ST,A>> monads)
Construct an XorT from an AnyM that wraps a monad containing Xors
|
static <ST,A> XorTSeq<ST,A> |
of(Xor<ST,A> monads) |
XorTSeq<ST,T> |
onEmpty(T value)
If this Container instance is empty, create a new instance containing the provided value
|
XorTSeq<ST,T> |
onEmptyGet(java.util.function.Supplier<? extends T> supplier)
If this Container instance is empty, create a new instance containing the value returned from the provided Supplier
|
<X extends java.lang.Throwable> |
onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
If this container instance is empty, throw the exception returned by the provided Supplier
|
XorTSeq<ST,T> |
peek(java.util.function.Consumer<? super T> peek)
Peek at the current value of the Xor
|
XorTSeq<ST,T> |
reverse()
Potentially efficient Stream reversal.
|
XorTSeq<ST,T> |
scanLeft(Monoid<T> monoid)
Scan left using supplied Monoid
|
<U> XorTSeq<ST,U> |
scanLeft(U seed,
java.util.function.BiFunction<? super U,? super T,? extends U> function)
Scan left
|
XorTSeq<ST,T> |
scanRight(Monoid<T> monoid)
Scan right
|
<U> XorTSeq<ST,U> |
scanRight(U identity,
java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
Scan right
|
XorTSeq<ST,T> |
shuffle() |
XorTSeq<ST,T> |
shuffle(java.util.Random random) |
XorTSeq<ST,T> |
skip(long num)
assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); |
XorTSeq<ST,T> |
skipLast(int num)
assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2)
.collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
|
XorTSeq<ST,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
|
XorTSeq<ST,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 *
|
XorTSeq<ST,T> |
slice(long from,
long to) |
XorTSeq<ST,ListX<T>> |
sliding(int windowSize)
Create a sliding view over this Sequence
|
XorTSeq<ST,ListX<T>> |
sliding(int windowSize,
int increment)
Create a sliding view over this Sequence
|
XorTSeq<ST,T> |
sorted()
assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); |
XorTSeq<ST,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)));
|
<U extends java.lang.Comparable<? super U>> |
sorted(java.util.function.Function<? super T,? extends U> function) |
ReactiveSeq<T> |
stream() |
XorTSeq<T,ST> |
swap() |
XorTSeq<ST,T> |
takeRight(int num)
Generate a new Traversable that takes the specified number elements from the end of this Traversable
|
XorTSeq<ST,T> |
takeUntil(java.util.function.Predicate<? super T> p)
Generate a new Traversable that takes elements from this Traversable until the predicate holds
|
XorTSeq<ST,T> |
takeWhile(java.util.function.Predicate<? super T> p)
Generate a new Traversable that takes elements from this Traversable as long as the predicate holds
|
java.lang.String |
toString() |
AnyMSeq<? extends Traversable<T>> |
transformerStream() |
<R> XorTSeq<ST,R> |
unit(R value) |
<T> XorTSeq<ST,T> |
unitAnyM(AnyM<Traversable<T>> traversable) |
<R> XorTSeq<ST,R> |
unitIterator(java.util.Iterator<R> it) |
<T> XorTSeq<ST,T> |
unitStream(ReactiveSeq<T> traversable) |
AnyMSeq<Xor<ST,T>> |
unwrap() |
<R> R |
visit(java.util.function.Function<ST,? extends R> secondary,
java.util.function.Function<? super T,? extends R> primary,
Monoid<R> combiner) |
<U> XorTSeq<ST,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
|
<U,R> XorTSeq<ST,R> |
zip(java.lang.Iterable<? extends U> other,
java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
|
<U> XorTSeq<ST,org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(org.jooq.lambda.Seq<? extends U> other)
Zip (combine) this Zippable with the supplied Seq combining both into a Tuple2
|
<U,R> XorTSeq<ST,R> |
zip(org.jooq.lambda.Seq<? extends U> other,
java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zip (combine) this Zippable with the supplied Seq, using the supplied combining function
|
<U> XorTSeq<ST,org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(java.util.stream.Stream<? extends U> other)
Zip 2 streams into one
|
<U,R> XorTSeq<ST,R> |
zip(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
|
<S,U> XorTSeq<ST,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
|
<T2,T3,T4> XorTSeq<ST,org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> |
zip4(java.util.stream.Stream<? extends T2> second,
java.util.stream.Stream<? extends T3> third,
java.util.stream.Stream<? extends T4> fourth)
zip 4 Streams into 1
|
XorTSeq<ST,org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> |
zipWithIndex()
Add an index to the current Stream
|
clone, finalize, getClass, notify, notifyAll, wait, wait, wait
bind, cast, emptyOptional, filterNot, fromAnyM, fromAnyMSeq, fromAnyMValue, fromFuture, fromIterable, fromIterablXorue, fromOptional, fromPublisher, fromStream, fromValue, notNull, of, ofType, patternMatch, trampoline
subscribe
futureOperations, lazyOperations
seq, toCompletableFuture, toDequeX, toEvalAlways, toEvalLater, toEvalNow, toFutureStream, toFutureStream, toFutureW, toIor, toIorSecondary, toListX, toMapX, toMaybe, toOptional, toPBagX, toPMapX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toStreamable, toTry, toValue, toValueMap, toValueSet, toXor, toXorSecondary
drop, take, traversable
fixedDelay, onePer, xPer
futureStream, getStreamable, isEmpty, jdkStream, reactiveSeq, reveresedJDKStream, reveresedStream
foldable, headAndTail, visit
allMatch, anyMatch, avg, avg, avgDouble, avgInt, avgLong, bitAnd, bitAnd, bitAndInt, bitAndLong, bitOr, bitOr, bitOrInt, bitOrLong, collect, commonPrefix, commonSuffix, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, foldFuture, foldLazy, foldTry, max, max, max, max, maxAll, maxAll, maxAll, maxAll, maxAllBy, maxAllBy, maxBy, maxBy, median, median, medianBy, medianBy, min, min, min, min, minAll, minAll, minAll, minAll, minAllBy, minAllBy, minBy, minBy, mode, modeAll, modeAllBy, modeBy, noneMatch, percentile, percentile, percentileBy, percentileBy, sum, sum, sumDouble, sumInt, sumLong, toCollection, toList, toList, toMap, toMap, toSet, toSet, toString, toString
collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect
endsWith, endsWithIterable, findAny, findFirst, firstValue, 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, validate, xMatch
public XorTSeq<ST,T> peek(java.util.function.Consumer<? super T> peek)
XorT.of(AnyM.fromStream(Xor.of(10))
.peek(System.out::println);
//prints 10
public XorTSeq<ST,T> filter(java.util.function.Predicate<? super T> test)
XorT.of(AnyM.fromStream(Xor.of(10))
.filter(t->t!=10);
//XorT<AnyMSeq<Stream<Xor.empty>>>
public <B> XorTSeq<ST,B> map(java.util.function.Function<? super T,? extends B> f)
XorT.of(AnyM.fromStream(Xor.of(10))
.map(t->t=t+1);
//XorT<AnyMSeq<Stream<Xor[11]>>>
public <ST2,B> XorTSeq<ST,B> flatMapT(java.util.function.Function<? super T,XorTSeq<ST2,? extends B>> f)
XorT.of(AnyM.fromStream(Xor.of(10))
.flatMap(t->Xor.empty();
//XorT<AnyMSeq<Stream<Xor.empty>>>
f
- FlatMap functionpublic <T> XorTSeq<ST,T> unitStream(ReactiveSeq<T> traversable)
unitStream
in interface ValueTransformerSeq<T>
public <T> XorTSeq<ST,T> unitAnyM(AnyM<Traversable<T>> traversable)
unitAnyM
in interface TransformerSeq<T>
public AnyMSeq<? extends Traversable<T>> transformerStream()
transformerStream
in interface TransformerSeq<T>
public <B> XorTSeq<ST,B> flatMap(java.util.function.Function<? super T,? extends MonadicValue<? extends B>> f)
public static <ST,U,R> java.util.function.Function<XorTSeq<ST,U>,XorTSeq<ST,R>> lift(java.util.function.Function<? super U,? extends R> fn)
{ @code Functionadd2 = i -> i + 2; Function , XorT > optTAdd2 = XorT.lift(add2); Stream withNulls = Stream.of(1, 2, null); AnyMSeq stream = AnyM.ofMonad(withNulls); AnyMSeq > streamOpt = stream.map(Xor::ofNullable); List results = optTAdd2.apply(XorT.of(streamOpt)).unwrap(). >> unwrap() .filter(Xor::isPresent).map(Xor::get).collect(Collectors.toList()); // Arrays.asList(3,4); }
public static <ST,U1,U2,R> java.util.function.BiFunction<XorTSeq<ST,U1>,XorTSeq<ST,U2>,XorTSeq<ST,R>> lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)
{ @code BiFunctionadd = (a, b) -> a + b; BiFunction , XorT , XorT > optTAdd2 = XorT.lift2(add); Stream withNulls = Stream.of(1, 2, null); AnyMSeq stream = AnyM.ofMonad(withNulls); AnyMSeq > streamOpt = stream.map(Xor::ofNullable); CompletableFuture > two = CompletableFuture.supplyAsync(() -> Xor.of(2)); AnyMSeq > future = AnyM.ofMonad(two); List results = optTAdd2.apply(XorT.of(streamOpt), XorT.of(future)).unwrap() . >> unwrap().filter(Xor::isPresent).map(Xor::get) .collect(Collectors.toList()); // Arrays.asList(3,4); }
public static <ST,A> XorTSeq<ST,A> fromAnyM(AnyMSeq<A> anyM)
anyM
- AnyM that doesn't contain a monad wrapping an Xorpublic static <ST,A> XorTSeq<ST,A> of(AnyMSeq<Xor<ST,A>> monads)
monads
- AnyM that contains a monad wrapping an Xorpublic java.lang.String toString()
toString
in class java.lang.Object
public boolean isPrimary()
public boolean isSecondary()
public <R> R visit(java.util.function.Function<ST,? extends R> secondary, java.util.function.Function<? super T,? extends R> primary, Monoid<R> combiner)
public ReactiveSeq<T> stream()
stream
in interface TransformerSeq<T>
stream
in interface Foldable<T>
stream
in interface Sequential<T>
stream
in interface ConvertableSequence<T>
stream
in interface ToStream<T>
stream
in interface Traversable<T>
ReactiveSeq
) of it's elementspublic java.util.Iterator<T> iterator()
public org.jooq.lambda.Collectable<T> collectable()
CyclopsCollectable
collectable
in interface CyclopsCollectable<T>
public boolean isSeqPresent()
isSeqPresent
in interface TransformerSeq<T>
public static <ST,T> XorTSeq<ST,T> emptyList()
public XorTSeq<ST,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 TransformerSeq<T>
combine
in interface ValueTransformerSeq<T>
combine
in interface Traversable<T>
predicate
- Test to see if two neighbours should be joinedop
- Reducer to combine neighbourspublic XorTSeq<ST,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 TransformerSeq<T>
cycle
in interface ValueTransformerSeq<T>
cycle
in interface Traversable<T>
times
- Times values should be repeated within a Streampublic XorTSeq<ST,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 TransformerSeq<T>
cycle
in interface ValueTransformerSeq<T>
cycle
in interface Traversable<T>
m
- Monoid to be used in reductiontimes
- Number of times value should be repeatedpublic XorTSeq<ST,T> cycleWhile(java.util.function.Predicate<? super T> predicate)
Traversable
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 TransformerSeq<T>
cycleWhile
in interface ValueTransformerSeq<T>
cycleWhile
in interface Traversable<T>
predicate
- repeat while truepublic XorTSeq<ST,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 TransformerSeq<T>
cycleUntil
in interface ValueTransformerSeq<T>
cycleUntil
in interface Traversable<T>
predicate
- repeat while truepublic <U,R> XorTSeq<ST,R> zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zippable
zip
in interface TransformerSeq<T>
zip
in interface ValueTransformerSeq<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- to zip withzipper
- Zip functionpublic <U,R> XorTSeq<ST,R> zip(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zippable
zip
in interface TransformerSeq<T>
zip
in interface ValueTransformerSeq<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- Seq to combine withzipper
- Zip / combining functionpublic <U,R> XorTSeq<ST,R> zip(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zippable
zip
in interface TransformerSeq<T>
zip
in interface ValueTransformerSeq<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- Stream to combine withzipper
- Zip / combining functionpublic <U> XorTSeq<ST,org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.util.stream.Stream<? extends U> other)
Traversable
List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
// [[1,"a"],[2,"b"]]
zip
in interface TransformerSeq<T>
zip
in interface ValueTransformerSeq<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- Stream to combine withpublic <U> XorTSeq<ST,org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<? extends U> other)
Zippable
zip
in interface TransformerSeq<T>
zip
in interface ValueTransformerSeq<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- Seq to combine withpublic <U> XorTSeq<ST,org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
Zippable
zip
in interface TransformerSeq<T>
zip
in interface ValueTransformerSeq<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- Iterable to combine withpublic <S,U> XorTSeq<ST,org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.util.stream.Stream<? extends S> second, java.util.stream.Stream<? extends U> third)
Traversable
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 TransformerSeq<T>
zip3
in interface ValueTransformerSeq<T>
zip3
in interface Traversable<T>
public <T2,T3,T4> XorTSeq<ST,org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.util.stream.Stream<? extends T2> second, java.util.stream.Stream<? extends T3> third, java.util.stream.Stream<? extends T4> fourth)
Traversable
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 TransformerSeq<T>
zip4
in interface ValueTransformerSeq<T>
zip4
in interface Traversable<T>
public XorTSeq<ST,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 TransformerSeq<T>
zipWithIndex
in interface ValueTransformerSeq<T>
zipWithIndex
in interface Traversable<T>
public XorTSeq<ST,ListX<T>> sliding(int windowSize)
Traversable
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 TransformerSeq<T>
sliding
in interface ValueTransformerSeq<T>
sliding
in interface Traversable<T>
windowSize
- Size of sliding windowpublic XorTSeq<ST,ListX<T>> sliding(int windowSize, int increment)
Traversable
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 TransformerSeq<T>
sliding
in interface ValueTransformerSeq<T>
sliding
in interface Traversable<T>
windowSize
- number of elements in each batchincrement
- for each windowpublic <C extends java.util.Collection<? super T>> XorTSeq<ST,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 TransformerSeq<T>
grouped
in interface ValueTransformerSeq<T>
grouped
in interface Traversable<T>
size
- batch sizesupplier
- Collection factorypublic XorTSeq<ST,ListX<T>> groupedUntil(java.util.function.Predicate<? super T> predicate)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5,6)
.groupedUntil(i->i%3==0)
.toList()
.size(),equalTo(2));
groupedUntil
in interface TransformerSeq<T>
groupedUntil
in interface ValueTransformerSeq<T>
groupedUntil
in interface Traversable<T>
predicate
- Batch until predicate holds, then open next batchpublic XorTSeq<ST,ListX<T>> groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5,6)
.groupedStatefullyUntil((s,i)->s.contains(4) ? true : false)
.toList().size(),equalTo(5));
groupedStatefullyUntil
in interface TransformerSeq<T>
groupedStatefullyUntil
in interface ValueTransformerSeq<T>
groupedStatefullyUntil
in interface Traversable<T>
predicate
- Window while truepublic XorTSeq<ST,ListX<T>> groupedWhile(java.util.function.Predicate<? super T> predicate)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5,6)
.groupedWhile(i->i%3!=0)
.toList().size(),equalTo(2));
groupedWhile
in interface TransformerSeq<T>
groupedWhile
in interface ValueTransformerSeq<T>
groupedWhile
in interface Traversable<T>
predicate
- Batch while predicate holds, then open next batchpublic <C extends java.util.Collection<? super T>> XorTSeq<ST,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 TransformerSeq<T>
groupedWhile
in interface ValueTransformerSeq<T>
groupedWhile
in interface Traversable<T>
predicate
- Batch while predicate holds, then open next batchfactory
- Collection factorypublic <C extends java.util.Collection<? super T>> XorTSeq<ST,C> groupedUntil(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)
Traversable
ReactiveSeq.of(1,2,3,4,5,6)
.groupedUntil(i->i%3!=0)
.toList()
//2
groupedUntil
in interface TransformerSeq<T>
groupedUntil
in interface ValueTransformerSeq<T>
groupedUntil
in interface Traversable<T>
predicate
- Batch until predicate holds, then open next batchfactory
- Collection factorypublic XorTSeq<ST,ListX<T>> grouped(int groupSize)
Traversable
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 TransformerSeq<T>
grouped
in interface ValueTransformerSeq<T>
grouped
in interface Traversable<T>
groupSize
- Size of each Grouppublic <K,A,D> XorTSeq<ST,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)
Traversable
grouped
in interface TransformerSeq<T>
grouped
in interface ValueTransformerSeq<T>
grouped
in interface Traversable<T>
classifier
- Grouping functiondownstream
- Collector to create the grouping collectionpublic <K> XorTSeq<ST,org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)
Traversable
grouped
in interface TransformerSeq<T>
grouped
in interface ValueTransformerSeq<T>
grouped
in interface Traversable<T>
classifier
- Grouping functionpublic XorTSeq<ST,T> distinct()
distinct
in interface TransformerSeq<T>
distinct
in interface ValueTransformerSeq<T>
distinct
in interface Traversable<T>
public XorTSeq<ST,T> scanLeft(Monoid<T> monoid)
Traversable
assertEquals(asList("", "a", "ab", "abc"),ReactiveSeq.of("a", "b", "c")
.scanLeft(Reducers.toString("")).toList());
scanLeft
in interface TransformerSeq<T>
scanLeft
in interface ValueTransformerSeq<T>
scanLeft
in interface Traversable<T>
public <U> XorTSeq<ST,U> scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)
Traversable
assertThat(of("a", "b", "c").scanLeft("", String::concat).toList().size(),
is(4));
scanLeft
in interface TransformerSeq<T>
scanLeft
in interface ValueTransformerSeq<T>
scanLeft
in interface Traversable<T>
public XorTSeq<ST,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 TransformerSeq<T>
scanRight
in interface ValueTransformerSeq<T>
scanRight
in interface Traversable<T>
public <U> XorTSeq<ST,U> scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends 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 TransformerSeq<T>
scanRight
in interface ValueTransformerSeq<T>
scanRight
in interface Traversable<T>
public XorTSeq<ST,T> sorted()
Traversable
assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));
sorted
in interface TransformerSeq<T>
sorted
in interface ValueTransformerSeq<T>
sorted
in interface Traversable<T>
public XorTSeq<ST,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 TransformerSeq<T>
sorted
in interface ValueTransformerSeq<T>
sorted
in interface Traversable<T>
c
- Compartor to sort withpublic XorTSeq<ST,T> takeWhile(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).takeWhile(i<3);
//[1,2]
takeWhile
in interface TransformerSeq<T>
takeWhile
in interface ValueTransformerSeq<T>
takeWhile
in interface Traversable<T>
p
- Predicate to determine when values should be takenpublic XorTSeq<ST,T> dropWhile(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).dropWhile(i<3);
//[3]
dropWhile
in interface TransformerSeq<T>
dropWhile
in interface ValueTransformerSeq<T>
dropWhile
in interface Traversable<T>
p
- Predicate to determine when values should be droppedpublic XorTSeq<ST,T> takeUntil(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).takeUntil(i<2);
//[1,2]
takeUntil
in interface TransformerSeq<T>
takeUntil
in interface ValueTransformerSeq<T>
takeUntil
in interface Traversable<T>
p
- Predicate to determine when values should be taken untilpublic XorTSeq<ST,T> dropUntil(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).dropUntil(i>2);
//[3]
dropUntil
in interface TransformerSeq<T>
dropUntil
in interface ValueTransformerSeq<T>
dropUntil
in interface Traversable<T>
p
- Predicate to determine when values should be droppedpublic XorTSeq<ST,T> dropRight(int num)
Traversable
ListX.of(1,2,3).dropRight(2);
//[1]
dropRight
in interface TransformerSeq<T>
dropRight
in interface ValueTransformerSeq<T>
dropRight
in interface Traversable<T>
num
- Drop this number of elements from the end of this Traversablepublic XorTSeq<ST,T> takeRight(int num)
Traversable
ListX.of(1,2,3).takeRight(2);
//[2,3]
takeRight
in interface TransformerSeq<T>
takeRight
in interface ValueTransformerSeq<T>
takeRight
in interface Traversable<T>
num
- Take this number of elements from the end of this Traversablepublic XorTSeq<ST,T> skip(long num)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));
skip
in interface TransformerSeq<T>
skip
in interface ValueTransformerSeq<T>
skip
in interface Traversable<T>
num
- Number of elemenets to skippublic XorTSeq<ST,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 TransformerSeq<T>
skipWhile
in interface ValueTransformerSeq<T>
skipWhile
in interface Traversable<T>
p
- Predicate to skip while truepublic XorTSeq<ST,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 TransformerSeq<T>
skipUntil
in interface ValueTransformerSeq<T>
skipUntil
in interface Traversable<T>
p
- Predicate to skip until truepublic XorTSeq<ST,T> limit(long num)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
limit
in interface TransformerSeq<T>
limit
in interface ValueTransformerSeq<T>
limit
in interface Traversable<T>
num
- Limit element size to numpublic XorTSeq<ST,T> limitWhile(java.util.function.Predicate<? super T> p)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).sorted().limitWhile(i->i<6).toList(),equalTo(Arrays.asList(3,4)));
limitWhile
in interface TransformerSeq<T>
limitWhile
in interface ValueTransformerSeq<T>
limitWhile
in interface Traversable<T>
p
- Limit while predicate is truepublic XorTSeq<ST,T> limitUntil(java.util.function.Predicate<? super T> p)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).limitUntil(i->i==6).toList(),equalTo(Arrays.asList(4,3)));
limitUntil
in interface TransformerSeq<T>
limitUntil
in interface ValueTransformerSeq<T>
limitUntil
in interface Traversable<T>
p
- Limit until predicate is truepublic XorTSeq<ST,T> intersperse(T value)
Traversable
intersperse
in interface TransformerSeq<T>
intersperse
in interface ValueTransformerSeq<T>
intersperse
in interface Traversable<T>
public XorTSeq<ST,T> reverse()
Traversable
assertThat( of(1, 2, 3).reverse().toList(),
equalTo(asList(3, 2, 1)));
reverse
in interface TransformerSeq<T>
reverse
in interface ValueTransformerSeq<T>
reverse
in interface Traversable<T>
public XorTSeq<ST,T> shuffle()
shuffle
in interface TransformerSeq<T>
shuffle
in interface ValueTransformerSeq<T>
shuffle
in interface Traversable<T>
public XorTSeq<ST,T> skipLast(int num)
Traversable
skipLast
in interface TransformerSeq<T>
skipLast
in interface ValueTransformerSeq<T>
skipLast
in interface Traversable<T>
public XorTSeq<ST,T> limitLast(int num)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5)
.limitLast(2)
.collect(Collectors.toList()),equalTo(Arrays.asList(4,5)));
limitLast
in interface TransformerSeq<T>
limitLast
in interface ValueTransformerSeq<T>
limitLast
in interface Traversable<T>
num
- of elements to return (last elements)public XorTSeq<ST,T> onEmpty(T value)
OnEmpty
onEmpty
in interface TransformerSeq<T>
onEmpty
in interface ValueTransformerSeq<T>
onEmpty
in interface OnEmpty<T>
onEmpty
in interface Traversable<T>
public XorTSeq<ST,T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
OnEmpty
onEmptyGet
in interface TransformerSeq<T>
onEmptyGet
in interface ValueTransformerSeq<T>
onEmptyGet
in interface OnEmpty<T>
onEmptyGet
in interface Traversable<T>
supplier
- to determine new value for containerpublic <X extends java.lang.Throwable> XorTSeq<ST,T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
OnEmpty
onEmptyThrow
in interface TransformerSeq<T>
onEmptyThrow
in interface ValueTransformerSeq<T>
onEmptyThrow
in interface OnEmpty<T>
onEmptyThrow
in interface Traversable<T>
supplier
- to create exception frompublic XorTSeq<ST,T> shuffle(java.util.Random random)
shuffle
in interface TransformerSeq<T>
shuffle
in interface ValueTransformerSeq<T>
shuffle
in interface Traversable<T>
public XorTSeq<ST,T> slice(long from, long to)
slice
in interface TransformerSeq<T>
slice
in interface ValueTransformerSeq<T>
slice
in interface Traversable<T>
public <U extends java.lang.Comparable<? super U>> XorTSeq<ST,T> sorted(java.util.function.Function<? super T,? extends U> function)
sorted
in interface TransformerSeq<T>
sorted
in interface ValueTransformerSeq<T>
sorted
in interface Traversable<T>
public int hashCode()
hashCode
in class java.lang.Object
public boolean equals(java.lang.Object o)
equals
in class java.lang.Object