T
- Type of data stored inside the nest Listspublic class ListT<W extends WitnessType<W>,T> extends java.lang.Object implements To<ListT<W,T>>, FoldableTransformerSeq<W,T>
ListT<optional,Integer> streamT = ListT.ofList(AnyM.fromOptional(Optional.of(Arrays.asList(10))));
AnyM<optional, IndexedSequenceX<Integer>> anyM = listT.unwrap();
Optional<IndexedSequenceX<Integer>> opt = Witness.optional(anyM);
Optional<LinkedList<Integer>> list = opt.map(s -> s.toX(Converters::LinkedList));
Modifier and Type | Method and Description |
---|---|
ListT<W,T> |
append(T... values)
Append values to the take of this ReactiveSeq
|
ListT<W,T> |
append(T value) |
<U> ListT<W,U> |
cast(java.lang.Class<? extends U> type)
Cast all elements in a reactiveStream to a given type, possibly throwing a
ClassCastException . |
ListT<W,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.
|
ListT<W,T> |
combine(Monoid<T> op,
java.util.function.BiPredicate<? super T,? super T> predicate)
Combine two adjacent elements in a traversable using the supplied BinaryOperator
This is a stateful grouping and reduction operation.
|
ListT<W,T> |
cycle(long times)
Convert to a Stream with the values repeated specified times
|
ListT<W,T> |
cycle(Monoid<T> m,
long times)
Convert to a Stream with the result of a reduction operation repeated
specified times
|
ListT<W,T> |
cycleUntil(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream until specified predicate holds
|
ListT<W,T> |
cycleWhile(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream while specified predicate holds
|
ListT<W,T> |
deleteBetween(int start,
int end)
Delete elements between given indexes in a Stream
|
ListT<W,T> |
distinct() |
ListT<W,T> |
drop(long num)
assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7))); |
ListT<W,T> |
dropRight(int num)
Generate a new Traversable that drops the specified number elements from the take of this Traversable
|
ListT<W,T> |
dropUntil(java.util.function.Predicate<? super T> p)
Generate a new Traversable that drops elements from this Traversable until the predicate holds
|
ListT<W,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> ListT<W,R> |
empty() |
static <W extends WitnessType<W>,T> |
emptyList(W witness) |
boolean |
equals(java.lang.Object o) |
ListT<W,T> |
filter(java.util.function.Predicate<? super T> test)
Filter the wrapped List
|
ListT<W,T> |
filterNot(java.util.function.Predicate<? super T> predicate)
Remove any elements for which the predicate holds (inverse operation to filter)
e.g.
|
<B> ListT<W,B> |
flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends B>> f) |
<B> ListT<W,B> |
flatMapT(java.util.function.Function<? super T,ListT<W,B>> f)
Flat Map the wrapped List
|
<R1,R> ListT<W,R> |
forEach2M(java.util.function.Function<? super T,? extends ListT<W,R1>> value1,
java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction) |
<R1,R> ListT<W,R> |
forEach2M(java.util.function.Function<? super T,? extends ListT<W,R1>> value1,
java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction,
java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction) |
<T2,R1,R2,R> |
forEach3M(java.util.function.Function<? super T,? extends ListT<W,R1>> value1,
java.util.function.BiFunction<? super T,? super R1,? extends ListT<W,R2>> value2,
Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction) |
<T2,R1,R2,R> |
forEach3M(java.util.function.Function<? super T,? extends ListT<W,R1>> value1,
java.util.function.BiFunction<? super T,? super R1,? extends ListT<W,R2>> value2,
Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction,
Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction) |
<T2,R1,R2,R3,R> |
forEach4M(java.util.function.Function<? super T,? extends ListT<W,R1>> value1,
java.util.function.BiFunction<? super T,? super R1,? extends ListT<W,R2>> value2,
Fn3<? super T,? super R1,? super R2,? extends ListT<W,R3>> value3,
Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction) |
<T2,R1,R2,R3,R> |
forEach4M(java.util.function.Function<? super T,? extends ListT<W,R1>> value1,
java.util.function.BiFunction<? super T,? super R1,? extends ListT<W,R2>> value2,
Fn3<? super T,? super R1,? super R2,? extends ListT<W,R3>> value3,
Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction) |
static <W extends WitnessType<W>,A> |
fromAnyM(AnyM<W,A> anyM)
|
static <A> ListT<Witness.list,A> |
fromList(java.util.List<? extends IndexedSequenceX<A>> nested) |
static <A> ListT<Witness.maybe,A> |
fromMaybe(Maybe<? extends IndexedSequenceX<A>> nested) |
static <A> ListT<Witness.optional,A> |
fromOptional(java.util.Optional<? extends IndexedSequenceX<A>> nested) |
static <A> ListT<Witness.set,A> |
fromSet(java.util.Set<? extends IndexedSequenceX<A>> nested) |
static <A> ListT<Witness.reactiveSeq,A> |
fromStream(ReactiveSeq<? extends IndexedSequenceX<A>> nested) |
static <A> ListT<Witness.stream,A> |
fromStream(java.util.stream.Stream<? extends IndexedSequenceX<A>> nested) |
<K> ListT<W,org.jooq.lambda.tuple.Tuple2<K,ReactiveSeq<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> ListT<W,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
|
ListT<W,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 toX created by the
supplied factory
|
ListT<W,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.
|
ListT<W,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
|
ListT<W,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() |
ListT<W,T> |
insertAt(int pos,
T... values)
Insert data into a reactiveStream at given position
|
ListT<W,T> |
insertAtS(int pos,
java.util.stream.Stream<T> stream)
Insert a Stream into the middle of this reactiveStream at the specified position
|
ListT<W,T> |
intersperse(T value)
Returns a reactiveStream with a given value interspersed between any two values
of this reactiveStream.
|
boolean |
isSeqPresent() |
java.util.Iterator<T> |
iterator() |
ListT<W,T> |
limit(long num)
assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3)); |
ListT<W,T> |
limitLast(int num)
Limit results to the last x elements in a SequenceM
|
ListT<W,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.
|
ListT<W,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> ListT<W,B> |
map(java.util.function.Function<? super T,? extends B> f)
Map the wrapped List
|
AnyM<W,? extends CyclopsCollectable<T>> |
nestedCollectables() |
AnyM<W,? extends FoldableTraversable<T>> |
nestedFoldables() |
ListT<W,T> |
notNull()
Filter elements retaining only values which are not null
|
static <W extends WitnessType<W>,A> |
of(AnyM<W,? extends IndexedSequenceX<A>> monads)
Construct an ListT from an AnyM that wraps a monad containing Lists
|
static <W extends WitnessType<W>,A> |
ofList(AnyM<W,? extends java.util.List<A>> monads) |
<U> ListT<W,U> |
ofType(java.lang.Class<? extends U> type)
Keep only those elements in a reactiveStream that are of a given type.
|
ListT<W,T> |
onEmpty(T value)
If this Container instance is zero, create a new instance containing the provided value
|
ListT<W,T> |
onEmptyGet(java.util.function.Supplier<? extends T> supplier)
If this Container instance is zero, 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 zero, throw the exception returned by the provided Supplier
|
ListT<W,T> |
peek(java.util.function.Consumer<? super T> peek)
Peek at the current value of the List
|
ListT<W,T> |
prepend(T... values)
Prepend given values to the skip of the Stream
|
ListT<W,T> |
prepend(T value) |
ListT<W,T> |
prependS(java.util.stream.Stream<? extends T> stream)
Prepend Stream to this ReactiveSeq
|
<EX extends java.lang.Throwable> |
recover(java.lang.Class<EX> exceptionClass,
java.util.function.Function<? super EX,? extends T> fn)
Recover from a particular exception type
|
ListT<W,T> |
recover(java.util.function.Function<? super java.lang.Throwable,? extends T> fn)
Recover from an exception with an alternative value
|
ListT<W,T> |
removeAll(T... values)
Remove all supplied elements from this filterable
|
ListT<W,T> |
removeAllI(java.lang.Iterable<? extends T> it)
Remove all elements in the supplied Iterable from this filterable
|
ListT<W,T> |
removeAllS(java.util.stream.Stream<? extends T> stream)
Remove all elements in the supplied Stream from this filterable
|
ListT<W,T> |
retainAll(T... values)
Retain only the supplied elements in the returned Filters
|
ListT<W,T> |
retainAllI(java.lang.Iterable<? extends T> it)
Retain only the supplied elements in the returned Filters
|
ListT<W,T> |
retainAllS(java.util.stream.Stream<? extends T> stream)
Retain only the supplied elements in the returned Filters
|
<R> ListT<W,R> |
retry(java.util.function.Function<? super T,? extends R> fn)
Retry a transformation if it fails.
|
<R> ListT<W,R> |
retry(java.util.function.Function<? super T,? extends R> fn,
int retries,
long delay,
java.util.concurrent.TimeUnit timeUnit)
Retry a transformation if it fails.
|
ListT<W,T> |
reverse()
Potentially efficient Stream reversal.
|
ListT<W,T> |
scanLeft(Monoid<T> monoid)
Scan left using supplied Monoid
|
<U> ListT<W,U> |
scanLeft(U seed,
java.util.function.BiFunction<? super U,? super T,? extends U> function)
Scan left
|
ListT<W,T> |
scanRight(Monoid<T> monoid)
Scan right
|
<U> ListT<W,U> |
scanRight(U identity,
java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
Scan right
|
ListT<W,T> |
shuffle() |
ListT<W,T> |
shuffle(java.util.Random random) |
ListT<W,T> |
skip(long num)
assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); |
ListT<W,T> |
skipLast(int num)
assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2)
.collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(1,2,3)));
|
ListT<W,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
|
ListT<W,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 *
|
ListT<W,T> |
slice(long from,
long to) |
ListT<W,VectorX<T>> |
sliding(int windowSize)
Create a sliding view over this Sequence
|
ListT<W,VectorX<T>> |
sliding(int windowSize,
int increment)
Create a sliding view over this Sequence
|
ListT<W,T> |
sorted()
assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); |
ListT<W,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() |
ListT<W,T> |
take(long num)
assertThat(ReactiveSeq.of(4,3,6,7).take(2).toList(),equalTo(Arrays.asList(4,3)); |
ListT<W,T> |
takeRight(int num)
Generate a new Traversable that takes the specified number elements from the take of this Traversable
|
ListT<W,T> |
takeUntil(java.util.function.Predicate<? super T> p)
Generate a new Traversable that takes elements from this Traversable until the predicate holds
|
ListT<W,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() |
AnyM<W,? extends FoldableTraversable<T>> |
transformerStream() |
<T> ListT<W,T> |
unit(T unit) |
<T> ListT<W,T> |
unitAnyM(AnyM<W,Traversable<T>> traversable) |
<R> ListT<W,R> |
unitIterator(java.util.Iterator<R> it)
Create an IterableFunctor instance of the same type from an Iterator
|
AnyM<W,IndexedSequenceX<T>> |
unwrap()
Unwrap a wrapped value
|
<R> R |
unwrapTo(java.util.function.Function<? super AnyM<W,IndexedSequenceX<T>>,? extends R> fn) |
ListT<W,T> |
zip(java.util.function.BinaryOperator<Zippable<T>> combiner,
Zippable<T> app)
Combine two applicatives together using the provided BinaryOperator (Semigroup, Monoid and Reducer all
extend BinaryOperator - checkout SemigroupK and Monoids for a large number of canned combinations).
|
<U> ListT<W,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> ListT<W,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
|
<S,U> ListT<W,org.jooq.lambda.tuple.Tuple3<T,S,U>> |
zip3(java.lang.Iterable<? extends S> second,
java.lang.Iterable<? extends U> third)
zip 3 Streams into one
|
<S,U,R> ListT<W,R> |
zip3(java.lang.Iterable<? extends S> second,
java.lang.Iterable<? extends U> third,
Fn3<? super T,? super S,? super U,? extends R> fn3) |
<T2,T3,T4> ListT<W,org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> |
zip4(java.lang.Iterable<? extends T2> second,
java.lang.Iterable<? extends T3> third,
java.lang.Iterable<? extends T4> fourth)
zip 4 Streams into 1
|
<T2,T3,T4,R> |
zip4(java.lang.Iterable<? extends T2> second,
java.lang.Iterable<? extends T3> third,
java.lang.Iterable<? extends T4> fourth,
Fn4<? super T,? super T2,? super T3,? super T4,? extends R> fn) |
<T2,R> ListT<W,R> |
zipP(org.reactivestreams.Publisher<? extends T2> publisher,
java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
|
<U> ListT<W,org.jooq.lambda.tuple.Tuple2<T,U>> |
zipP(org.reactivestreams.Publisher<? extends U> other) |
<U> ListT<W,org.jooq.lambda.tuple.Tuple2<T,U>> |
zipS(java.util.stream.Stream<? extends U> other)
Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2
|
<U,R> ListT<W,R> |
zipS(java.util.stream.Stream<? extends U> other,
java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
|
<R> ListT<W,R> |
zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn) |
ListT<W,org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> |
zipWithIndex()
Add an index to the current Stream
|
<R> ListT<W,R> |
zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn) |
<R> ListT<W,R> |
zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn) |
clone, finalize, getClass, notify, notifyAll, wait, wait, wait
headAndTail, visit
subscribe, to, trampoline
unwrapIfInstance, unwrapNested
mapToDouble, mapToInt, mapToLong, traversable
groupedStatefullyUntilT, groupedT, groupedUntilT, groupedWhileT, slidingT, slidingT
fixedDelay, onePer, xPer
endsWith, endsWithIterable, findFirst, firstValue, foldRight, foldRight, foldRight, foldRightMapToType, forEach, forEach, get, groupBy, join, join, join, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleUnsafe, startsWith, startsWithIterable, toNested
futureStream, getStreamable, isEmpty, jdkStream, reactiveSeq, reveresedJDKStream, reveresedStream
allMatch, anyMatch, collect, collect, futureT, listT, noneMatch, toListOfLists, toNestedListX, toNestedSetX, toSetOfSets
public AnyM<W,IndexedSequenceX<T>> unwrap()
Unwrapable
unwrap
in interface Unwrapable
public <R> R unwrapTo(java.util.function.Function<? super AnyM<W,IndexedSequenceX<T>>,? extends R> fn)
public ListT<W,T> peek(java.util.function.Consumer<? super T> peek)
ListT.of(AnyM.fromStream(Arrays.asList(10))
.peek(System.out::println);
//prints 10
peek
in interface TransformerSeq<W extends WitnessType<W>,T>
peek
in interface Transformable<T>
peek
- Consumer to accept current value of Listpublic ListT<W,T> filter(java.util.function.Predicate<? super T> test)
ListT.of(AnyM.fromStream(Arrays.asList(10,11))
.filter(t->t!=10);
//ListT<AnyM<Stream<List[11]>>>
public <B> ListT<W,B> map(java.util.function.Function<? super T,? extends B> f)
ListT.of(AnyM.fromStream(Arrays.asList(10))
.map(t->t=t+1);
//ListT<AnyM<Stream<List[11]>>>
map
in interface FilterableTransformable<T>
map
in interface Transformable<T>
f
- Mapping function for the wrapped Listpublic <B> ListT<W,B> flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends B>> f)
flatMap
in interface FoldableTransformerSeq<W extends WitnessType<W>,T>
public <B> ListT<W,B> flatMapT(java.util.function.Function<? super T,ListT<W,B>> f)
ListT.of(AnyM.fromStream(Arrays.asList(10))
.flatMap(t->List.zero();
//ListT<AnyM<Stream<List.zero>>>
f
- FlatMap functionpublic static <W extends WitnessType<W>,A> ListT<W,A> fromAnyM(AnyM<W,A> anyM)
anyM
- AnyM that doesn't contain a monad wrapping an Listpublic static <W extends WitnessType<W>,A> ListT<W,A> of(AnyM<W,? extends IndexedSequenceX<A>> monads)
monads
- AnyM that contains a monad wrapping an Listpublic static <W extends WitnessType<W>,A> ListT<W,A> ofList(AnyM<W,? extends java.util.List<A>> monads)
public static <A> ListT<Witness.stream,A> fromStream(java.util.stream.Stream<? extends IndexedSequenceX<A>> nested)
public static <A> ListT<Witness.reactiveSeq,A> fromStream(ReactiveSeq<? extends IndexedSequenceX<A>> nested)
public static <A> ListT<Witness.optional,A> fromOptional(java.util.Optional<? extends IndexedSequenceX<A>> nested)
public static <A> ListT<Witness.maybe,A> fromMaybe(Maybe<? extends IndexedSequenceX<A>> nested)
public static <A> ListT<Witness.list,A> fromList(java.util.List<? extends IndexedSequenceX<A>> nested)
public static <A> ListT<Witness.set,A> fromSet(java.util.Set<? extends IndexedSequenceX<A>> nested)
public java.lang.String toString()
toString
in class java.lang.Object
public ReactiveSeq<T> stream()
stream
in interface FoldableTransformerSeq<W extends WitnessType<W>,T>
stream
in interface TransformerSeq<W extends WitnessType<W>,T>
stream
in interface TransformerTraversable<T>
stream
in interface ToStream<T>
stream
in interface Sequential<T>
stream
in interface Traversable<T>
public java.util.Iterator<T> iterator()
iterator
in interface java.lang.Iterable<T>
public <R> ListT<W,R> unitIterator(java.util.Iterator<R> it)
Traversable
ReactiveSeq<Integer> newSeq = seq.unitIterable(myIterator);
unitIterator
in interface FoldableTransformerSeq<W extends WitnessType<W>,T>
unitIterator
in interface Traversable<T>
it
- Iterator to create new IterableFunctor frompublic <R> ListT<W,R> empty()
empty
in interface FoldableTransformerSeq<W extends WitnessType<W>,T>
public AnyM<W,? extends FoldableTraversable<T>> nestedFoldables()
nestedFoldables
in interface NestedFoldable<W extends WitnessType<W>,T>
public AnyM<W,? extends CyclopsCollectable<T>> nestedCollectables()
nestedCollectables
in interface NestedCollectable<W extends WitnessType<W>,T>
public <T> ListT<W,T> unitAnyM(AnyM<W,Traversable<T>> traversable)
unitAnyM
in interface TransformerSeq<W extends WitnessType<W>,T>
public AnyM<W,? extends FoldableTraversable<T>> transformerStream()
transformerStream
in interface TransformerSeq<W extends WitnessType<W>,T>
public static <W extends WitnessType<W>,T> ListT<W,T> emptyList(W witness)
public boolean isSeqPresent()
isSeqPresent
in interface TransformerSeq<W extends WitnessType<W>,T>
public ListT<W,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),SemigroupK.intSum)
.listX()
//ListX(3,4)
combine
in interface TransformerSeq<W extends WitnessType<W>,T>
combine
in interface Traversable<T>
predicate
- Test to see if two neighbours should be joined. The first parameter to the bi-predicate is the currently
accumulated result and the second is the next elementop
- BinaryOperator to combine neighbourspublic ListT<W,T> combine(Monoid<T> op, java.util.function.BiPredicate<? super T,? super T> predicate)
Traversable
ReactiveSeq.of(1,1,2,3)
.combine(Monoids.intMult,(a, b)->a.equals(b))
.listX()
//ListX(1)
Simalar to @see Traversable.combine(BiPredicate, BinaryOperator)
but differs in that the first comparison is always to the Monoid zero
This allows us to terminate with just a single valuecombine
in interface TransformerSeq<W extends WitnessType<W>,T>
combine
in interface Traversable<T>
op
- Monoid to combine neighbourspredicate
- Test to see if two neighbours should be joined. The first parameter to the bi-predicate is the currently
accumulated result and the second is the next elementpublic ListT<W,T> cycle(long times)
Traversable
ReactiveSeq.of(1,2,2)
.cycle(3)
.collect(CyclopsCollectors.toList());
//List[1,2,2,1,2,2,1,2,2]
cycle
in interface TransformerSeq<W extends WitnessType<W>,T>
cycle
in interface Traversable<T>
times
- Times values should be repeated within a Streampublic ListT<W,T> cycle(Monoid<T> m, long times)
Traversable
List<Integer> list = ReactiveSeq.of(1,2,2))
.cycle(Reducers.toCountInt(),3)
.collect(CyclopsCollectors.toList());
//List[3,3,3];
cycle
in interface TransformerSeq<W extends WitnessType<W>,T>
cycle
in interface Traversable<T>
m
- Monoid to be used in reductiontimes
- Number of times value should be repeatedpublic ListT<W,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(CyclopsCollectors.toList());
// List(1,2,2,1,2,2)
cycleWhile
in interface TransformerSeq<W extends WitnessType<W>,T>
cycleWhile
in interface Traversable<T>
predicate
- repeat while truepublic ListT<W,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(CyclopsCollectors.toList());
//List[1,2,2,1,2,2,1]
cycleUntil
in interface TransformerSeq<W extends WitnessType<W>,T>
cycleUntil
in interface Traversable<T>
predicate
- repeat while truepublic <U,R> ListT<W,R> zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zippable
zip
in interface TransformerSeq<W extends WitnessType<W>,T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- to zip withzipper
- Zip functionpublic <U,R> ListT<W,R> zipS(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zippable
zipS
in interface TransformerSeq<W extends WitnessType<W>,T>
zipS
in interface Traversable<T>
zipS
in interface Zippable<T>
other
- Stream to combine withzipper
- Zip / combining functionpublic <U> ListT<W,org.jooq.lambda.tuple.Tuple2<T,U>> zipS(java.util.stream.Stream<? extends U> other)
Traversable
zipS
in interface TransformerSeq<W extends WitnessType<W>,T>
zipS
in interface Traversable<T>
zipS
in interface Zippable<T>
other
- Stream to combine withpublic <U> ListT<W,org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
Zippable
zip
in interface TransformerSeq<W extends WitnessType<W>,T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- Iterable to combine withpublic <S,U> ListT<W,org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? 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(CyclopsCollectors.toList());
// [[1,100,'a'],[2,200,'b'],[3,300,'c']]
zip3
in interface TransformerSeq<W extends WitnessType<W>,T>
zip3
in interface Traversable<T>
zip3
in interface Zippable<T>
public <T2,T3,T4> ListT<W,org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth)
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(CyclopsCollectors.toList());
// [[1,100,'a',"hello"],[2,200,'b',"world"]]
zip4
in interface TransformerSeq<W extends WitnessType<W>,T>
zip4
in interface Traversable<T>
zip4
in interface Zippable<T>
public ListT<W,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<W extends WitnessType<W>,T>
zipWithIndex
in interface Traversable<T>
public ListT<W,VectorX<T>> sliding(int windowSize)
Traversable
List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(2).collect(CyclopsCollectors.toList());
assertThat(list.get(0), hasItems(1, 2));
assertThat(list.get(1), hasItems(2, 3));
sliding
in interface TransformerSeq<W extends WitnessType<W>,T>
sliding
in interface Traversable<T>
windowSize
- Size of sliding windowpublic ListT<W,VectorX<T>> sliding(int windowSize, int increment)
Traversable
List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(3, 2).collect(CyclopsCollectors.toList());
assertThat(list.get(0), hasItems(1, 2, 3));
assertThat(list.get(1), hasItems(3, 4, 5));
sliding
in interface TransformerSeq<W extends WitnessType<W>,T>
sliding
in interface Traversable<T>
windowSize
- number of elements in each batchincrement
- for each windowpublic <C extends java.util.Collection<? super T>> ListT<W,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<W extends WitnessType<W>,T>
grouped
in interface Traversable<T>
size
- batch sizesupplier
- Collection factorypublic ListT<W,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<W extends WitnessType<W>,T>
groupedUntil
in interface Traversable<T>
predicate
- Batch until predicate holds, applyHKT open next batchpublic ListT<W,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<W extends WitnessType<W>,T>
groupedStatefullyUntil
in interface Traversable<T>
predicate
- Window while truepublic ListT<W,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<W extends WitnessType<W>,T>
groupedWhile
in interface Traversable<T>
predicate
- Batch while predicate holds, applyHKT open next batchpublic <C extends java.util.Collection<? super T>> ListT<W,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<W extends WitnessType<W>,T>
groupedWhile
in interface Traversable<T>
predicate
- Batch while predicate holds, applyHKT open next batchfactory
- Collection factorypublic <C extends java.util.Collection<? super T>> ListT<W,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<W extends WitnessType<W>,T>
groupedUntil
in interface Traversable<T>
predicate
- Batch until predicate holds, applyHKT open next batchfactory
- Collection factorypublic ListT<W,ListX<T>> grouped(int groupSize)
Traversable
List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).grouped(3).collect(CyclopsCollectors.toList());
assertThat(list.get(0), hasItems(1, 2, 3));
assertThat(list.get(1), hasItems(4, 5, 6));
grouped
in interface TransformerSeq<W extends WitnessType<W>,T>
grouped
in interface Traversable<T>
groupSize
- Size of each Grouppublic <K,A,D> ListT<W,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<W extends WitnessType<W>,T>
grouped
in interface Traversable<T>
classifier
- Grouping functiondownstream
- Collector to create the grouping toXpublic <K> ListT<W,org.jooq.lambda.tuple.Tuple2<K,ReactiveSeq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)
Traversable
grouped
in interface TransformerSeq<W extends WitnessType<W>,T>
grouped
in interface Traversable<T>
classifier
- Grouping functionpublic ListT<W,T> distinct()
distinct
in interface TransformerSeq<W extends WitnessType<W>,T>
distinct
in interface Traversable<T>
public ListT<W,T> scanLeft(Monoid<T> monoid)
Traversable
assertEquals(asList("", "a", "ab", "abc"),ReactiveSeq.of("a", "b", "c")
.scanLeft(Reducers.toString("")).toList());
scanLeft
in interface TransformerSeq<W extends WitnessType<W>,T>
scanLeft
in interface Traversable<T>
public <U> ListT<W,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<W extends WitnessType<W>,T>
scanLeft
in interface Traversable<T>
public ListT<W,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<W extends WitnessType<W>,T>
scanRight
in interface Traversable<T>
public <U> ListT<W,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<W extends WitnessType<W>,T>
scanRight
in interface Traversable<T>
public ListT<W,T> sorted()
Traversable
assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));
sorted
in interface TransformerSeq<W extends WitnessType<W>,T>
sorted
in interface Traversable<T>
public ListT<W,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<W extends WitnessType<W>,T>
sorted
in interface Traversable<T>
c
- Compartor to sort withpublic ListT<W,T> takeWhile(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).takeWhile(i<3);
//[1,2]
takeWhile
in interface TransformerSeq<W extends WitnessType<W>,T>
takeWhile
in interface Traversable<T>
p
- Predicate to determine when values should be takenpublic ListT<W,T> dropWhile(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).dropWhile(i<3);
//[3]
dropWhile
in interface TransformerSeq<W extends WitnessType<W>,T>
dropWhile
in interface Traversable<T>
p
- Predicate to determine when values should be droppedpublic ListT<W,T> takeUntil(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).takeUntil(i<2);
//[1,2]
takeUntil
in interface TransformerSeq<W extends WitnessType<W>,T>
takeUntil
in interface Traversable<T>
p
- Predicate to determine when values should be taken untilpublic ListT<W,T> dropUntil(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).dropUntil(i>2);
//[3]
dropUntil
in interface TransformerSeq<W extends WitnessType<W>,T>
dropUntil
in interface Traversable<T>
p
- Predicate to determine when values should be droppedpublic ListT<W,T> dropRight(int num)
Traversable
ListX.of(1,2,3).dropRight(2);
//[1]
dropRight
in interface TransformerSeq<W extends WitnessType<W>,T>
dropRight
in interface Traversable<T>
num
- Drop this number of elements from the take of this Traversablepublic ListT<W,T> takeRight(int num)
Traversable
ListX.of(1,2,3).takeRight(2);
//[2,3]
takeRight
in interface TransformerSeq<W extends WitnessType<W>,T>
takeRight
in interface Traversable<T>
num
- Take this number of elements from the take of this Traversablepublic ListT<W,T> skip(long num)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));
skip
in interface TransformerSeq<W extends WitnessType<W>,T>
skip
in interface Traversable<T>
num
- Number of elemenets to skippublic ListT<W,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<W extends WitnessType<W>,T>
skipWhile
in interface Traversable<T>
p
- Predicate to skip while truepublic ListT<W,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<W extends WitnessType<W>,T>
skipUntil
in interface Traversable<T>
p
- Predicate to skip until truepublic ListT<W,T> limit(long num)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
limit
in interface TransformerSeq<W extends WitnessType<W>,T>
limit
in interface Traversable<T>
num
- Limit element size to numpublic ListT<W,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<W extends WitnessType<W>,T>
limitWhile
in interface Traversable<T>
p
- Limit while predicate is truepublic ListT<W,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<W extends WitnessType<W>,T>
limitUntil
in interface Traversable<T>
p
- Limit until predicate is truepublic ListT<W,T> intersperse(T value)
Traversable
intersperse
in interface TransformerSeq<W extends WitnessType<W>,T>
intersperse
in interface Traversable<T>
public ListT<W,T> reverse()
Traversable
assertThat( of(1, 2, 3).reverse().toList(),
equalTo(asList(3, 2, 1)));
reverse
in interface TransformerSeq<W extends WitnessType<W>,T>
reverse
in interface Traversable<T>
public ListT<W,T> shuffle()
shuffle
in interface TransformerSeq<W extends WitnessType<W>,T>
shuffle
in interface Traversable<T>
public ListT<W,T> skipLast(int num)
Traversable
skipLast
in interface TransformerSeq<W extends WitnessType<W>,T>
skipLast
in interface Traversable<T>
public ListT<W,T> limitLast(int num)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5)
.limitLast(2)
.collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(4,5)));
limitLast
in interface TransformerSeq<W extends WitnessType<W>,T>
limitLast
in interface Traversable<T>
num
- of elements to return (last elements)public ListT<W,T> onEmpty(T value)
OnEmpty
onEmpty
in interface TransformerSeq<W extends WitnessType<W>,T>
onEmpty
in interface OnEmpty<T>
onEmpty
in interface Traversable<T>
public ListT<W,T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
OnEmpty
onEmptyGet
in interface TransformerSeq<W extends WitnessType<W>,T>
onEmptyGet
in interface OnEmpty<T>
onEmptyGet
in interface Traversable<T>
supplier
- to determine new value for containerpublic <X extends java.lang.Throwable> ListT<W,T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
OnEmpty
onEmptyThrow
in interface TransformerSeq<W extends WitnessType<W>,T>
onEmptyThrow
in interface OnEmpty<T>
onEmptyThrow
in interface Traversable<T>
supplier
- to create exception frompublic ListT<W,T> shuffle(java.util.Random random)
shuffle
in interface TransformerSeq<W extends WitnessType<W>,T>
shuffle
in interface Traversable<T>
public ListT<W,T> slice(long from, long to)
slice
in interface TransformerSeq<W extends WitnessType<W>,T>
slice
in interface Traversable<T>
public <U extends java.lang.Comparable<? super U>> ListT<W,T> sorted(java.util.function.Function<? super T,? extends U> function)
sorted
in interface TransformerSeq<W extends WitnessType<W>,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
public <T2,R1,R2,R3,R> ListT<W,R> forEach4M(java.util.function.Function<? super T,? extends ListT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends ListT<W,R2>> value2, Fn3<? super T,? super R1,? super R2,? extends ListT<W,R3>> value3, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
public <T2,R1,R2,R3,R> ListT<W,R> forEach4M(java.util.function.Function<? super T,? extends ListT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends ListT<W,R2>> value2, Fn3<? super T,? super R1,? super R2,? extends ListT<W,R3>> value3, Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
public <T2,R1,R2,R> ListT<W,R> forEach3M(java.util.function.Function<? super T,? extends ListT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends ListT<W,R2>> value2, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
public <T2,R1,R2,R> ListT<W,R> forEach3M(java.util.function.Function<? super T,? extends ListT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends ListT<W,R2>> value2, Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
public <R1,R> ListT<W,R> forEach2M(java.util.function.Function<? super T,? extends ListT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
public <R1,R> ListT<W,R> forEach2M(java.util.function.Function<? super T,? extends ListT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
public ListT<W,T> prependS(java.util.stream.Stream<? extends T> stream)
Traversable
List<String> result = ReactiveSeq.of(1, 2, 3)
.prependS(of(100, 200, 300))
.map(it -> it + "!!")
.collect(CyclopsCollectors.toList());
assertThat(result, equalTo(Arrays.asList("100!!", "200!!", "300!!", "1!!", "2!!", "3!!")));
prependS
in interface TransformerSeq<W extends WitnessType<W>,T>
prependS
in interface Traversable<T>
stream
- to Prependpublic ListT<W,T> append(T... values)
Traversable
List<String> result = ReactiveSeq.of(1, 2, 3).append(100, 200, 300).map(it -> it + "!!").collect(CyclopsCollectors.toList());
assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "3!!", "100!!", "200!!", "300!!"))); *
append
in interface TransformerSeq<W extends WitnessType<W>,T>
append
in interface Traversable<T>
values
- to appendpublic ListT<W,T> append(T value)
append
in interface TransformerSeq<W extends WitnessType<W>,T>
append
in interface Traversable<T>
public ListT<W,T> prepend(T value)
prepend
in interface TransformerSeq<W extends WitnessType<W>,T>
prepend
in interface Traversable<T>
public ListT<W,T> prepend(T... values)
Traversable
List<String> result = ReactiveSeq.of(1,2,3)
.prepend(100,200,300)
.map(it ->it+"!!")
.collect(CyclopsCollectors.toList());
assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
prepend
in interface TransformerSeq<W extends WitnessType<W>,T>
prepend
in interface Traversable<T>
values
- to prependpublic ListT<W,T> insertAt(int pos, T... values)
Traversable
List<String> result = ReactiveSeq.of(1, 2, 3).insertAt(1, 100, 200, 300).map(it -> it + "!!").collect(CyclopsCollectors.toList());
assertThat(result, equalTo(Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!"))); *
insertAt
in interface TransformerSeq<W extends WitnessType<W>,T>
insertAt
in interface Traversable<T>
pos
- to insert data atvalues
- to insertpublic ListT<W,T> deleteBetween(int start, int end)
Traversable
List<String> result = ReactiveSeq.of(1, 2, 3, 4, 5, 6).deleteBetween(2, 4).map(it -> it + "!!").collect(CyclopsCollectors.toList());
assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "5!!", "6!!"))); *
deleteBetween
in interface TransformerSeq<W extends WitnessType<W>,T>
deleteBetween
in interface Traversable<T>
start
- indexend
- indexpublic ListT<W,T> insertAtS(int pos, java.util.stream.Stream<T> stream)
Traversable
List<String> result = ReactiveSeq.of(1, 2, 3).insertAtS(1, of(100, 200, 300)).map(it -> it + "!!").collect(CyclopsCollectors.toList());
assertThat(result, equalTo(Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!")));
insertAtS
in interface TransformerSeq<W extends WitnessType<W>,T>
insertAtS
in interface Traversable<T>
pos
- to insert Stream atstream
- to insertpublic ListT<W,T> zip(java.util.function.BinaryOperator<Zippable<T>> combiner, Zippable<T> app)
Zippable
zip
in interface TransformerSeq<W extends WitnessType<W>,T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
Semigroup
,
Semigroups
,
Monoid
,
To lift any Semigroup (or monoid) up to handling Applicatives use the combineApplicatives operator in SemigroupK
{@see com.aol.cyclops2.SemigroupK#combineApplicatives(BiFunction) } or Monoids
{ {@see com.aol.cyclops2.Monoids#combineApplicatives(java.util.function.Function, com.aol.cyclops2.function.Monoid)
}
{@code
BinaryOperator> sumMaybes = SemigroupK.combineScalarFunctors(SemigroupK.intSum);
Maybe.just(1).zip(sumMaybes, Maybe.just(5))
//Maybe.just(6));
}
public <R> ListT<W,R> zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn)
zipWith
in interface TransformerSeq<W extends WitnessType<W>,T>
zipWith
in interface Traversable<T>
zipWith
in interface Zippable<T>
public <R> ListT<W,R> zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn)
zipWithS
in interface TransformerSeq<W extends WitnessType<W>,T>
zipWithS
in interface Traversable<T>
zipWithS
in interface Zippable<T>
public <R> ListT<W,R> zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn)
zipWithP
in interface TransformerSeq<W extends WitnessType<W>,T>
zipWithP
in interface Traversable<T>
zipWithP
in interface Zippable<T>
public <T2,R> ListT<W,R> zipP(org.reactivestreams.Publisher<? extends T2> publisher, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
Zippable
zipP
in interface TransformerSeq<W extends WitnessType<W>,T>
zipP
in interface Traversable<T>
zipP
in interface Zippable<T>
publisher
- to combine withfn
- Zip / combining functionpublic <U> ListT<W,org.jooq.lambda.tuple.Tuple2<T,U>> zipP(org.reactivestreams.Publisher<? extends U> other)
zipP
in interface TransformerSeq<W extends WitnessType<W>,T>
zipP
in interface Traversable<T>
zipP
in interface Zippable<T>
public <S,U,R> ListT<W,R> zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third, Fn3<? super T,? super S,? super U,? extends R> fn3)
zip3
in interface TransformerSeq<W extends WitnessType<W>,T>
zip3
in interface Traversable<T>
zip3
in interface Zippable<T>
public <T2,T3,T4,R> ListT<W,R> zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth, Fn4<? super T,? super T2,? super T3,? super T4,? extends R> fn)
zip4
in interface TransformerSeq<W extends WitnessType<W>,T>
zip4
in interface Traversable<T>
zip4
in interface Zippable<T>
public ListT<W,T> removeAllS(java.util.stream.Stream<? extends T> stream)
IterableFilterable
removeAllS
in interface TransformerSeq<W extends WitnessType<W>,T>
removeAllS
in interface IterableFilterable<T>
stream
- of elements to removepublic <U> ListT<W,U> cast(java.lang.Class<? extends U> type)
Transformable
ClassCastException
.
// ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)cast
in interface TransformerSeq<W extends WitnessType<W>,T>
cast
in interface Transformable<T>
public <U> ListT<W,U> ofType(java.lang.Class<? extends U> type)
Filters
// (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)
ofType
in interface TransformerSeq<W extends WitnessType<W>,T>
ofType
in interface Filters<T>
public ListT<W,T> removeAllI(java.lang.Iterable<? extends T> it)
IterableFilterable
removeAllI
in interface TransformerSeq<W extends WitnessType<W>,T>
removeAllI
in interface IterableFilterable<T>
it
- an Iterable of elements to removepublic ListT<W,T> removeAll(T... values)
IterableFilterable
removeAll
in interface TransformerSeq<W extends WitnessType<W>,T>
removeAll
in interface IterableFilterable<T>
values
- to removepublic ListT<W,T> filterNot(java.util.function.Predicate<? super T> predicate)
Filters
of(1,2,3).filter(i->i>2);
//[1,2]
filterNot
in interface TransformerSeq<W extends WitnessType<W>,T>
filterNot
in interface Filters<T>
predicate
- to filter elements by, retaining matchespublic ListT<W,T> retainAllI(java.lang.Iterable<? extends T> it)
IterableFilterable
retainAllI
in interface TransformerSeq<W extends WitnessType<W>,T>
retainAllI
in interface IterableFilterable<T>
it
- Iterable of elements to retainpublic ListT<W,T> notNull()
Filters
of(1,2,null,4).nonNull();
//[1,2,4]
notNull
in interface TransformerSeq<W extends WitnessType<W>,T>
notNull
in interface Filters<T>
public ListT<W,T> retainAllS(java.util.stream.Stream<? extends T> stream)
IterableFilterable
retainAllS
in interface TransformerSeq<W extends WitnessType<W>,T>
retainAllS
in interface IterableFilterable<T>
stream
- of elements to retainpublic ListT<W,T> retainAll(T... values)
IterableFilterable
retainAll
in interface TransformerSeq<W extends WitnessType<W>,T>
retainAll
in interface IterableFilterable<T>
values
- elements to retainpublic <R> ListT<W,R> retry(java.util.function.Function<? super T,? extends R> fn)
Transformable
given(serviceMock.applyHKT(anyInt())).willThrow(
new RuntimeException(new SocketException("First")),
new RuntimeException(new IOException("Second"))).willReturn(
"42");
String result = ReactiveSeq.of( 1, 2, 3)
.retry(serviceMock)
.firstValue();
//result = 42
retry
in interface TransformerSeq<W extends WitnessType<W>,T>
retry
in interface Transformable<T>
fn
- Function to retry if failspublic <R> ListT<W,R> retry(java.util.function.Function<? super T,? extends R> fn, int retries, long delay, java.util.concurrent.TimeUnit timeUnit)
Transformable
given(serviceMock.applyHKT(anyInt())).willThrow(
new RuntimeException(new SocketException("First")),
new RuntimeException(new IOException("Second"))).willReturn(
"42");
String result = ReactiveSeq.of( 1, 2, 3)
.retry(serviceMock, 7, 2, TimeUnit.SECONDS)
.firstValue();
//result = 42
retry
in interface TransformerSeq<W extends WitnessType<W>,T>
retry
in interface Transformable<T>
fn
- Function to retry if failsretries
- Number of retriesdelay
- Delay in TimeUnitstimeUnit
- TimeUnit to use for delaypublic ListT<W,T> drop(long num)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7)));
drop
in interface TransformerSeq<W extends WitnessType<W>,T>
drop
in interface Traversable<T>
num
- Number of elemenets to droppublic ListT<W,T> take(long num)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).take(2).toList(),equalTo(Arrays.asList(4,3));
take
in interface TransformerSeq<W extends WitnessType<W>,T>
take
in interface Traversable<T>
num
- Limit element size to numpublic ListT<W,T> recover(java.util.function.Function<? super java.lang.Throwable,? extends T> fn)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4)
.map(i->i+2)
.map(u->{throw new RuntimeException();})
.recover(e->"hello")
.firstValue(),equalTo("hello"));
recover
in interface TransformerSeq<W extends WitnessType<W>,T>
recover
in interface Traversable<T>
fn
- Function that accepts a Throwable and returns an alternative
valuepublic <EX extends java.lang.Throwable> ListT<W,T> recover(java.lang.Class<EX> exceptionClass, java.util.function.Function<? super EX,? extends T> fn)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4)
.map(i->i+2)
.map(u->{ExceptionSoftener.throwSoftenedException( new IOException()); return null;})
.recover(IOException.class,e->"hello")
.firstValue(),equalTo("hello"));
recover
in interface TransformerSeq<W extends WitnessType<W>,T>
recover
in interface Traversable<T>
exceptionClass
- Type to recover fromfn
- That accepts an error and returns an alternative value