T - The type contained on the Try withinpublic class TryTSeq<T,X extends java.lang.Throwable> extends java.lang.Object implements TryT<T,X>, ValueTransformerSeq<T>, Foldable<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
|
TryTSeq<T,X> |
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.
|
TryTSeq<T,X> |
cycle(int times)
Convert to a Stream with the values repeated specified times
|
TryTSeq<T,X> |
cycle(Monoid<T> m,
int times)
Convert to a Stream with the result of a reduction operation repeated
specified times
|
TryTSeq<T,X> |
cycleUntil(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream until specified predicate holds
|
TryTSeq<T,X> |
cycleWhile(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream while specified predicate holds
|
TryTSeq<T,X> |
distinct() |
TryTSeq<T,X> |
dropRight(int num) |
TryTSeq<T,X> |
dropUntil(java.util.function.Predicate<? super T> p) |
TryTSeq<T,X> |
dropWhile(java.util.function.Predicate<? super T> p) |
<R> TryTSeq<R,X> |
empty() |
static <T,X extends java.lang.Throwable> |
emptyList() |
MaybeTSeq<T> |
filter(java.util.function.Predicate<? super T> test)
Filter the wrapped Try
|
<B> TryTSeq<B,X> |
flatMap(java.util.function.Function<? super T,? extends Try<B,X>> f) |
<B> TryTSeq<B,X> |
flatMapT(java.util.function.Function<? super T,TryTSeq<B,X>> f)
Flat Map the wrapped Try
|
static <A,X extends java.lang.Throwable> |
fromAnyM(AnyMSeq<A> anyM)
|
<K> TryTSeq<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>,X> |
grouped(java.util.function.Function<? super T,? extends K> classifier) |
<K,A,D> TryTSeq<org.jooq.lambda.tuple.Tuple2<K,D>,X> |
grouped(java.util.function.Function<? super T,? extends K> classifier,
java.util.stream.Collector<? super T,A,D> downstream) |
TryTSeq<ListX<T>,X> |
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
|
TryTSeq<ListX<T>,X> |
groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
Create Travesable of Lists where
each List is populated while the supplied bipredicate holds.
|
TryTSeq<ListX<T>,X> |
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 SequenceM batched by a Collection, where each batch is populated
until the predicate holds
|
TryTSeq<ListX<T>,X> |
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
|
TryTSeq<T,X> |
intersperse(T value)
Returns a stream with a given value interspersed between any two values
of this stream.
|
boolean |
isFailure() |
boolean |
isSeqPresent() |
boolean |
isSuccess() |
java.util.Iterator<T> |
iterator() |
static <U,R,X extends java.lang.Throwable> |
lift(java.util.function.Function<? super U,? extends R> fn)
Lift a function into one that accepts and returns an TryT
This allows multiple monad types to add functionality to existing functions and methods
e.g.
|
static <U1,U2,R,X extends java.lang.Throwable> |
lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)
Lift a BiFunction into one that accepts and returns TryTs
This allows multiple monad types to add functionality to existing functions and methods
e.g.
|
TryTSeq<T,X> |
limit(long num)
assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3)); |
TryTSeq<T,X> |
limitLast(int num)
Limit results to the last x elements in a SequenceM
|
TryTSeq<T,X> |
limitUntil(java.util.function.Predicate<? super T> p)
Take elements from the Stream until the predicate returns true, after
which all elements are excluded.
|
TryTSeq<T,X> |
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> TryTSeq<B,X> |
map(java.util.function.Function<? super T,? extends B> f)
Map the wrapped Try
|
static <A,X extends java.lang.Throwable> |
of(AnyMSeq<Try<A,X>> monads)
Construct an TryT from an AnyM that wraps a monad containing Trys
|
static <A,X extends java.lang.Throwable> |
of(Try<A,X> monads) |
TryTSeq<T,X> |
onEmpty(T value) |
TryTSeq<T,X> |
onEmptyGet(java.util.function.Supplier<? extends T> supplier) |
<X extends java.lang.Throwable> |
onEmptyThrow(java.util.function.Supplier<? extends X> supplier) |
TryTSeq<T,X> |
peek(java.util.function.Consumer<? super T> peek)
Peek at the current value of the Try
|
TryTSeq<T,X> |
reverse() |
TryTSeq<T,X> |
scanLeft(Monoid<T> monoid)
Scan left using supplied Monoid
|
<U> TryTSeq<U,X> |
scanLeft(U seed,
java.util.function.BiFunction<? super U,? super T,? extends U> function)
Scan left
|
TryTSeq<T,X> |
scanRight(Monoid<T> monoid)
Scan right
|
<U> TryTSeq<U,X> |
scanRight(U identity,
java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
Scan right
|
TryTSeq<T,X> |
shuffle() |
TryTSeq<T,X> |
shuffle(java.util.Random random) |
TryTSeq<T,X> |
skip(long num)
assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); |
TryTSeq<T,X> |
skipLast(int num)
assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2)
.collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
|
TryTSeq<T,X> |
skipUntil(java.util.function.Predicate<? super T> p)
Drop elements from the Stream until the predicate returns true, after
which all elements are included
|
TryTSeq<T,X> |
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 *
|
TryTSeq<T,X> |
slice(long from,
long to) |
TryTSeq<ListX<T>,X> |
sliding(int windowSize)
Create a sliding view over this Sequence
|
TryTSeq<ListX<T>,X> |
sliding(int windowSize,
int increment)
Create a sliding view over this Sequence
|
TryTSeq<T,X> |
sorted()
assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); |
TryTSeq<T,X> |
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() |
TryTSeq<T,X> |
takeRight(int num) |
TryTSeq<T,X> |
takeUntil(java.util.function.Predicate<? super T> p) |
TryTSeq<T,X> |
takeWhile(java.util.function.Predicate<? super T> p) |
java.lang.String |
toString() |
AnyMSeq<? extends Traversable<T>> |
transformerStream() |
<R> TryTSeq<R,X> |
unit(R value) |
<T> TryTSeq<T,X> |
unitAnyM(AnyM<Traversable<T>> traversable) |
<R> TryTSeq<R,X> |
unitIterator(java.util.Iterator<R> it) |
<T> TryTSeq<T,X> |
unitStream(ReactiveSeq<T> traversable) |
AnyMSeq<Try<T,X>> |
unwrap() |
<R> R |
visit(java.util.function.Function<? super T,? extends R> success,
java.util.function.Function<? super X,? extends R> failure,
Monoid<R> combiner) |
<U,R> TryTSeq<R,X> |
zip(java.lang.Iterable<? extends U> other,
java.util.function.BiFunction<? super T,? super U,? extends R> zipper) |
<U> TryTSeq<org.jooq.lambda.tuple.Tuple2<T,U>,X> |
zip(org.jooq.lambda.Seq<? extends U> other)
Zip 2 streams into one
|
<S,U> TryTSeq<org.jooq.lambda.tuple.Tuple3<T,S,U>,X> |
zip3(java.util.stream.Stream<? extends S> second,
java.util.stream.Stream<? extends U> third)
zip 3 Streams into one
|
<T2,T3,T4> TryTSeq<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>,X> |
zip4(java.util.stream.Stream<T2> second,
java.util.stream.Stream<T3> third,
java.util.stream.Stream<T4> fourth)
zip 4 Streams into 1
|
<U> TryTSeq<org.jooq.lambda.tuple.Tuple2<T,U>,X> |
zipStream(java.util.stream.Stream<? extends U> other)
Zip 2 streams into one
|
TryTSeq<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>,X> |
zipWithIndex()
Add an index to the current Stream
|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, waitbind, cast, emptyOptional, filterNot, fromAnyM, fromAnyMSeq, fromAnyMValue, fromFuture, fromIterable, fromIterablTryue, fromOptional, fromPublisher, fromStream, fromValue, notNull, of, ofType, patternMatch, trampolinesubscribefutureOperations, lazyOperationsseq, 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, toXorSecondarytraversablefixedDelay, onePer, xPerfutureStream, getStreamable, isEmpty, jdkStream, reactiveSeq, reveresedJDKStream, reveresedStreamendsWith, endsWithIterable, findAny, findFirst, firstValue, foldable, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, headAndTail, 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, visit, visit, xMatchallMatch, anyMatch, avg, avg, avgDouble, avgInt, avgLong, bitAnd, bitAnd, bitAndInt, bitAndLong, bitOr, bitOr, bitOrInt, bitOrLong, collect, commonPrefix, commonSuffix, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, 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, toStringpublic TryTSeq<T,X> peek(java.util.function.Consumer<? super T> peek)
TryT.of(AnyM.fromStream(Success.of(10))
.peek(System.out::println);
//prints 10
public MaybeTSeq<T> filter(java.util.function.Predicate<? super T> test)
TryT.of(AnyM.fromStream(Success.of(10))
.filter(t->t!=10);
//TryT<AnyMSeq<Stream<Optional.empty>>>
public <B> TryTSeq<B,X> map(java.util.function.Function<? super T,? extends B> f)
TryT.of(AnyM.fromStream(Success.of(10))
.map(t->t=t+1);
//TryT<AnyMSeq<Stream<Success[11]>>>
public <B> TryTSeq<B,X> flatMapT(java.util.function.Function<? super T,TryTSeq<B,X>> f)
TryT.of(AnyM.fromStream(Success.of(10))
.flatMap(t->Failure.of(new Exception());
//TryT<AnyMSeq<Stream<Failure[Excption]>>>
f - FlatMap functionpublic <B> TryTSeq<B,X> flatMap(java.util.function.Function<? super T,? extends Try<B,X>> f)
public <T> TryTSeq<T,X> unitStream(ReactiveSeq<T> traversable)
unitStream in interface ValueTransformerSeq<T>public <T> TryTSeq<T,X> unitAnyM(AnyM<Traversable<T>> traversable)
unitAnyM in interface TransformerSeq<T>public AnyMSeq<? extends Traversable<T>> transformerStream()
transformerStream in interface TransformerSeq<T>public static <U,R,X extends java.lang.Throwable> java.util.function.Function<TryTSeq<U,X>,TryTSeq<R,X>> lift(java.util.function.Function<? super U,? extends R> fn)
Function<Integer,Integer> add2 = i -> i+2;
Function<TryT<Integer,RuntimeException>, TryT<Integer,RuntimeException>> optTAdd2 = TryT.lift(add2);
Stream<Integer> withNulls = Stream.of(1,2,null);
AnyMSeq<Integer> stream = AnyM.ofMonad(withNulls);
AnyMSeq<Try<Integer,RuntimeException>> streamOpt = stream.map(this::toTry);
List<Integer> results = optTAdd2.apply(TryT.of(streamOpt))
.unwrap()
.<Stream<Try<Integer,RuntimeException>>>unwrap()
.filter(Try::isSuccess)
.map(Try::get)
.collect(Collectors.toList());
//Arrays.asList(3,4);
public static <U1,U2,R,X extends java.lang.Throwable> java.util.function.BiFunction<TryTSeq<U1,X>,TryTSeq<U2,X>,TryTSeq<R,X>> lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)
BiFunction<Integer,Integer,Integer> add = (a,b) -> a+b;
BiFunction<TryT<Integer,RuntimeException>,TryT<Integer,RuntimeException>, TryT<Integer,RuntimeException>> optTAdd2 = TryT.lift2(add);
Stream<Integer> withNulls = Stream.of(1,2,null);
AnyMSeq<Integer> stream = AnyM.ofMonad(withNulls);
AnyMSeq<Try<Integer,RuntimeException>> streamOpt = stream.map(this::toTry);
CompletableFuture<Try<Integer,RuntimeException>> two = CompletableFuture.completedFuture(Try.of(2));
AnyMSeq<Try<Integer,RuntimeException>> future= AnyM.ofMonad(two);
List<Integer> results = optTAdd2.apply(TryT.of(streamOpt),TryT.of(future))
.unwrap()
.<Stream<Try<Integer,RuntimeException>>>unwrap()
.filter(Try::isSuccess)
.map(Try::get)
.collect(Collectors.toList());
//Arrays.asList(3,4);
public static <A,X extends java.lang.Throwable> TryTSeq<A,X> fromAnyM(AnyMSeq<A> anyM)
anyM - AnyM that doesn't contain a monad wrapping an Trypublic static <A,X extends java.lang.Throwable> TryTSeq<A,X> of(AnyMSeq<Try<A,X>> monads)
monads - AnyM that contains a monad wrapping an Trypublic java.lang.String toString()
toString in class java.lang.Objectpublic boolean isSuccess()
public boolean isFailure()
public <R> R visit(java.util.function.Function<? super T,? extends R> success, java.util.function.Function<? super X,? extends R> failure, 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>public java.util.Iterator<T> iterator()
public org.jooq.lambda.Collectable<T> collectable()
CyclopsCollectablecollectable in interface CyclopsCollectable<T>public boolean isSeqPresent()
isSeqPresent in interface TransformerSeq<T>public static <T,X extends java.lang.Throwable> TryTSeq<T,X> emptyList()
public TryTSeq<T,X> 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 TryTSeq<T,X> 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 TryTSeq<T,X> 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 TryTSeq<T,X> 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 TransformerSeq<T>cycleWhile in interface ValueTransformerSeq<T>cycleWhile in interface Traversable<T>predicate - repeat while truepublic TryTSeq<T,X> 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> TryTSeq<R,X> zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
zip in interface TransformerSeq<T>zip in interface ValueTransformerSeq<T>zip in interface Traversable<T>public <U> TryTSeq<org.jooq.lambda.tuple.Tuple2<T,U>,X> zipStream(java.util.stream.Stream<? extends 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 TransformerSeq<T>zipStream in interface ValueTransformerSeq<T>zipStream in interface Traversable<T>public <U> TryTSeq<org.jooq.lambda.tuple.Tuple2<T,U>,X> zip(org.jooq.lambda.Seq<? extends 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 TransformerSeq<T>zip in interface ValueTransformerSeq<T>zip in interface Traversable<T>public <S,U> TryTSeq<org.jooq.lambda.tuple.Tuple3<T,S,U>,X> 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 TransformerSeq<T>zip3 in interface ValueTransformerSeq<T>zip3 in interface Traversable<T>public <T2,T3,T4> TryTSeq<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>,X> 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 TransformerSeq<T>zip4 in interface ValueTransformerSeq<T>zip4 in interface Traversable<T>public TryTSeq<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>,X> 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 TryTSeq<ListX<T>,X> 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 TransformerSeq<T>sliding in interface ValueTransformerSeq<T>sliding in interface Traversable<T>windowSize - Size of sliding windowpublic TryTSeq<ListX<T>,X> 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 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>> TryTSeq<C,X> 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 TryTSeq<ListX<T>,X> 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 TryTSeq<ListX<T>,X> groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5,6)
.groupedStatefullyWhile((s,i)->s.contains(4) ? true : false)
.toList().size(),equalTo(5));
groupedStatefullyWhile in interface TransformerSeq<T>groupedStatefullyWhile in interface ValueTransformerSeq<T>groupedStatefullyWhile in interface Traversable<T>predicate - Window while truepublic TryTSeq<ListX<T>,X> 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>> TryTSeq<C,X> 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>> TryTSeq<C,X> 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 TransformerSeq<T>groupedUntil in interface ValueTransformerSeq<T>groupedUntil in interface Traversable<T>predicate - Batch until predicate holds, then open next batchfactory - Collection factorypublic TryTSeq<ListX<T>,X> 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 TransformerSeq<T>grouped in interface ValueTransformerSeq<T>grouped in interface Traversable<T>groupSize - Size of each Grouppublic <K,A,D> TryTSeq<org.jooq.lambda.tuple.Tuple2<K,D>,X> grouped(java.util.function.Function<? super T,? extends K> classifier, java.util.stream.Collector<? super T,A,D> downstream)
grouped in interface TransformerSeq<T>grouped in interface ValueTransformerSeq<T>grouped in interface Traversable<T>public <K> TryTSeq<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>,X> grouped(java.util.function.Function<? super T,? extends K> classifier)
grouped in interface TransformerSeq<T>grouped in interface ValueTransformerSeq<T>grouped in interface Traversable<T>public TryTSeq<T,X> distinct()
distinct in interface TransformerSeq<T>distinct in interface ValueTransformerSeq<T>distinct in interface Traversable<T>public TryTSeq<T,X> 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> TryTSeq<U,X> 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 TryTSeq<T,X> 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> TryTSeq<U,X> 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 TryTSeq<T,X> 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 TryTSeq<T,X> 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 TryTSeq<T,X> takeWhile(java.util.function.Predicate<? super T> p)
takeWhile in interface TransformerSeq<T>takeWhile in interface ValueTransformerSeq<T>takeWhile in interface Traversable<T>public TryTSeq<T,X> dropWhile(java.util.function.Predicate<? super T> p)
dropWhile in interface TransformerSeq<T>dropWhile in interface ValueTransformerSeq<T>dropWhile in interface Traversable<T>public TryTSeq<T,X> takeUntil(java.util.function.Predicate<? super T> p)
takeUntil in interface TransformerSeq<T>takeUntil in interface ValueTransformerSeq<T>takeUntil in interface Traversable<T>public TryTSeq<T,X> dropUntil(java.util.function.Predicate<? super T> p)
dropUntil in interface TransformerSeq<T>dropUntil in interface ValueTransformerSeq<T>dropUntil in interface Traversable<T>public TryTSeq<T,X> dropRight(int num)
dropRight in interface TransformerSeq<T>dropRight in interface ValueTransformerSeq<T>dropRight in interface Traversable<T>public TryTSeq<T,X> takeRight(int num)
takeRight in interface TransformerSeq<T>takeRight in interface ValueTransformerSeq<T>takeRight in interface Traversable<T>public TryTSeq<T,X> 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 TryTSeq<T,X> 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 TryTSeq<T,X> 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 TryTSeq<T,X> 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 TryTSeq<T,X> 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 TryTSeq<T,X> 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 TryTSeq<T,X> intersperse(T value)
Traversableintersperse in interface TransformerSeq<T>intersperse in interface ValueTransformerSeq<T>intersperse in interface Traversable<T>public TryTSeq<T,X> reverse()
reverse in interface TransformerSeq<T>reverse in interface ValueTransformerSeq<T>reverse in interface Traversable<T>public TryTSeq<T,X> shuffle()
shuffle in interface TransformerSeq<T>shuffle in interface ValueTransformerSeq<T>shuffle in interface Traversable<T>public TryTSeq<T,X> skipLast(int num)
TraversableskipLast in interface TransformerSeq<T>skipLast in interface ValueTransformerSeq<T>skipLast in interface Traversable<T>public TryTSeq<T,X> 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 TryTSeq<T,X> onEmpty(T value)
onEmpty in interface TransformerSeq<T>onEmpty in interface ValueTransformerSeq<T>onEmpty in interface Traversable<T>public TryTSeq<T,X> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
onEmptyGet in interface TransformerSeq<T>onEmptyGet in interface ValueTransformerSeq<T>onEmptyGet in interface Traversable<T>public <X extends java.lang.Throwable> TryTSeq<T,X> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
onEmptyThrow in interface TransformerSeq<T>onEmptyThrow in interface ValueTransformerSeq<T>onEmptyThrow in interface Traversable<T>public TryTSeq<T,X> shuffle(java.util.Random random)
shuffle in interface TransformerSeq<T>shuffle in interface ValueTransformerSeq<T>shuffle in interface Traversable<T>public TryTSeq<T,X> 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>> TryTSeq<T,X> 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>