ReactiveSeq (simple-react 1.0.0-RC4 API)

All Superinterfaces:

java.lang.AutoCloseable, java.util.stream.BaseStream<T,java.util.stream.Stream<T>>, org.jooq.lambda.Collectable<T>, ConvertableSequence<T>, CyclopsCollectable<T>, ExtendedTraversable<T>, Filterable<T>, FilterableFunctor<T>, Foldable<T>, Functor<T>, java.lang.Iterable<T>, IterableFilterable<T>, IterableFoldable<T>, IterableFunctor<T>, JoolManipulation<T>, JoolWindowing<T>, org.reactivestreams.Publisher<T>, ReactiveStreamsTerminalOperations<T>, org.jooq.lambda.Seq<T>, java.util.stream.Stream<T>, TransformerTraversable<T>, Traversable<T>, Unit<T>, Unwrapable, ZippingApplicativable<T>

All Known Subinterfaces:

LazyFutureStream

All Known Implementing Classes:

LazyFutureStreamImpl, ReactiveSeqImpl
```
public interface ReactiveSeq<T>
extends Unwrapable, java.util.stream.Stream<T>, JoolManipulation<T>, IterableFilterable<T>, FilterableFunctor<T>, ExtendedTraversable<T>, IterableFoldable<T>, CyclopsCollectable<T>, JoolWindowing<T>, org.jooq.lambda.Seq<T>, java.lang.Iterable<T>, org.reactivestreams.Publisher<T>, ReactiveStreamsTerminalOperations<T>, ZippingApplicativable<T>, Unit<T>, ConvertableSequence<T>
```

Nested Class Summary
- Nested classes/interfaces inherited from interface java.util.stream.Stream
 java.util.stream.Stream.Builder<T>

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`boolean`	`allMatch(java.util.function.Predicate<? super T> c)` True if predicate matches all elements when Monad converted to a Stream
`AnyMSeq<T>`	`anyM()`
`boolean`	`anyMatch(java.util.function.Predicate<? super T> c)` True if a single element matches when Monad converted to a Stream
`default <R> ZippingApplicativable<R>`	`ap1(java.util.function.Function<? super T,? extends R> fn)`
`ReactiveSeq<T>`	`append(T... values)` Append values to the end of this ReactiveSeq
`ReactiveSeq<T>`	`append(T value)`
`ReactiveSeq<T>`	`appendStream(java.util.stream.Stream<T> stream)` Append Stream to this ReactiveSeq
`default <R> ApplyingZippingApplicativeBuilder<T,R,ZippingApplicativable<R>>`	`applicatives()`
`default java.util.Optional<T>`	`avg()`
`default <U> java.util.Optional<U>`	`avg(java.util.function.Function<? super T,? extends U> function)`
`default double`	`avgDouble(java.util.function.ToDoubleFunction<? super T> function)`
`default double`	`avgInt(java.util.function.ToIntFunction<? super T> function)`
`default double`	`avgLong(java.util.function.ToLongFunction<? super T> function)`
`<U> ReactiveSeq<U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`default <R,A> R`	`collect(java.util.stream.Collector<? super T,A,R> collector)`
`default org.jooq.lambda.Collectable<T>`	`collectable()` Narrow this class to a Collectable
`default ReactiveSeq<ReactiveSeq<T>>`	`combinations()` `ReactiveSeq.of(1,2,3).combinations() //ReactiveSeq[ReactiveSeq[],ReactiveSeq[1],ReactiveSeq[2],ReactiveSeq[3].ReactiveSeq[1,2],ReactiveSeq[1,3],ReactiveSeq[2,3] ,ReactiveSeq[1,2,3]]`
`default ReactiveSeq<ReactiveSeq<T>>`	`combinations(int size)` `ReactiveSeq.of(1,2,3).combinations(2) //ReactiveSeq[ReactiveSeq[1,2],ReactiveSeq[1,3],ReactiveSeq[2,3]]`
`default ReactiveSeq<T>`	`combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)` Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping & reduction operation.
`ReactiveSeq<T>`	`concat(java.util.stream.Stream<? extends T> other)`
`ReactiveSeq<T>`	`concat(T... other)`
`ReactiveSeq<T>`	`concat(T other)`
`default long`	`count()`
`default long`	`count(java.util.function.Predicate<? super T> predicate)`
`default long`	`countDistinct()`
`default long`	`countDistinct(java.util.function.Predicate<? super T> predicate)`
`default <U> long`	`countDistinctBy(java.util.function.Function<? super T,? extends U> function)`
`default <U> long`	`countDistinctBy(java.util.function.Function<? super T,? extends U> function, java.util.function.Predicate<? super U> predicate)`
`default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`crossJoin(java.lang.Iterable<? extends U> other)`
`default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`crossJoin(org.jooq.lambda.Seq<? extends U> other)`
`default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`crossJoin(java.util.stream.Stream<? extends U> other)`
`ReactiveSeq<T>`	`cycle()` Convert to a Stream with the values infinitely cycled
`ReactiveSeq<T>`	`cycle(int times)` Convert to a Stream with the values repeated specified times
`ReactiveSeq<T>`	`cycle(Monoid<T> m, int times)` Convert to a Stream with the result of a reduction operation repeated specified times
`ReactiveSeq<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream until specified predicate holds
`ReactiveSeq<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream while specified predicate holds
`ReactiveSeq<T>`	`debounce(long time, java.util.concurrent.TimeUnit t)` Allow one element through per time period, drop all other elements in that time period
`ReactiveSeq<T>`	`deleteBetween(int start, int end)` Delete elements between given indexes in a Stream
`ReactiveSeq<T>`	`distinct()`
`<U> ReactiveSeq<T>`	`distinct(java.util.function.Function<? super T,? extends U> keyExtractor)`
`default ReactiveSeq<T>`	`dropRight(int num)`
`default ReactiveSeq<T>`	`dropUntil(java.util.function.Predicate<? super T> p)`
`default ReactiveSeq<T>`	`dropWhile(java.util.function.Predicate<? super T> p)`
`org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>`	`duplicateSequence()` Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
`default ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>`	`elapsed()` `ReactiveSeq.of(1,2,3,4,5) .elapsed() .forEach(System.out::println);`
`default org.jooq.lambda.tuple.Tuple2<T,ReactiveSeq<T>>`	`elementAt(long index)` Gets the element at index, and returns a Tuple containing the element (it must be present) and a lazy copy of the Sequence for further processing.
`static <T> ReactiveSeq<T>`	`empty()`
`boolean`	`endsWith(java.util.stream.Stream<T> stream)` `assertTrue(ReactiveSeq.of(1,2,3,4,5,6) .endsWith(Stream.of(5,6)));`
`boolean`	`endsWithIterable(java.lang.Iterable<T> iterable)` `assertTrue(ReactiveSeq.of(1,2,3,4,5,6) .endsWith(Arrays.asList(5,6)));`
`ReactiveSeq<T>`	`filter(java.util.function.Predicate<? super T> fn)` Keep only elements for which the supplied predicates hold e.g.
`java.util.Optional<T>`	`findAny()`
`java.util.Optional<T>`	`findFirst()`
`T`	`firstValue()` `assertThat(ReactiveSeq.of(1,2,3,4) .map(u->{throw new RuntimeException();}) .recover(e->"hello") .firstValue(),equalTo("hello"));`
`ReactiveSeq<T>`	`fixedDelay(long l, java.util.concurrent.TimeUnit unit)` emit elements after a fixed delay
`<R> ReactiveSeq<R>`	`flatMap(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)` flatMap operation
`<R> ReactiveSeq<R>`	`flatMapAnyM(java.util.function.Function<? super T,AnyM<? extends R>> fn)` Allows flatMap return type to be any Monad type
`<R> ReactiveSeq<R>`	`flatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)` FlatMap where the result is a Collection, flattens the resultant collections into the host ReactiveSeq
`<R> ReactiveSeq<R>`	`flatMapStream(java.util.function.Function<? super T,java.util.stream.BaseStream<? extends R,?>> fn)` flatMap operation
`<T1> ReactiveSeq<T1>`	`flatten()` join / flatten one level of a nested hierarchy
`T`	`foldRight(Monoid<T> reducer)` `ReactiveSeq.of("a","b","c").foldRight(Reducers.toString("")); // "cab"`
`T`	`foldRight(T identity, java.util.function.BinaryOperator<T> accumulator)` Immutable reduction from right to left
`default <U> U`	`foldRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> accumulator)`
`<T> T`	`foldRightMapToType(Reducer<T> reducer)` Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
`<R1,R> ReactiveSeq<R>`	`forEach2(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)` Perform a two level nested internal iteration over this Stream and the supplied stream
`<R1,R> ReactiveSeq<R>`	`forEach2(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Boolean>> filterFunction, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)` Perform a two level nested internal iteration over this Stream and the supplied stream
`<R1,R2,R> ReactiveSeq<R>`	`forEach3(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends java.util.stream.BaseStream<R2,?>>> stream2, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)` Perform a three level nested internal iteration over this Stream and the supplied streams
`<R1,R2,R> ReactiveSeq<R>`	forEach3(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends java.util.stream.BaseStream<R2,?>>> stream2, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,java.lang.Boolean>>> filterFunction, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction) Perform a three level nested internal iteration over this Stream and the supplied streams
`static ReactiveSeq<java.lang.Double>`	`fromDoubleStream(java.util.stream.DoubleStream stream)` Construct a ReactiveSeq from a Stream
`static ReactiveSeq<java.lang.Integer>`	`fromIntStream(java.util.stream.IntStream stream)` Construct a ReactiveSeq from a Stream
`static <T> ReactiveSeq<T>`	`fromIterable(java.lang.Iterable<T> iterable)` Construct a ReactiveSeq from an Iterable
`static <T> ReactiveSeq<T>`	`fromIterator(java.util.Iterator<T> iterator)` Construct a ReactiveSeq from an Iterator
`static <T> ReactiveSeq<T>`	`fromList(java.util.List<T> list)` Construct a ReactiveSeq from a List (prefer this method if the source is a list, as it allows more efficient Stream reversal).
`static ReactiveSeq<java.lang.Long>`	`fromLongStream(java.util.stream.LongStream stream)` Construct a ReactiveSeq from a Stream
`static <T> ReactiveSeq<T>`	`fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)` Construct a ReactiveSeq from an Publisher
`static <T> ReactiveSeq<T>`	`fromStream(java.util.stream.Stream<T> stream)` Construct a ReactiveSeq from a Stream
`FutureOperations<T>`	`futureOperations(java.util.concurrent.Executor exec)` Access asynchronous terminal operations (each returns a Future)
`static <T> ReactiveSeq<T>`	`generate(java.util.function.Supplier<T> s)`
`default java.util.Optional<T>`	`get(long index)` Return the elementAt index or Optional.empty
`default <K> MapX<K,java.util.List<T>>`	`groupBy(java.util.function.Function<? super T,? extends K> classifier)` Use classifier function to group elements in this Sequence into a Map
`default <K> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>>`	`grouped(java.util.function.Function<? super T,? extends K> classifier)`
`default <K,A,D> ReactiveSeq<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)`
`ReactiveSeq<ListX<T>>`	`grouped(int groupSize)` Group elements in a Stream
`<C extends java.util.Collection<? super T>> ReactiveSeq<C>`	`grouped(int size, java.util.function.Supplier<C> supplier)` Batch elements in a Stream by size into a collection created by the supplied factory
`ReactiveSeq<ListX<T>>`	`groupedBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit t)` Batch elements by size into a List
`<C extends java.util.Collection<? super T>> ReactiveSeq<C>`	`groupedBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory)` Batch elements by size into a collection created by the supplied factory
`ReactiveSeq<ListX<T>>`	`groupedByTime(long time, java.util.concurrent.TimeUnit t)` Batch elements in a Stream by time period
`<C extends java.util.Collection<? super T>> ReactiveSeq<C>`	`groupedByTime(long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory)` Batch elements by time into a collection created by the supplied factory
`ReactiveSeq<ListX<T>>`	`groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)` Create ReactiveSeq of ListX where each ListX is populated while the supplied bipredicate holds.
`ReactiveSeq<ListX<T>>`	`groupedUntil(java.util.function.Predicate<? super T> predicate)` Create a ReactiveSeq batched by List, where each batch is populated until the predicate holds
`<C extends java.util.Collection<? super T>> ReactiveSeq<C>`	`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
`ReactiveSeq<ListX<T>>`	`groupedWhile(java.util.function.Predicate<? super T> predicate)` Create a ReactiveSeq batched by List, where each batch is populated while the predicate holds
`<C extends java.util.Collection<? super T>> ReactiveSeq<C>`	`groupedWhile(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 while the predicate holds
`HeadAndTail<T>`	`headAndTail()` extract head and tail together, where head is expected to be present
`HotStream<T>`	`hotStream(java.util.concurrent.Executor e)` Turns this ReactiveSeq into a HotStream, a connectable Stream, being executed on a thread on the supplied executor, that is producing data.
`default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`innerJoin(java.lang.Iterable<? extends U> other, java.util.function.BiPredicate<? super T,? super U> predicate)`
`default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`innerJoin(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiPredicate<? super T,? super U> predicate)`
`default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`innerJoin(java.util.stream.Stream<? extends U> other, java.util.function.BiPredicate<? super T,? super U> predicate)`
`default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`innerJoin(Streamable<? extends U> other, java.util.function.BiPredicate<? super T,? super U> predicate)`
`ReactiveSeq<T>`	`insertAt(int pos, T... values)` Insert data into a stream at given position
`ReactiveSeq<T>`	`insertStreamAt(int pos, java.util.stream.Stream<T> stream)` Insert a Stream into the middle of this stream at the specified position
`ReactiveSeq<T>`	`intersperse(T value)` Returns a stream with a given value interspersed between any two values of this stream.
`static <T> ReactiveSeq<T>`	`iterate(T seed, java.util.function.UnaryOperator<T> f)`
`ReactiveSeq<T>`	`jitter(long maxJitterPeriodInNanos)` Introduce a random jitter / time delay between the emission of elements
`java.lang.String`	`join()` `assertEquals("123".length(),ReactiveSeq.of(1, 2, 3).join().length());`
`java.lang.String`	`join(java.lang.String sep)` `assertEquals("1, 2, 3".length(), ReactiveSeq.of(1, 2, 3).join(", ").length());`
`java.lang.String`	`join(java.lang.String sep, java.lang.String start, java.lang.String end)` `assertEquals("^1\|2\|3$".length(), of(1, 2, 3).join("\|", "^", "$").length());`
`default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`leftOuterJoin(java.lang.Iterable<? extends U> other, java.util.function.BiPredicate<? super T,? super U> predicate)`
`default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`leftOuterJoin(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiPredicate<? super T,? super U> predicate)`
`default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`leftOuterJoin(java.util.stream.Stream<? extends U> other, java.util.function.BiPredicate<? super T,? super U> predicate)`
`default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`leftOuterJoin(Streamable<? extends U> s, java.util.function.BiPredicate<? super T,? super U> predicate)`
`ReactiveSeq<T>`	`limit(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`ReactiveSeq<T>`	`limit(long time, java.util.concurrent.TimeUnit unit)` Return all elements until specified time period has elapsed
`ReactiveSeq<T>`	`limitLast(int num)` Limit results to the last x elements in a ReactiveSeq
`ReactiveSeq<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.
`default ReactiveSeq<T>`	`limitUntilClosed(java.util.function.Predicate<? super T> p)`
`ReactiveSeq<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
`<R> ReactiveSeq<R>`	`map(java.util.function.Function<? super T,? extends R> fn)` Transform this functor using the supplied transformation function
`<R> R`	`mapReduce(java.util.function.Function<? super T,? extends R> mapper, Monoid<R> reducer)` Attempt to map this Monad to the same type as the supplied Monoid, using supplied function Then use Monoid to reduce values
`<R> R`	`mapReduce(Reducer<R> reducer)` Attempt to map this Sequence to the same type as the supplied Monoid (Reducer) Then use Monoid to reduce values
`default java.util.Optional<T>`	`max()`
`default java.util.Optional<T>`	`max(java.util.Comparator<? super T> comparator)`
`default <U extends java.lang.Comparable<? super U>> java.util.Optional<U>`	`max(java.util.function.Function<? super T,? extends U> function)`
`default <U> java.util.Optional<U>`	`max(java.util.function.Function<? super T,? extends U> function, java.util.Comparator<? super U> comparator)`
`default <U extends java.lang.Comparable<? super U>> java.util.Optional<T>`	`maxBy(java.util.function.Function<? super T,? extends U> function)`
`default <U> java.util.Optional<T>`	`maxBy(java.util.function.Function<? super T,? extends U> function, java.util.Comparator<? super U> comparator)`
`default java.util.Optional<T>`	`median()`
`default java.util.Optional<T>`	`median(java.util.Comparator<? super T> comparator)`
`default <U extends java.lang.Comparable<? super U>> java.util.Optional<T>`	`medianBy(java.util.function.Function<? super T,? extends U> function)`
`default <U> java.util.Optional<T>`	`medianBy(java.util.function.Function<? super T,? extends U> function, java.util.Comparator<? super U> comparator)`
`default java.util.Optional<T>`	`min()`
`default java.util.Optional<T>`	`min(java.util.Comparator<? super T> comparator)`
`default <U extends java.lang.Comparable<? super U>> java.util.Optional<U>`	`min(java.util.function.Function<? super T,? extends U> function)`
`default <U> java.util.Optional<U>`	`min(java.util.function.Function<? super T,? extends U> function, java.util.Comparator<? super U> comparator)`
`default <U extends java.lang.Comparable<? super U>> java.util.Optional<T>`	`minBy(java.util.function.Function<? super T,? extends U> function)`
`default <U> java.util.Optional<T>`	`minBy(java.util.function.Function<? super T,? extends U> function, java.util.Comparator<? super U> comparator)`
`default java.util.Optional<T>`	`mode()`
`boolean`	`noneMatch(java.util.function.Predicate<? super T> c)`
`static <T> ReactiveSeq<T>`	`of(T... elements)` Create an efficiently reversable Sequence from the provided elements
`<U> ReactiveSeq<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`ReactiveSeq<T>`	`onClose(java.lang.Runnable closeHandler)`
`ReactiveSeq<T>`	`onEmpty(T value)`
`ReactiveSeq<T>`	`onEmptyGet(java.util.function.Supplier<? extends T> supplier)`
`default ReactiveSeq<T>`	`onEmptySwitch(java.util.function.Supplier<? extends java.util.stream.Stream<T>> switchTo)` If this ReactiveSeq is empty replace it with a another Stream
`default <X extends java.lang.Throwable> ReactiveSeq<T>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)`
`ReactiveSeq<T>`	`onePer(long time, java.util.concurrent.TimeUnit t)` emit one element per time period
`ReactiveSeq<T>`	`parallel()`
`org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>`	`partitionSequence(java.util.function.Predicate<T> splitter)` Partition a Stream into two one a per element basis, based on predicate's boolean value
`default <R> ReactiveSeq<R>`	`patternMatch(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,R>> case1, java.util.function.Supplier<? extends R> otherwise)` Transform the elements of this Stream with a Pattern Matching case and default value
`PausableHotStream<T>`	`pausableHotStream(java.util.concurrent.Executor e)` Turns this ReactiveSeq into a HotStream, a connectable & pausable Stream, being executed on a thread on the supplied executor, that is producing data.
`ReactiveSeq<T>`	`peek(java.util.function.Consumer<? super T> c)` Peek at the current value of this Functor, without transforming it
`default java.util.Optional<T>`	`percentile(double percentile)`
`default java.util.Optional<T>`	`percentile(double percentile, java.util.Comparator<? super T> comparator)`
`default <U extends java.lang.Comparable<? super U>> java.util.Optional<T>`	`percentileBy(double percentile, java.util.function.Function<? super T,? extends U> function)`
`default <U> java.util.Optional<T>`	`percentileBy(double percentile, java.util.function.Function<? super T,? extends U> function, java.util.Comparator<? super U> comparator)`
`default ReactiveSeq<ReactiveSeq<T>>`	`permutations()` Generate the permutations based on values in the ReactiveSeq Makes use of Streamable to store intermediate stages in a collection
`ReactiveSeq<T>`	`prepend(T... values)` Prepend given values to the start of the Stream
`ReactiveSeq<T>`	`prepend(T value)`
`ReactiveSeq<T>`	`prependStream(java.util.stream.Stream<T> stream)` Prepend Stream to this ReactiveSeq
`HotStream<T>`	`primedHotStream(java.util.concurrent.Executor e)` Return a HotStream that will start emitting data when the first connecting Stream connects.
`PausableHotStream<T>`	`primedPausableHotStream(java.util.concurrent.Executor e)` Return a pausable HotStream that will start emitting data when the first connecting Stream connects.
`default void`	`print(java.io.PrintStream stream)`
`default void`	`print(java.io.PrintWriter writer)`
`default void`	`printErr()`
`default void`	`printOut()`
`org.jooq.lambda.tuple.Tuple4<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>>`	`quadruplicate()` Makes four copies of a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
`static ReactiveSeq<java.lang.Integer>`	`range(int start, int end)` Create an efficiently reversable Sequence that produces the integers between start and end
`static ReactiveSeq<java.lang.Long>`	`rangeLong(long start, long end)` Create an efficiently reversable Sequence that produces the integers between start and end
`<EX extends java.lang.Throwable> ReactiveSeq<T>`	`recover(java.lang.Class<EX> exceptionClass, java.util.function.Function<EX,? extends T> fn)` Recover from a particular exception type
`ReactiveSeq<T>`	`recover(java.util.function.Function<java.lang.Throwable,? extends T> fn)` Recover from an exception with an alternative value
`java.util.Optional<T>`	`reduce(java.util.function.BinaryOperator<T> accumulator)`
`ListX<T>`	`reduce(java.lang.Iterable<? extends Monoid<T>> reducers)` Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first.
`T`	`reduce(Monoid<T> reducer)` `ReactiveSeq.of("hello","2","world","4").reduce(Reducers.toString(",")); //hello,2,world,4`
`ListX<T>`	`reduce(java.util.stream.Stream<? extends Monoid<T>> reducers)` Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first.
`T`	`reduce(T identity, java.util.function.BinaryOperator<T> accumulator)`
`<U> U`	`reduce(U identity, java.util.function.BiFunction<U,? super T,U> accumulator, java.util.function.BinaryOperator<U> combiner)`
`default ReactiveSeq<T>`	`remove(T t)` Remove all occurances of the specified element from the ReactiveSeq
`default <R> ReactiveSeq<R>`	`retry(java.util.function.Function<? super T,? extends R> fn)` Retry a transformation if it fails.
`default <R> ReactiveSeq<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.
`ReactiveSeq<T>`	`reverse()`
`static <T> ReactiveSeq<T>`	`reversedListOf(java.util.List<T> elements)` Construct a Reveresed Sequence from the provided elements Can be reversed (again) efficiently
`static <T> ReactiveSeq<T>`	`reversedOf(T... elements)` Construct a Reveresed Sequence from the provided elements Can be reversed (again) efficiently
`default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`rightOuterJoin(java.lang.Iterable<? extends U> other, java.util.function.BiPredicate<? super T,? super U> predicate)`
`default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`rightOuterJoin(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiPredicate<? super T,? super U> predicate)`
`default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`rightOuterJoin(java.util.stream.Stream<? extends U> other, java.util.function.BiPredicate<? super T,? super U> predicate)`
`ReactiveSeq<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`<U> ReactiveSeq<U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)` Scan left
`ReactiveSeq<T>`	`scanRight(Monoid<T> monoid)` Scan right
`<U> ReactiveSeq<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)` Scan right
`HotStream<T>`	`schedule(java.lang.String cron, java.util.concurrent.ScheduledExecutorService ex)` Execute this Stream on a schedule
`HotStream<T>`	`scheduleFixedDelay(long delay, java.util.concurrent.ScheduledExecutorService ex)` Execute this Stream on a schedule
`HotStream<T>`	`scheduleFixedRate(long rate, java.util.concurrent.ScheduledExecutorService ex)` Execute this Stream on a schedule
`ReactiveSeq<T>`	`sequential()`
`ReactiveSeq<T>`	`shuffle()`
`ReactiveSeq<T>`	`shuffle(java.util.Random random)`
`default T`	`single()` `//1 ReactiveSeq.of(1).single(); //UnsupportedOperationException ReactiveSeq.of().single(); //UnsupportedOperationException ReactiveSeq.of(1,2,3).single();`
`default T`	`single(java.util.function.Predicate<? super T> predicate)`
`default java.util.Optional<T>`	`singleOptional()` `//Optional[1] ReactiveSeq.of(1).singleOptional(); //Optional.empty ReactiveSeq.of().singleOpional(); //Optional.empty ReactiveSeq.of(1,2,3).singleOptional();`
`default int`	`size()` [equivalent to count]
`ReactiveSeq<T>`	`skip(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`ReactiveSeq<T>`	`skip(long time, java.util.concurrent.TimeUnit unit)` Skip all elements until specified time period has passed
`ReactiveSeq<T>`	`skipLast(int num)` assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
`ReactiveSeq<T>`	`skipUntil(java.util.function.Predicate<? super T> p)` Drop elements from the Stream until the predicate returns true, after which all elements are included
`default ReactiveSeq<T>`	`skipUntilClosed(java.util.function.Predicate<? super T> p)`
`ReactiveSeq<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 *
`ReactiveSeq<T>`	`slice(long from, long to)`
`ReactiveSeq<ListX<T>>`	`sliding(int windowSize)` Create a sliding view over this Sequence
`ReactiveSeq<ListX<T>>`	`sliding(int windowSize, int increment)` Create a sliding view over this Sequence
`ReactiveSeq<T>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`ReactiveSeq<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>> ReactiveSeq<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>`	`splitAt(int where)` Split at supplied location
`org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>`	`splitBy(java.util.function.Predicate<T> splitter)` Split stream at point where predicate no longer holds
`org.jooq.lambda.tuple.Tuple2<java.util.Optional<T>,ReactiveSeq<T>>`	`splitSequenceAtHead()` Split a Stream at it's head (similar to headAndTail)
`boolean`	`startsWith(java.util.stream.Stream<T> stream)` `assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Stream.of(1,2,3)))`
`boolean`	`startsWithIterable(java.lang.Iterable<T> iterable)` `assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Arrays.asList(1,2,3)));`
`ReactiveSeq<T>`	`stream()` Convert this ReactiveSeq into a Stream
`static <T> SeqSubscriber<T>`	`subscriber()` Create a subscriber that can listen to Reactive Streams (simple-react, RxJava AkkaStreams, Kontraktor, QuadarStreams etc)
`default ReactiveSeq<T>`	`subStream(int start, int end)` Return a Stream with elements before the provided start index removed, and elements after the provided end index removed
`default java.util.Optional<T>`	`sum()`
`default <U> java.util.Optional<U>`	`sum(java.util.function.Function<? super T,? extends U> function)`
`default double`	`sumDouble(java.util.function.ToDoubleFunction<? super T> function)`
`default int`	`sumInt(java.util.function.ToIntFunction<? super T> function)`
`default long`	`sumLong(java.util.function.ToLongFunction<? super T> function)`
`default ReactiveSeq<T>`	`takeRight(int num)`
`default ReactiveSeq<T>`	`takeUntil(java.util.function.Predicate<? super T> p)`
`default ReactiveSeq<T>`	`takeWhile(java.util.function.Predicate<? super T> p)`
`default ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>`	`timestamp()` `ReactiveSeq.of(1,2,3,4,5) .timestamp() .forEach(System.out::println)`
`<C extends java.util.Collection<T>> C`	`toCollection(java.util.function.Supplier<C> collectionFactory)`
`CollectionX<T>`	`toConcurrentLazyCollection()` Lazily converts this ReactiveSeq into a Collection.
`Streamable<T>`	`toConcurrentLazyStreamable()` { @code Streamable<Integer> repeat = ReactiveSeq.of(1, 2, 3, 4, 5, 6).map(i -> i + 2).toConcurrentLazyStreamable(); assertThat(repeat.sequenceM().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12))); assertThat(repeat.sequenceM().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12))); }
`CollectionX<T>`	`toLazyCollection()` Lazily converts this ReactiveSeq into a Collection.
`java.util.List<T>`	`toList()`
`default <L extends java.util.List<T>> L`	`toList(java.util.function.Supplier<L> factory)`
`default <K,V> java.util.Map<K,V>`	`toMap(java.util.function.Function<? super T,? extends K> keyMapper, java.util.function.Function<? super T,? extends V> valueMapper)`
`java.util.Set<T>`	`toSet()`
`default <S extends java.util.Set<T>> S`	`toSet(java.util.function.Supplier<S> factory)`
`<T> java.util.stream.Stream<T>`	`toStream()` Convert this ReactiveSeq into a Stream
`Streamable<T>`	`toStreamable()` `Streamable<Integer> repeat = ReactiveSeq.of(1,2,3,4,5,6) .map(i->i*2) .toStreamable(); repeat.sequenceM().toList(); //Arrays.asList(2,4,6,8,10,12)); repeat.sequenceM().toList() //Arrays.asList(2,4,6,8,10,12));`
`default java.lang.String`	`toString(java.lang.CharSequence delimiter)`
`default java.lang.String`	`toString(java.lang.CharSequence delimiter, java.lang.CharSequence prefix, java.lang.CharSequence suffix)`
`default <R> ReactiveSeq<R>`	`trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)` Performs a map operation that can call a recursive method without running out of stack space
`org.jooq.lambda.tuple.Tuple3<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>>`	`triplicate()` Triplicates a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
`static <U,T> ReactiveSeq<T>`	`unfold(U seed, java.util.function.Function<? super U,java.util.Optional<org.jooq.lambda.tuple.Tuple2<T,U>>> unfolder)` Unfold a function into a ReactiveSeq
`<T> ReactiveSeq<T>`	`unit(T unit)`
`<T> ReactiveSeq<T>`	`unitIterator(java.util.Iterator<T> it)`
`ReactiveSeq<T>`	`unordered()`
`<R> R`	`unwrap()` Unwrap a wrapped value
`static <T,U> org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<U>>`	`unzip(ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> sequence)` Unzip a zipped Stream
`static <T1,T2,T3> org.jooq.lambda.tuple.Tuple3<ReactiveSeq<T1>,ReactiveSeq<T2>,ReactiveSeq<T3>>`	`unzip3(ReactiveSeq<org.jooq.lambda.tuple.Tuple3<T1,T2,T3>> sequence)` Unzip a zipped Stream into 3
`static <T1,T2,T3,T4> org.jooq.lambda.tuple.Tuple4<ReactiveSeq<T1>,ReactiveSeq<T2>,ReactiveSeq<T3>,ReactiveSeq<T4>>`	`unzip4(ReactiveSeq<org.jooq.lambda.tuple.Tuple4<T1,T2,T3,T4>> sequence)` Unzip a zipped Stream into 4
`boolean`	`xMatch(int num, java.util.function.Predicate<? super T> c)` Check that there are specified number of matches of predicate in the Stream
`ReactiveSeq<T>`	`xPer(int x, long time, java.util.concurrent.TimeUnit t)` emit x elements per time period
`default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.lang.Iterable<? extends U> other)`
`default <U,R> ReactiveSeq<R>`	`zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(org.jooq.lambda.Seq<? extends U> other)` Zip 2 streams into one
`default <U,R> ReactiveSeq<R>`	`zip(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.util.stream.Stream<? extends U> other)` Zip 2 streams into one
`default <U,R> ReactiveSeq<R>`	`zip(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`<S,U> ReactiveSeq<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> ReactiveSeq<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
`<S,R> ReactiveSeq<R>`	`zipStream(java.util.stream.BaseStream<? extends S,? extends java.util.stream.BaseStream<? extends S,?>> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper)` Zip this Monad with a Stream
`default ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>`	`zipWithIndex()` Add an index to the current Stream

Methods inherited from interface com.aol.cyclops.types.stream.JoolManipulation
filterNot, notNull, removeAll, removeAll, removeAll, removeAll, retainAll, retainAll, retainAll, retainAll

Methods inherited from interface com.aol.cyclops.types.TransformerTraversable
groupedStatefullyWhileT, groupedT, groupedUntilT, groupedWhileT, slidingT, slidingT

Methods inherited from interface com.aol.cyclops.types.IterableFoldable
foldable, visit

Methods inherited from interface com.aol.cyclops.types.stream.CyclopsCollectable
bitAnd, bitAnd, bitAndInt, bitAndLong, bitOr, bitOr, bitOrInt, bitOrLong, commonPrefix, commonSuffix, maxAll, maxAll, maxAll, maxAll, maxAllBy, maxAllBy, minAll, minAll, minAll, minAll, minAllBy, minAllBy, modeAll, modeAllBy, modeBy, toMap

Methods inherited from interface com.aol.cyclops.types.stream.JoolWindowing
window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window

Methods inherited from interface org.jooq.lambda.Seq
append, append, append, append, cast, close, concat, concat, concat, concat, concat, concat, concat, contains, containsAll, containsAll, containsAll, containsAll, containsAny, containsAny, containsAny, containsAny, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, cycle, cycle, cycle, cycle, cycle, cycle, cycle, drop, duplicate, duplicate, findFirst, findSingle, flatMapToDouble, flatMapToInt, flatMapToLong, foldLeft, foldLeft, foldLeft, foldLeft, foldRight, foldRight, foldRight, forEach, format, generate, groupBy, groupBy, groupBy, groupBy, groupBy, grouped, grouped, grouped, grouped, grouped, grouped, intersperse, isEmpty, isNotEmpty, join, join, join, join, join, limit, limitUntil, limitUntilClosed, limitWhile, limitWhileClosed, limitWhileClosed, mapToDouble, mapToInt, mapToLong, ofType, partition, partition, prepend, prepend, prepend, prepend, range, range, range, range, range, range, range, range, range, range, range, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, reverse, reverse, reverse, scanLeft, scanLeft, scanLeft, scanRight, scanRight, scanRight, seq, seq, seq, seq, seq, seq, seq, seq, seq, seq, seq, seq, seq, seq, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, skip, skipUntil, skipUntilClosed, skipWhile, skipWhileClosed, skipWhileClosed, slice, sliding, sorted, splitAt, splitAt, splitAtHead, splitAtHead, spliterator, take, toCollection, toList, toMap, toMap, toSet, toString, toString, transform, unzip, unzip, unzip, unzip, unzip, unzip, unzip, unzip, unzip, unzip, unzip, unzip, window, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipWithIndex, zipWithIndex, zipWithIndex

Methods inherited from interface java.util.stream.Stream
builder, collect, concat, forEachOrdered, toArray, toArray

Methods inherited from interface java.util.stream.BaseStream
isParallel, iterator

Methods inherited from interface com.aol.cyclops.types.stream.reactive.ReactiveStreamsTerminalOperations
forEachEvent, forEachWithError, forEachX, forEachXEvents, forEachXWithError

Methods inherited from interface com.aol.cyclops.types.applicative.zipping.ZippingApplicativable
ap2, ap3, ap4, ap5

Methods inherited from interface com.aol.cyclops.types.IterableFunctor
flatMapPublisher, flatMapPublisher, flatMapPublisher, mergePublisher, mergePublisher

Methods inherited from interface com.aol.cyclops.types.Foldable
reduce, validate

Methods inherited from interface com.aol.cyclops.types.Traversable
lazyOperations, traversable

Methods inherited from interface com.aol.cyclops.types.stream.ConvertableSequence
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, toTry, toValue, toValueMap, toValueSet, toXor, toXorSecondary

Methods inherited from interface java.lang.Iterable
iterator

Method Detail

unitIterator
```
<T> ReactiveSeq<T> unitIterator(java.util.Iterator<T> it)
```
Specified by:

unitIterator in interface IterableFunctor<T>

unit
```
<T> ReactiveSeq<T> unit(T unit)
```
Specified by:

unit in interface Unit<T>

foldRight

default <U> U foldRight(U identity,
                        java.util.function.BiFunction<? super T,? super U,? extends U> accumulator)

Specified by:: foldRight in interface Foldable<T>
Specified by:: foldRight in interface org.jooq.lambda.Seq<T>

printOut
```
default void printOut()
```
Specified by:

printOut in interface Foldable<T>

Specified by:

printOut in interface org.jooq.lambda.Seq<T>

applicatives

default <R> ApplyingZippingApplicativeBuilder<T,R,ZippingApplicativable<R>> applicatives()

Specified by:: applicatives in interface ZippingApplicativable<T>

ap1

default <R> ZippingApplicativable<R> ap1(java.util.function.Function<? super T,? extends R> fn)

Specified by:: ap1 in interface ZippingApplicativable<T>

zip

default <U,R> ReactiveSeq<R> zip(java.lang.Iterable<? extends U> other,
                                 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)

Specified by:: zip in interface org.jooq.lambda.Seq<T>
Specified by:: zip in interface Traversable<T>

zip

default <U,R> ReactiveSeq<R> zip(org.jooq.lambda.Seq<? extends U> other,
                                 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)

Specified by:: zip in interface org.jooq.lambda.Seq<T>
Specified by:: zip in interface Traversable<T>

zip

default <U,R> ReactiveSeq<R> zip(java.util.stream.Stream<? extends U> other,
                                 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)

Specified by:: zip in interface org.jooq.lambda.Seq<T>
Specified by:: zip in interface Traversable<T>

unwrap
```
<R> R unwrap()
```
Description copied from interface: Unwrapable

Unwrap a wrapped value

Specified by:

unwrap in interface Unwrapable

Returns:

wrapped value

flatten

<T1> ReactiveSeq<T1> flatten()

join / flatten one level of a nested hierarchy

  
  ReactiveSeq.of(Arrays.asList(1,2)).flatten();
  
  //stream of (1,  2);

Returns:: Flattened / joined one level

cycle
```
ReactiveSeq<T> cycle(int times)
```
Convert to a Stream with the values repeated specified times
```
 
 		ReactiveSeq.of(1,2,2)
 								.cycle(3)
 								.collect(Collectors.toList());
 								
 		//List[1,2,2,1,2,2,1,2,2]
 
 
 
```
Specified by:

cycle in interface Traversable<T>

Parameters:

times - Times values should be repeated within a Stream

Returns:

Stream with values repeated

cycle
```
ReactiveSeq<T> cycle()
```
Convert to a Stream with the values infinitely cycled
```
 
 ReactiveSeq.of(1).cycle().limit(6).toList());
 //List[1, 1, 1, 1, 1,1]
 
 
```
Specified by:

cycle in interface org.jooq.lambda.Seq<T>

Returns:

Stream with values repeated

duplicateSequence

org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> duplicateSequence()

Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.

 {
        @code
        Tuple2<ReactiveSeq<Integer>, ReactiveSeq<Integer>> copies = of(1, 2, 3, 4, 5, 6).duplicate();
        assertTrue(copies.v1.anyMatch(i -> i == 2));
        assertTrue(copies.v2.anyMatch(i -> i == 2));
 
 }

Returns:: duplicated stream

triplicate

org.jooq.lambda.tuple.Tuple3<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>> triplicate()

Triplicates a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.

 {
        @code
        Tuple3<ReactiveSeq<Tuple3<T1, T2, T3>>, ReactiveSeq<Tuple3<T1, T2, T3>>, ReactiveSeq<Tuple3<T1, T2, T3>>> Tuple3 = sequence.triplicate();
 
 }

quadruplicate

org.jooq.lambda.tuple.Tuple4<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>> quadruplicate()

Makes four copies of a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.

 {
        @code
        Tuple4<ReactiveSeq<Tuple4<T1, T2, T3, T4>>, ReactiveSeq<Tuple4<T1, T2, T3, T4>>, ReactiveSeq<Tuple4<T1, T2, T3, T4>>, ReactiveSeq<Tuple4<T1, T2, T3, T4>>> quad = sequence
                        .quadruplicate();
 
 }

Returns:

splitSequenceAtHead

org.jooq.lambda.tuple.Tuple2<java.util.Optional<T>,ReactiveSeq<T>> splitSequenceAtHead()

Split a Stream at it's head (similar to headAndTail)

  
 ReactiveSeq.of(1,2,3).splitAtHead()
 
  //Optional[1], ReactiveSeq[2,3]

splitAt

org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> splitAt(int where)

Split at supplied location

  
 ReactiveSeq.of(1,2,3).splitAt(1)
 
  //ReactiveSeq[1], ReactiveSeq[2,3]

splitBy

org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> splitBy(java.util.function.Predicate<T> splitter)

Split stream at point where predicate no longer holds

 
   ReactiveSeq.of(1, 2, 3, 4, 5, 6).splitBy(i->i<4)
   
   //ReactiveSeq[1,2,3] ReactiveSeq[4,5,6]

partitionSequence

org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> partitionSequence(java.util.function.Predicate<T> splitter)

Partition a Stream into two one a per element basis, based on predicate's boolean value

  
  ReactiveSeq.of(1, 2, 3, 4, 5, 6).partition(i -> i % 2 != 0) 
  
  //ReactiveSeq[1,3,5], ReactiveSeq[2,4,6]

cycle

ReactiveSeq<T> cycle(Monoid<T> m,
                     int times)

Convert to a Stream with the result of a reduction operation repeated specified times

  
   List<Integer> list = ReactiveSeq.of(1,2,2))
                                 .cycle(Reducers.toCountInt(),3)
                                 .collect(Collectors.toList());
   //List[3,3,3];

Specified by:: cycle in interface Traversable<T>
Parameters:: m - Monoid to be used in reduction; times - Number of times value should be repeated
Returns:: Stream with reduced values repeated

cycleWhile

ReactiveSeq<T> cycleWhile(java.util.function.Predicate<? super T> predicate)

Repeat in a Stream while specified predicate holds

 {
        @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)
 }

Specified by:: cycleWhile in interface Traversable<T>
Parameters:: predicate - repeat while true
Returns:: Repeating Stream

cycleUntil

ReactiveSeq<T> cycleUntil(java.util.function.Predicate<? super T> predicate)

Repeat in a Stream until specified predicate holds

  
 	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]

Specified by:: cycleUntil in interface Traversable<T>
Parameters:: predicate - repeat while true
Returns:: Repeating Stream

zip

default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.util.stream.Stream<? extends U> other)

Zip 2 streams into one

 {
        @code
        List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
        // [[1,"a"],[2,"b"]]
 }

Specified by:: zip in interface org.jooq.lambda.Seq<T>
Specified by:: zip in interface Traversable<T>

zip

default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)

Specified by:: zip in interface org.jooq.lambda.Seq<T>
Specified by:: zip in interface Traversable<T>

zip

default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<? extends U> other)

Zip 2 streams into one

 {
        @code
        List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
        // [[1,"a"],[2,"b"]]
 }

Specified by:: zip in interface org.jooq.lambda.Seq<T>
Specified by:: zip in interface Traversable<T>

zip3

<S,U> ReactiveSeq<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

 {
        @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']]
 }

Specified by:: zip3 in interface Traversable<T>

zip4

<T2,T3,T4> ReactiveSeq<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

 {
        @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"]]

Specified by:: zip4 in interface Traversable<T>

zipWithIndex

default ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()

Add an index to the current Stream

  
 assertEquals(asList(new Tuple2("a", 0L), new Tuple2("b", 1L)), of("a", "b").zipWithIndex().toList());

Specified by:: zipWithIndex in interface org.jooq.lambda.Seq<T>
Specified by:: zipWithIndex in interface Traversable<T>

zipStream

<S,R> ReactiveSeq<R> zipStream(java.util.stream.BaseStream<? extends S,? extends java.util.stream.BaseStream<? extends S,?>> second,
                               java.util.function.BiFunction<? super T,? super S,? extends R> zipper)

Zip this Monad with a Stream

 {
        @code
        Stream<List<Integer>> zipped = asMonad(Stream.of(1, 2, 3)).zip(Stream.of(2, 3, 4), (a, b) -> Arrays.asList(a, b));
 
        // [[1,2][2,3][3,4]]
 }

Parameters:: second - Stream to zip with; zipper - Zip funciton
Returns:: This monad zipped with a Stream

sliding

ReactiveSeq<ListX<T>> sliding(int windowSize)

Create a sliding view over this Sequence

 {
        @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));
 
 }

Specified by:: sliding in interface Traversable<T>
Parameters:: windowSize - Size of sliding window
Returns:: ReactiveSeq with sliding view

sliding

ReactiveSeq<ListX<T>> sliding(int windowSize,
                              int increment)

Create a sliding view over this Sequence

 {
        @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));
 
 }

Specified by:: sliding in interface Traversable<T>
Parameters:: windowSize - number of elements in each batch; increment - for each window
Returns:: ReactiveSeq with sliding view

grouped

ReactiveSeq<ListX<T>> grouped(int groupSize)

Group elements in a Stream

 {
        @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));
 
 }

Specified by:: grouped in interface Traversable<T>
Parameters:: groupSize - Size of each Group
Returns:: Stream with elements grouped by size

groupedStatefullyWhile
```
ReactiveSeq<ListX<T>> groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
```
Create ReactiveSeq of ListX where each ListX is populated while the supplied bipredicate holds. The bipredicate recieves the ListX from the last window as well as the current value and can choose to aggregate the current value or create a new window
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .groupedStatefullyWhile((s,i)-> s.contains(4) ? true : false)
 .toList().size(),equalTo(5));
 
 
```
Specified by:

groupedStatefullyWhile in interface Traversable<T>

Parameters:

predicate - Window while true

Returns:

ReactiveSeq windowed while predicate holds

groupedBySizeAndTime

ReactiveSeq<ListX<T>> groupedBySizeAndTime(int size,
                                           long time,
                                           java.util.concurrent.TimeUnit t)

Batch elements by size into a List

 
 ReactiveSeq.of(1,2,3,4,5,6)
              .batchBySizeAndTime(3,10,TimeUnit.SECONDS)
              .toList();
          
 //[[1,2,3],[4,5,6]]

Parameters:: size - Max size of a batch; time - (Max) time period to build a single batch in; t - time unit for batch
Returns:: ReactiveSeq batched by size and time

groupedBySizeAndTime

<C extends java.util.Collection<? super T>> ReactiveSeq<C> groupedBySizeAndTime(int size,
                                                                                long time,
                                                                                java.util.concurrent.TimeUnit unit,
                                                                                java.util.function.Supplier<C> factory)

Batch elements by size into a collection created by the supplied factory

 {
  @code
  List<ArrayList<Integer>> list = of(1, 2, 3, 4, 5, 6).batchBySizeAndTime(10, 1, TimeUnit.MICROSECONDS, () -> new ArrayList<>()).toList();
 }

Parameters:: size - Max size of a batch; time - (Max) time period to build a single batch in; unit - time unit for batch; factory - Collection factory
Returns:: ReactiveSeq batched by size and time

groupedByTime

ReactiveSeq<ListX<T>> groupedByTime(long time,
                                    java.util.concurrent.TimeUnit t)

Batch elements in a Stream by time period

  
 assertThat(ReactiveSeq.of(1,2,3,4,5,6).batchByTime(1,TimeUnit.SECONDS).collect(Collectors.toList()).size(),is(1));
 assertThat(ReactiveSeq.of(1,2,3,4,5,6).batchByTime(1,TimeUnit.NANOSECONDS).collect(Collectors.toList()).size(),greaterThan(5));

Parameters:: time - - time period to build a single batch in; t - time unit for batch
Returns:: ReactiveSeq batched into lists by time period

groupedByTime

<C extends java.util.Collection<? super T>> ReactiveSeq<C> groupedByTime(long time,
                                                                         java.util.concurrent.TimeUnit unit,
                                                                         java.util.function.Supplier<C> factory)

Batch elements by time into a collection created by the supplied factory

  
   assertThat(ReactiveSeq.of(1,1,1,1,1,1)
                       .batchByTime(1500,TimeUnit.MICROSECONDS,()-> new TreeSet<>())
                       .toList()
                       .get(0)
                       .size(),is(1));

Parameters:: time - - time period to build a single batch in; unit - time unit for batch; factory - Collection factory
Returns:: ReactiveSeq batched into collection types by time period

grouped

<C extends java.util.Collection<? super T>> ReactiveSeq<C> grouped(int size,
                                                                   java.util.function.Supplier<C> supplier)

Batch elements in a Stream by size into a collection created by the supplied factory

 
 assertThat(ReactiveSeq.of(1,1,1,1,1,1)
                      .batchBySize(3,()->new TreeSet<>())
                      .toList()
                      .get(0)
                      .size(),is(1));

Specified by:: grouped in interface Traversable<T>
Parameters:: size - batch size; supplier - Collection factory
Returns:: ReactiveSeq batched into collection types by size

groupedUntil
```
ReactiveSeq<ListX<T>> groupedUntil(java.util.function.Predicate<? super T> predicate)
```
Create a ReactiveSeq batched by List, where each batch is populated until the predicate holds
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .batchUntil(i->i%3==0)
 .toList()
 .size(),equalTo(2));
 
 
```
Specified by:

groupedUntil in interface Traversable<T>

Parameters:

predicate - Batch until predicate holds, then open next batch

Returns:

ReactiveSeq batched into lists determined by the predicate supplied

groupedWhile
```
ReactiveSeq<ListX<T>> groupedWhile(java.util.function.Predicate<? super T> predicate)
```
Create a ReactiveSeq batched by List, where each batch is populated while the predicate holds
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .batchWhile(i->i%3!=0)
 .toList().size(),equalTo(2));
 
 
 
```
Specified by:

groupedWhile in interface Traversable<T>

Parameters:

predicate - Batch while predicate holds, then open next batch

Returns:

ReactiveSeq batched into lists determined by the predicate supplied

groupedWhile

<C extends java.util.Collection<? super T>> ReactiveSeq<C> groupedWhile(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 while the predicate holds

  
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
              .batchWhile(i->i%3!=0)
              .toList()
              .size(),equalTo(2));

Specified by:: groupedWhile in interface Traversable<T>
Parameters:: predicate - Batch while predicate holds, then open next batch; factory - Collection factory
Returns:: ReactiveSeq batched into collections determined by the predicate supplied

groupedUntil

<C extends java.util.Collection<? super T>> ReactiveSeq<C> 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

  
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
              .batchUntil(i->i%3!=0)
              .toList()
              .size(),equalTo(2));

Specified by:: groupedUntil in interface Traversable<T>
Parameters:: predicate - Batch until predicate holds, then open next batch; factory - Collection factory
Returns:: ReactiveSeq batched into collections determined by the predicate supplied

grouped

default <K,A,D> ReactiveSeq<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)

Specified by:: grouped in interface org.jooq.lambda.Seq<T>
Specified by:: grouped in interface Traversable<T>

grouped

default <K> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)

Specified by:: grouped in interface org.jooq.lambda.Seq<T>
Specified by:: grouped in interface Traversable<T>

groupBy

default <K> MapX<K,java.util.List<T>> groupBy(java.util.function.Function<? super T,? extends K> classifier)

Use classifier function to group elements in this Sequence into a Map

 {
        @code
        Map<Integer, List<Integer>> map1 = of(1, 2, 3, 4).groupBy(i -> i % 2);
        assertEquals(asList(2, 4), map1.get(0));
        assertEquals(asList(1, 3), map1.get(1));
        assertEquals(2, map1.size());
 
 }

Specified by:: groupBy in interface Foldable<T>
Specified by:: groupBy in interface org.jooq.lambda.Seq<T>

distinct
```
ReactiveSeq<T> distinct()
```
Specified by:

distinct in interface org.jooq.lambda.Seq<T>

Specified by:

distinct in interface java.util.stream.Stream<T>

Specified by:

distinct in interface Traversable<T>

scanLeft

ReactiveSeq<T> scanLeft(Monoid<T> monoid)

Scan left using supplied Monoid

   
 
 	assertEquals(asList("", "a", "ab", "abc"),ReactiveSeq.of("a", "b", "c")
 													.scanLeft(Reducers.toString("")).toList());

Specified by:: scanLeft in interface Traversable<T>
Parameters:: monoid -
Returns:

scanLeft

<U> ReactiveSeq<U> scanLeft(U seed,
                            java.util.function.BiFunction<? super U,? super T,? extends U> function)

Scan left

  
  assertThat(of("a", "b", "c").scanLeft("", String::concat).toList().size(),
         		is(4));

Specified by:: scanLeft in interface org.jooq.lambda.Seq<T>
Specified by:: scanLeft in interface Traversable<T>

scanRight

ReactiveSeq<T> scanRight(Monoid<T> monoid)

Scan right

  
 assertThat(of("a", "b", "c").scanRight(Monoid.of("", String::concat)).toList().size(),
             is(asList("", "c", "bc", "abc").size()));

Specified by:: scanRight in interface Traversable<T>

scanRight

<U> ReactiveSeq<U> scanRight(U identity,
                             java.util.function.BiFunction<? super T,? super U,? extends U> combiner)

Scan right

  
 assertThat(of("a", "ab", "abc").map(str->str.length()).scanRight(0, (t, u) -> u + t).toList().size(),
             is(asList(0, 3, 5, 6).size()));

Specified by:: scanRight in interface org.jooq.lambda.Seq<T>
Specified by:: scanRight in interface Traversable<T>

sorted
```
ReactiveSeq<T> sorted()
```
```
 assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); 
 
```
Specified by:

sorted in interface org.jooq.lambda.Seq<T>

Specified by:

sorted in interface java.util.stream.Stream<T>

Specified by:

sorted in interface Traversable<T>

combine
```
default ReactiveSeq<T> combine(java.util.function.BiPredicate<? super T,? super T> predicate,
 java.util.function.BinaryOperator<T> op)
```
Description copied from interface: Traversable
Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping & reduction operation. The output of a combination may in turn be combined with it's neighbour
```
 
 ReactiveSeq.of(1,1,2,3)
 .combine((a, b)->a.equals(b),Semigroups.intSum)
 .toListX()
 
 //ListX(3,4) 
 
```
Specified by:

combine in interface Traversable<T>

Parameters:

predicate - Test to see if two neighbours should be joined

op - Reducer to combine neighbours

Returns:

Combined / Partially Reduced Traversable

sorted
```
ReactiveSeq<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)));
 
 
```
Specified by:

sorted in interface org.jooq.lambda.Seq<T>

Specified by:

sorted in interface java.util.stream.Stream<T>

Specified by:

sorted in interface Traversable<T>

Parameters:

c - Compartor to sort with

Returns:

Sorted Stream

takeWhile

default ReactiveSeq<T> takeWhile(java.util.function.Predicate<? super T> p)

Specified by:: takeWhile in interface Traversable<T>

dropWhile

default ReactiveSeq<T> dropWhile(java.util.function.Predicate<? super T> p)

Specified by:: dropWhile in interface Traversable<T>

takeUntil

default ReactiveSeq<T> takeUntil(java.util.function.Predicate<? super T> p)

Specified by:: takeUntil in interface Traversable<T>

dropUntil

default ReactiveSeq<T> dropUntil(java.util.function.Predicate<? super T> p)

Specified by:: dropUntil in interface Traversable<T>

dropRight
```
default ReactiveSeq<T> dropRight(int num)
```
Specified by:

dropRight in interface Traversable<T>

takeRight
```
default ReactiveSeq<T> takeRight(int num)
```
Specified by:

takeRight in interface Traversable<T>

skip
```
ReactiveSeq<T> skip(long num)
```
```
 assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); 
 
```
Specified by:

skip in interface org.jooq.lambda.Seq<T>

Specified by:

skip in interface java.util.stream.Stream<T>

Specified by:

skip in interface Traversable<T>

Parameters:

num - Number of elemenets to skip

Returns:

Stream with specified number of elements skipped

skipWhile
```
ReactiveSeq<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 *
```
 
 assertThat(ReactiveSeq.of(4,3,6,7).sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));
 
 
```
Specified by:

skipWhile in interface org.jooq.lambda.Seq<T>

Specified by:

skipWhile in interface Traversable<T>

Parameters:

p - Predicate to skip while true

Returns:

Stream with elements skipped while predicate holds

skipUntil
```
ReactiveSeq<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
```
 assertThat(ReactiveSeq.of(4,3,6,7).skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));
 
```
Specified by:

skipUntil in interface org.jooq.lambda.Seq<T>

Specified by:

skipUntil in interface Traversable<T>

Parameters:

p - Predicate to skip until true

Returns:

Stream with elements skipped until predicate holds

skipUntilClosed

default ReactiveSeq<T> skipUntilClosed(java.util.function.Predicate<? super T> p)

Specified by:: skipUntilClosed in interface org.jooq.lambda.Seq<T>

limit
```
ReactiveSeq<T> limit(long num)
```
```
 assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
 
```
Specified by:

limit in interface org.jooq.lambda.Seq<T>

Specified by:

limit in interface java.util.stream.Stream<T>

Specified by:

limit in interface Traversable<T>

Parameters:

num - Limit element size to num

Returns:

Monad converted to Stream with elements up to num

limitWhile
```
ReactiveSeq<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
```
 assertThat(ReactiveSeq.of(4,3,6,7).sorted().limitWhile(i->i<6).toList(),equalTo(Arrays.asList(3,4)));
 
```
Specified by:

limitWhile in interface org.jooq.lambda.Seq<T>

Specified by:

limitWhile in interface Traversable<T>

Parameters:

p - Limit while predicate is true

Returns:

Stream with limited elements

limitUntil
```
ReactiveSeq<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.
```
 assertThat(ReactiveSeq.of(4,3,6,7).limitUntil(i->i==6).toList(),equalTo(Arrays.asList(4,3))); 
 
```
Specified by:

limitUntil in interface org.jooq.lambda.Seq<T>

Specified by:

limitUntil in interface Traversable<T>

Parameters:

p - Limit until predicate is true

Returns:

Stream with limited elements

limitUntilClosed

default ReactiveSeq<T> limitUntilClosed(java.util.function.Predicate<? super T> p)

Specified by:: limitUntilClosed in interface org.jooq.lambda.Seq<T>

parallel
```
ReactiveSeq<T> parallel()
```
Specified by:

parallel in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>

Specified by:

parallel in interface org.jooq.lambda.Seq<T>

Returns:

Does nothing ReactiveSeq is for Sequential Streams

allMatch
```
boolean allMatch(java.util.function.Predicate<? super T> c)
```
True if predicate matches all elements when Monad converted to a Stream
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5).allMatch(it-> it>0 && it <6),equalTo(true));
 
 
```
Specified by:

allMatch in interface org.jooq.lambda.Collectable<T>

Specified by:

allMatch in interface CyclopsCollectable<T>

Specified by:

allMatch in interface java.util.stream.Stream<T>

Parameters:

c - Predicate to check if all match

anyMatch
```
boolean anyMatch(java.util.function.Predicate<? super T> c)
```
True if a single element matches when Monad converted to a Stream
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5).anyMatch(it-> it.equals(3)),equalTo(true));
 
 
```
Specified by:

anyMatch in interface org.jooq.lambda.Collectable<T>

Specified by:

anyMatch in interface CyclopsCollectable<T>

Specified by:

anyMatch in interface java.util.stream.Stream<T>

Parameters:

c - Predicate to check if any match

xMatch

boolean xMatch(int num,
               java.util.function.Predicate<? super T> c)

Check that there are specified number of matches of predicate in the Stream

  
  assertTrue(ReactiveSeq.of(1,2,3,5,6,7).xMatch(3, i-> i>4 ));

Specified by:: xMatch in interface Foldable<T>

noneMatch
```
boolean noneMatch(java.util.function.Predicate<? super T> c)
```
Specified by:

noneMatch in interface org.jooq.lambda.Collectable<T>

Specified by:

noneMatch in interface CyclopsCollectable<T>

Specified by:

noneMatch in interface java.util.stream.Stream<T>

join
```
java.lang.String join()
```
```
 
 assertEquals("123".length(),ReactiveSeq.of(1, 2, 3).join().length());
 
 
```
Specified by:

join in interface Foldable<T>

Specified by:

join in interface org.jooq.lambda.Seq<T>

Returns:

Stream as concatenated String

join

java.lang.String join(java.lang.String sep)

 
 assertEquals("1, 2, 3".length(), ReactiveSeq.of(1, 2, 3).join(", ").length());

Specified by:: join in interface Foldable<T>
Returns:: Stream as concatenated String

join

java.lang.String join(java.lang.String sep,
                      java.lang.String start,
                      java.lang.String end)

  
 assertEquals("^1|2|3$".length(), of(1, 2, 3).join("|", "^", "$").length());

Specified by:: join in interface Foldable<T>
Returns:: Stream as concatenated String

headAndTail

HeadAndTail<T> headAndTail()

extract head and tail together, where head is expected to be present

 {
        @code
        ReactiveSeq<String> helloWorld = ReactiveSeq.of("hello", "world", "last");
        HeadAndTail<String> headAndTail = helloWorld.headAndTail();
        String head = headAndTail.head();
        assertThat(head, equalTo("hello"));
 
        ReactiveSeq<String> tail = headAndTail.tail();
        assertThat(tail.headAndTail().head(), equalTo("world"));
 }

Specified by:: headAndTail in interface IterableFoldable<T>
Returns:

findFirst
```
java.util.Optional<T> findFirst()
```
Specified by:

findFirst in interface Foldable<T>

Specified by:

findFirst in interface java.util.stream.Stream<T>

Returns:
First matching element in sequential order
```
 
 ReactiveSeq.of(1,2,3,4,5).filter(it -> it <3).findFirst().get();
 
 //3
 
 
```
(deterministic)

findAny
```
java.util.Optional<T> findAny()
```
Specified by:

findAny in interface Foldable<T>

Specified by:

findAny in interface java.util.stream.Stream<T>

Returns:
first matching element, but order is not guaranteed
```
 
 ReactiveSeq.of(1,2,3,4,5).filter(it -> it <3).findAny().get();
 
 //3
 
 
```
(non-deterministic)

trampoline

default <R> ReactiveSeq<R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)

Performs a map operation that can call a recursive method without running out of stack space

 
 ReactiveSeq.of(10,20,30,40)
				 .trampoline(i-> fibonacci(i))
				 .forEach(System.out::println); 
				 
		Trampoline<Long> fibonacci(int i){
			return fibonacci(i,1,0);
		}
		Trampoline<Long> fibonacci(int n, long a, long b) {
	    	return n == 0 ? Trampoline.done(b) : Trampoline.more( ()->fibonacci(n-1, a+b, a));
		}		 
				 
 55
		6765
		832040
		102334155
 
 
 ReactiveSeq.of(10_000,200_000,3_000_000,40_000_000)
				 .trampoline(i-> fibonacci(i))
				 .forEach(System.out::println);
				 
				 
 completes successfully

Specified by:: trampoline in interface Functor<T>
Parameters:: mapper -
Returns:

mapReduce
```
<R> R mapReduce(Reducer<R> reducer)
```
Attempt to map this Sequence to the same type as the supplied Monoid (Reducer) Then use Monoid to reduce values
```
 
 ReactiveSeq.of("hello","2","world","4").mapReduce(Reducers.toCountInt());
 
 //4
 
 
```
Specified by:

mapReduce in interface Foldable<T>

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

mapReduce

<R> R mapReduce(java.util.function.Function<? super T,? extends R> mapper,
                Monoid<R> reducer)

Attempt to map this Monad to the same type as the supplied Monoid, using supplied function Then use Monoid to reduce values

  
  ReactiveSeq.of("one","two","three","four")
           .mapReduce(this::toInt,Reducers.toTotalInt());
  
  //10
  
  int toInt(String s){
 		if("one".equals(s))
 			return 1;
 		if("two".equals(s))
 			return 2;
 		if("three".equals(s))
 			return 3;
 		if("four".equals(s))
 			return 4;
 		return -1;
 	   }

Specified by:: mapReduce in interface Foldable<T>
Parameters:: mapper - Function to map Monad type; reducer - Monoid to reduce values
Returns:: Reduce result

reduce

T reduce(Monoid<T> reducer)

  
 ReactiveSeq.of("hello","2","world","4").reduce(Reducers.toString(","));
 
 //hello,2,world,4

Specified by:: reduce in interface Foldable<T>
Parameters:: reducer - Use supplied Monoid to reduce values
Returns:: reduced values

reduce
```
java.util.Optional<T> reduce(java.util.function.BinaryOperator<T> accumulator)
```
Specified by:

reduce in interface Foldable<T>

Specified by:

reduce in interface java.util.stream.Stream<T>

reduce
```
T reduce(T identity,
 java.util.function.BinaryOperator<T> accumulator)
```
Specified by:

reduce in interface Foldable<T>

Specified by:

reduce in interface java.util.stream.Stream<T>

reduce

<U> U reduce(U identity,
             java.util.function.BiFunction<U,? super T,U> accumulator,
             java.util.function.BinaryOperator<U> combiner)

Specified by:: reduce in interface Foldable<T>
Specified by:: reduce in interface java.util.stream.Stream<T>

reduce

ListX<T> reduce(java.util.stream.Stream<? extends Monoid<T>> reducers)

Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first. I.e. streamedMonad().reduce(reducer)

 {
        @code
        Monoid<Integer> sum = Monoid.of(0, (a, b) -> a + b);
        Monoid<Integer> mult = Monoid.of(1, (a, b) -> a * b);
        List<Integer> result = ReactiveSeq.of(1, 2, 3, 4).reduce(Arrays.asList(sum, mult).stream());
 
        assertThat(result, equalTo(Arrays.asList(10, 24)));
 
 }

Specified by:: reduce in interface Foldable<T>
Parameters:: reducers -
Returns:

reduce
```
ListX<T> reduce(java.lang.Iterable<? extends Monoid<T>> reducers)
```
Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first. I.e. streamedMonad().reduce(reducer)
```
 
 Monoid<Integer> sum = Monoid.of(0,(a,b)->a+b);
 		Monoid<Integer> mult = Monoid.of(1,(a,b)->a*b);
 		List<Integer> result = ReactiveSeq.of(1,2,3,4))
 										.reduce(Arrays.asList(sum,mult) );
 				
 		 
 		assertThat(result,equalTo(Arrays.asList(10,24)));
 
 
```
Specified by:

reduce in interface Foldable<T>

Parameters:

reducers -

Returns:

foldRight

T foldRight(Monoid<T> reducer)

                
 		ReactiveSeq.of("a","b","c").foldRight(Reducers.toString(""));
        
         // "cab"

Specified by:: foldRight in interface Foldable<T>
Parameters:: reducer - Use supplied Monoid to reduce values starting via foldRight
Returns:: Reduced result

foldRight

T foldRight(T identity,
            java.util.function.BinaryOperator<T> accumulator)

Immutable reduction from right to left

  
  assertTrue(ReactiveSeq.of("a","b","c").foldRight("", String::concat).equals("cba"));

Specified by:: foldRight in interface Foldable<T>
Parameters:: identity -; accumulator -
Returns:

foldRightMapToType
```
<T> T foldRightMapToType(Reducer<T> reducer)
```
Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
```
 
 		ReactiveSeq.of(1,2,3).foldRightMapToType(Reducers.toString(""));
 
 // "321"
 
 
```
Specified by:

foldRightMapToType in interface Foldable<T>

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

toStreamable

Streamable<T> toStreamable()

  
 	Streamable<Integer> repeat = ReactiveSeq.of(1,2,3,4,5,6)
 												.map(i->i*2)
 												.toStreamable();
 		
 		repeat.sequenceM().toList(); //Arrays.asList(2,4,6,8,10,12));
 		repeat.sequenceM().toList() //Arrays.asList(2,4,6,8,10,12));

Specified by:: toStreamable in interface ConvertableSequence<T>
Returns:: Lazily Convert to a repeatable Streamable

toSet
```
java.util.Set<T> toSet()
```
Specified by:

toSet in interface org.jooq.lambda.Collectable<T>

Specified by:

toSet in interface CyclopsCollectable<T>

Returns:

This Stream converted to a set

toList
```
java.util.List<T> toList()
```
Specified by:

toList in interface org.jooq.lambda.Collectable<T>

Specified by:

toList in interface CyclopsCollectable<T>

Returns:

this Stream converted to a list

toCollection
```
<C extends java.util.Collection<T>> C toCollection(java.util.function.Supplier<C> collectionFactory)
```
Specified by:

toCollection in interface org.jooq.lambda.Collectable<T>

Specified by:

toCollection in interface CyclopsCollectable<T>

toStream
```
<T> java.util.stream.Stream<T> toStream()
```
Convert this ReactiveSeq into a Stream

Returns:

calls to stream() but more flexible on type for inferencing purposes.

stream
```
ReactiveSeq<T> stream()
```
Convert this ReactiveSeq into a Stream

Specified by:

stream in interface ConvertableSequence<T>

Specified by:

stream in interface ExtendedTraversable<T>

Specified by:

stream in interface Foldable<T>

Specified by:

stream in interface IterableFunctor<T>

Specified by:

stream in interface org.jooq.lambda.Seq<T>

Specified by:

stream in interface TransformerTraversable<T>

Specified by:

stream in interface Traversable<T>

startsWithIterable
```
boolean startsWithIterable(java.lang.Iterable<T> iterable)
```
```
 
 assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Arrays.asList(1,2,3)));
 
 
```
Specified by:

startsWithIterable in interface Foldable<T>

Parameters:

iterable -

Returns:

True if Monad starts with Iterable sequence of data

startsWith
```
boolean startsWith(java.util.stream.Stream<T> stream)
```
```
 assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Stream.of(1,2,3))) 
 
```
Specified by:

startsWith in interface Foldable<T>

Parameters:

iterator -

Returns:

True if Monad starts with Iterators sequence of data

anyM
```
AnyMSeq<T> anyM()
```
Returns:

this ReactiveSeq converted to AnyM format

map
```
<R> ReactiveSeq<R> map(java.util.function.Function<? super T,? extends R> fn)
```
Description copied from interface: Functor
Transform this functor using the supplied transformation function
```
 
 
 
 of(1,2,3).map(i->i*2)
 
 //[2,4,6]
 
 
 
```
Specified by:

map in interface FilterableFunctor<T>

Specified by:

map in interface Functor<T>

Specified by:

map in interface IterableFunctor<T>

Specified by:

map in interface org.jooq.lambda.Seq<T>

Specified by:

map in interface java.util.stream.Stream<T>

Parameters:

fn - Transformation function

Returns:

Transformed Functor

peek
```
ReactiveSeq<T> peek(java.util.function.Consumer<? super T> c)
```
Description copied from interface: Functor
Peek at the current value of this Functor, without transforming it
```
 
 
 
 of(1,2,3).map(System.out::println)
 
 1
 2
 3
 
 
 
```
Specified by:

peek in interface Functor<T>

Specified by:

peek in interface org.jooq.lambda.Seq<T>

Specified by:

peek in interface java.util.stream.Stream<T>

Parameters:

c - Consumer that recieves each element from this Functor

Returns:

Functor that will peek at each value

flatMap

<R> ReactiveSeq<R> flatMap(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)

flatMap operation

 
 	assertThat(ReactiveSeq.of(1,2)
 						.flatMap(i -> asList(i, -i).stream())
 						.toList(),equalTo(asList(1, -1, 2, -2)));

Specified by:: flatMap in interface org.jooq.lambda.Seq<T>
Specified by:: flatMap in interface java.util.stream.Stream<T>
Parameters:: fn - to be applied
Returns:: new stage in Sequence with flatMap operation to be lazily applied

flatMapAnyM

<R> ReactiveSeq<R> flatMapAnyM(java.util.function.Function<? super T,AnyM<? extends R>> fn)

Allows flatMap return type to be any Monad type

  
 	assertThat(ReactiveSeq.of(1,2,3)).flatMapAnyM(i-> anyM(CompletableFuture.completedFuture(i+2))).toList(),equalTo(Arrays.asList(3,4,5)));

Parameters:: fn - to be applied
Returns:: new stage in Sequence with flatMap operation to be lazily applied

flatMapIterable

<R> ReactiveSeq<R> flatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)

FlatMap where the result is a Collection, flattens the resultant collections into the host ReactiveSeq

  
 	ReactiveSeq.of(1,2)
 			.flatMap(i -> asList(i, -i))
          .toList();
          
   //1,-1,2,-2

Parameters:: fn -
Returns:

flatMapStream

<R> ReactiveSeq<R> flatMapStream(java.util.function.Function<? super T,java.util.stream.BaseStream<? extends R,?>> fn)

flatMap operation

  
 	assertThat(ReactiveSeq.of(1,2,3)
                      .flatMapStream(i->IntStream.of(i))
                      .toList(),equalTo(Arrays.asList(1,2,3)));

Parameters:: fn - to be applied
Returns:: new stage in Sequence with flatMap operation to be lazily applied

filter
```
ReactiveSeq<T> filter(java.util.function.Predicate<? super T> fn)
```
Description copied from interface: Filterable
Keep only elements for which the supplied predicates hold e.g.
```
 
 
 of(1,2,3).filter(i->i>2);
 
 //[3]
 
 
 
```
Specified by:

filter in interface Filterable<T>

Specified by:

filter in interface FilterableFunctor<T>

Specified by:

filter in interface JoolManipulation<T>

Specified by:

filter in interface org.jooq.lambda.Seq<T>

Specified by:

filter in interface java.util.stream.Stream<T>

Parameters:

fn - to filter elements by, retaining matches

Returns:

Filterable with elements removed where the predicate does not hold

sequential
```
ReactiveSeq<T> sequential()
```
Specified by:

sequential in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>

Specified by:

sequential in interface org.jooq.lambda.Seq<T>

unordered
```
ReactiveSeq<T> unordered()
```
Specified by:

unordered in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>

Specified by:

unordered in interface org.jooq.lambda.Seq<T>

intersperse
```
ReactiveSeq<T> intersperse(T value)
```
Returns a stream with a given value interspersed between any two values of this stream. // (1, 0, 2, 0, 3, 0, 4) ReactiveSeq.of(1, 2, 3, 4).intersperse(0)

Specified by:

intersperse in interface org.jooq.lambda.Seq<T>

Specified by:

intersperse in interface Traversable<T>

ofType
```
 ReactiveSeq ofType(java.lang.Class<? extends U> type)
```
Keep only those elements in a stream that are of a given type. // (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)

Specified by:

ofType in interface Filterable<T>

Specified by:

ofType in interface JoolManipulation<T>

Specified by:

ofType in interface org.jooq.lambda.Seq<T>

cast
```
 ReactiveSeq cast(java.lang.Class<? extends U> type)
```
Cast all elements in a stream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)

Specified by:

cast in interface Functor<T>

Specified by:

cast in interface org.jooq.lambda.Seq<T>

toLazyCollection

CollectionX<T> toLazyCollection()

Lazily converts this ReactiveSeq into a Collection. This does not trigger the Stream. E.g. Collection is not thread safe on the first iteration.

 {
        @code
        Collection<Integer> col = ReactiveSeq.of(1, 2, 3, 4, 5).peek(System.out::println).toLazyCollection();
 
        col.forEach(System.out::println);
 }
 
 // Will print out "first!" before anything else

Specified by:: toLazyCollection in interface Foldable<T>
Returns:

toConcurrentLazyCollection

CollectionX<T> toConcurrentLazyCollection()

Lazily converts this ReactiveSeq into a Collection. This does not trigger the Stream. E.g.

 {
        @code
        Collection<Integer> col = ReactiveSeq.of(1, 2, 3, 4, 5).peek(System.out::println).toConcurrentLazyCollection();
 
        col.forEach(System.out::println);
 }
 
 // Will print out "first!" before anything else

Specified by:: toConcurrentLazyCollection in interface Foldable<T>
Returns:

toConcurrentLazyStreamable

Streamable<T> toConcurrentLazyStreamable()

 {
        @code
        Streamable<Integer> repeat = ReactiveSeq.of(1, 2, 3, 4, 5, 6).map(i -> i + 2).toConcurrentLazyStreamable();
 
        assertThat(repeat.sequenceM().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12)));
        assertThat(repeat.sequenceM().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12)));
 }

Specified by:: toConcurrentLazyStreamable in interface Foldable<T>
Returns:: Streamable that replay this ReactiveSeq, populated lazily and can be populated across threads

reverse
```
ReactiveSeq<T> reverse()
```
Specified by:

reverse in interface org.jooq.lambda.Seq<T>

Specified by:

reverse in interface Traversable<T>

onClose
```
ReactiveSeq<T> onClose(java.lang.Runnable closeHandler)
```
Specified by:

onClose in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>

Specified by:

onClose in interface org.jooq.lambda.Seq<T>

shuffle
```
ReactiveSeq<T> shuffle()
```
Specified by:

shuffle in interface org.jooq.lambda.Seq<T>

Specified by:

shuffle in interface Traversable<T>

appendStream

ReactiveSeq<T> appendStream(java.util.stream.Stream<T> stream)

Append Stream to this ReactiveSeq

 {
        @code
        List<String> result = ReactiveSeq.of(1, 2, 3).appendStream(ReactiveSeq.of(100, 200, 300)).map(it -> it + "!!").collect(Collectors.toList());
 
        assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "3!!", "100!!", "200!!", "300!!")));
 }

Parameters:: stream - to append
Returns:: ReactiveSeq with Stream appended

prependStream

ReactiveSeq<T> prependStream(java.util.stream.Stream<T> stream)

Prepend Stream to this ReactiveSeq

 {
        @code
        List<String> result = ReactiveSeq.of(1, 2, 3).prependStream(of(100, 200, 300)).map(it -> it + "!!").collect(Collectors.toList());
 
        assertThat(result, equalTo(Arrays.asList("100!!", "200!!", "300!!", "1!!", "2!!", "3!!")));
 
 }

Parameters:: stream - to Prepend
Returns:: ReactiveSeq with Stream prepended

append

ReactiveSeq<T> append(T... values)

Append values to the end of this ReactiveSeq

 {
        @code
        List<String> result = ReactiveSeq.of(1, 2, 3).append(100, 200, 300).map(it -> it + "!!").collect(Collectors.toList());
 
        assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "3!!", "100!!", "200!!", "300!!")));
 }

Specified by:: append in interface org.jooq.lambda.Seq<T>
Parameters:: values - to append
Returns:: ReactiveSeq with appended values

append
```
ReactiveSeq<T> append(T value)
```
Specified by:

append in interface org.jooq.lambda.Seq<T>

prepend
```
ReactiveSeq<T> prepend(T value)
```
Specified by:

prepend in interface org.jooq.lambda.Seq<T>

prepend

ReactiveSeq<T> prepend(T... values)

Prepend given values to the start of the Stream

  
 List<String> result = 	ReactiveSeq.of(1,2,3)
 									 .prepend(100,200,300)
 										 .map(it ->it+"!!")
 										 .collect(Collectors.toList());
 
 			assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));

Specified by:: prepend in interface org.jooq.lambda.Seq<T>
Parameters:: values - to prepend
Returns:: ReactiveSeq with values prepended

insertAt

ReactiveSeq<T> insertAt(int pos,
                        T... values)

Insert data into a stream at given position

 {
        @code
        List<String> result = ReactiveSeq.of(1, 2, 3).insertAt(1, 100, 200, 300).map(it -> it + "!!").collect(Collectors.toList());
 
        assertThat(result, equalTo(Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!")));
 
 }

Parameters:: pos - to insert data at; values - to insert
Returns:: Stream with new data inserted

deleteBetween

ReactiveSeq<T> deleteBetween(int start,
                             int end)

Delete elements between given indexes in a Stream

 {
        @code
        List<String> result = ReactiveSeq.of(1, 2, 3, 4, 5, 6).deleteBetween(2, 4).map(it -> it + "!!").collect(Collectors.toList());
 
        assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "5!!", "6!!")));
 }

Parameters:: start - index; end - index
Returns:: Stream with elements removed

insertStreamAt

ReactiveSeq<T> insertStreamAt(int pos,
                              java.util.stream.Stream<T> stream)

Insert a Stream into the middle of this stream at the specified position

 {
        @code
        List<String> result = ReactiveSeq.of(1, 2, 3).insertStreamAt(1, of(100, 200, 300)).map(it -> it + "!!").collect(Collectors.toList());
 
        assertThat(result, equalTo(Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!")));
 }

Parameters:: pos - to insert Stream at; stream - to insert
Returns:: newly conjoined ReactiveSeq

futureOperations
```
FutureOperations<T> futureOperations(java.util.concurrent.Executor exec)
```
Access asynchronous terminal operations (each returns a Future)

Specified by:

futureOperations in interface Traversable<T>

Parameters:

exec - Executor to use for Stream execution

Returns:

Async Future Terminal Operations

endsWithIterable
```
boolean endsWithIterable(java.lang.Iterable<T> iterable)
```
```
 
 assertTrue(ReactiveSeq.of(1,2,3,4,5,6)
 				.endsWith(Arrays.asList(5,6)));
 
 
```
Specified by:

endsWithIterable in interface Foldable<T>

Parameters:

iterable - Values to check

Returns:

true if ReactiveSeq ends with values in the supplied iterable

endsWith
```
boolean endsWith(java.util.stream.Stream<T> stream)
```
```
 
 assertTrue(ReactiveSeq.of(1,2,3,4,5,6)
 				.endsWith(Stream.of(5,6))); 
 
 
```
Specified by:

endsWith in interface Foldable<T>

Parameters:

stream - Values to check

Returns:

true if ReactiveSeq endswith values in the supplied Stream

skip

ReactiveSeq<T> skip(long time,
                    java.util.concurrent.TimeUnit unit)

Skip all elements until specified time period has passed

 {
        @code
        List<Integer> result = ReactiveSeq.of(1, 2, 3, 4, 5, 6).peek(i -> sleep(i * 100)).skip(1000, TimeUnit.MILLISECONDS).toList();
 
        // [4,5,6]
 
 }

Parameters:: time - Length of time; unit - Time unit
Returns:: ReactiveSeq that skips all elements until time period has elapsed

limit

ReactiveSeq<T> limit(long time,
                     java.util.concurrent.TimeUnit unit)

Return all elements until specified time period has elapsed

 {
        @code
        List<Integer> result = ReactiveSeq.of(1, 2, 3, 4, 5, 6).peek(i -> sleep(i * 100)).limit(1000, TimeUnit.MILLISECONDS).toList();
 
        // [1,2,3,4]
 }

Parameters:: time - Length of time; unit - Time unit
Returns:: ReactiveSeq that returns all elements until time period has elapsed

skipLast
```
ReactiveSeq<T> skipLast(int num)
```
assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));

Specified by:

skipLast in interface Traversable<T>

Parameters:

num -

Returns:

limitLast
```
ReactiveSeq<T> limitLast(int num)
```
Limit results to the last x elements in a ReactiveSeq
```
 
 	assertThat(ReactiveSeq.of(1,2,3,4,5)
 							.limitLast(2)
 							.collect(Collectors.toList()),equalTo(Arrays.asList(4,5)));
 
 
```
Specified by:

limitLast in interface Traversable<T>

Parameters:

num - of elements to return (last elements)

Returns:

ReactiveSeq limited to last num elements

hotStream
```
HotStream<T> hotStream(java.util.concurrent.Executor e)
```
Turns this ReactiveSeq into a HotStream, a connectable Stream, being executed on a thread on the supplied executor, that is producing data. Note this method creates a HotStream that starts emitting data immediately. For a hotStream that waits until the first user streams connect @see primedHotStream(Executor). The generated HotStream is not pausable, for a pausable HotStream @see pausableHotStream(Executor). Turns this ReactiveSeq into a HotStream, a connectable Stream, being executed on a thread on the supplied executor, that is producing data
```
 
 HotStream<Integer> ints = ReactiveSeq.range(0,Integer.MAX_VALUE)
 											.hotStream(exec)
 											
 		
 		ints.connect().forEach(System.out::println);									
 //print out all the ints
 //multiple consumers are possible, so other Streams can connect on different Threads
 
 
 
```
Parameters:

e - Executor to execute this ReactiveSeq on

Returns:

a Connectable HotStream

primedHotStream

HotStream<T> primedHotStream(java.util.concurrent.Executor e)

Return a HotStream that will start emitting data when the first connecting Stream connects. Note this method creates a HotStream that starts emitting data only when the first connecting Stream connects. For a hotStream that starts to output data immediately @see hotStream(Executor). The generated HotStream is not pausable, for a pausable HotStream @see primedPausableHotStream(Executor).

   
  HotStream<Integer> ints = ReactiveSeq.range(0,Integer.MAX_VALUE)
											.hotStream(exec)
											
		
		ints.connect().forEach(System.out::println);									
  //print out all the ints - starting when connect is called.
  //multiple consumers are possible, so other Streams can connect on different Threads

Parameters:: e -
Returns:

pausableHotStream
```
PausableHotStream<T> pausableHotStream(java.util.concurrent.Executor e)
```
Turns this ReactiveSeq into a HotStream, a connectable & pausable Stream, being executed on a thread on the supplied executor, that is producing data. Note this method creates a HotStream that starts emitting data immediately. For a hotStream that waits until the first user streams connect @see primedPausableHotStream(Executor). The generated HotStream is pausable, for a unpausable HotStream (slightly faster execution) @see hotStream(Executor).
```
 
 HotStream<Integer> ints = ReactiveSeq.range(0,Integer.MAX_VALUE)
											.hotStream(exec)
											
		
		ints.connect().forEach(System.out::println);
		
		ints.pause(); //on a separate thread pause the generating Stream
											
 //print out all the ints
 //multiple consumers are possible, so other Streams can connect on different Threads
 
 
 
```
Parameters:

e - Executor to execute this ReactiveSeq on

Returns:

a Connectable HotStream

primedPausableHotStream

PausableHotStream<T> primedPausableHotStream(java.util.concurrent.Executor e)

Return a pausable HotStream that will start emitting data when the first connecting Stream connects. Note this method creates a HotStream that starts emitting data only when the first connecting Stream connects. For a hotStream that starts to output data immediately @see pausableHotStream(Executor). The generated HotStream is pausable, for a unpausable HotStream @see primedHotStream(Executor).

   
  HotStream<Integer> ints = ReactiveSeq.range(0,Integer.MAX_VALUE)
											.hotStream(exec)
											
		
		ints.connect().forEach(System.out::println);									
  //print out all the ints - starting when connect is called.
  //multiple consumers are possible, so other Streams can connect on different Threads

Parameters:: e -
Returns:

firstValue

T firstValue()

  
 	assertThat(ReactiveSeq.of(1,2,3,4)
 					.map(u->{throw new RuntimeException();})
 					.recover(e->"hello")
 					.firstValue(),equalTo("hello"));

Specified by:: firstValue in interface Foldable<T>
Returns:: first value in this Stream

single

default T single()

  
    
    //1
    ReactiveSeq.of(1).single(); 
    
    //UnsupportedOperationException
    ReactiveSeq.of().single();
     
     //UnsupportedOperationException
    ReactiveSeq.of(1,2,3).single();

Specified by:: single in interface Foldable<T>
Returns:: a single value or an UnsupportedOperationException if 0/1 values in this Stream

single

default T single(java.util.function.Predicate<? super T> predicate)

Specified by:: single in interface Foldable<T>

singleOptional

default java.util.Optional<T> singleOptional()

  
    
    //Optional[1]
    ReactiveSeq.of(1).singleOptional(); 
    
    //Optional.empty
    ReactiveSeq.of().singleOpional();
     
     //Optional.empty
    ReactiveSeq.of(1,2,3).singleOptional();

Specified by:: singleOptional in interface Foldable<T>
Returns:: An Optional with single value if this Stream has exactly one element, otherwise Optional Empty

get
```
default java.util.Optional<T> get(long index)
```
Return the elementAt index or Optional.empty
```
 
 	assertThat(ReactiveSeq.of(1,2,3,4,5).elementAt(2).get(),equalTo(3));
 
 
```
Specified by:

get in interface Foldable<T>

Specified by:

get in interface org.jooq.lambda.Seq<T>

Parameters:

index - to extract element from

Returns:

elementAt index

elementAt
```
default org.jooq.lambda.tuple.Tuple2<T,ReactiveSeq<T>> elementAt(long index)
```
Gets the element at index, and returns a Tuple containing the element (it must be present) and a lazy copy of the Sequence for further processing.
```
 
 ReactiveSeq.of(1,2,3,4,5).get(2).v1
 //3
 
 
```
Parameters:

index - to extract element from

Returns:

Element and Sequence

elapsed

default ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> elapsed()

  
 ReactiveSeq.of(1,2,3,4,5)
 				 .elapsed()
 				 .forEach(System.out::println);

Returns:: Sequence that adds the time between elements in millis to each element

timestamp

default ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> timestamp()

 
    ReactiveSeq.of(1,2,3,4,5)
 				   .timestamp()
 				   .forEach(System.out::println)

Returns:: Sequence that adds a timestamp to each element

subscriber

static <T> SeqSubscriber<T> subscriber()

Create a subscriber that can listen to Reactive Streams (simple-react, RxJava AkkaStreams, Kontraktor, QuadarStreams etc)

 
     SeqSubscriber<Integer> sub = ReactiveSeq.subscriber();
 		ReactiveSeq.of(1,2,3).subscribe(sub);
 		sub.stream().forEach(System.out::println);
 		
 		  1 
 		  2
 		  3

Returns:: A reactive-streams Subscriber

empty
```
static <T> ReactiveSeq<T> empty()
```
Specified by:

empty in interface org.jooq.lambda.Seq<T>

Specified by:

empty in interface java.util.stream.Stream<T>

of
```
@SafeVarargs
static <T> ReactiveSeq<T> of(T... elements)
```
Create an efficiently reversable Sequence from the provided elements

Specified by:

of in interface org.jooq.lambda.Seq<T>

Specified by:

of in interface java.util.stream.Stream<T>

Parameters:

elements - To Construct sequence from

Returns:

reversedOf
```
@SafeVarargs
static <T> ReactiveSeq<T> reversedOf(T... elements)
```
Construct a Reveresed Sequence from the provided elements Can be reversed (again) efficiently

Parameters:

elements - To Construct sequence from

Returns:

reversedListOf
```
static <T> ReactiveSeq<T> reversedListOf(java.util.List<T> elements)
```
Construct a Reveresed Sequence from the provided elements Can be reversed (again) efficiently

Parameters:

elements - To Construct sequence from

Returns:

range
```
static ReactiveSeq<java.lang.Integer> range(int start,
 int end)
```
Create an efficiently reversable Sequence that produces the integers between start and end

Specified by:

range in interface org.jooq.lambda.Seq<T>

Parameters:

start - Number of range to start from

end - Number for range to end at

Returns:

Range ReactiveSeq

rangeLong
```
static ReactiveSeq<java.lang.Long> rangeLong(long start,
 long end)
```
Create an efficiently reversable Sequence that produces the integers between start and end

Parameters:

start - Number of range to start from

end - Number for range to end at

Returns:

Range ReactiveSeq

fromStream
```
static <T> ReactiveSeq<T> fromStream(java.util.stream.Stream<T> stream)
```
Construct a ReactiveSeq from a Stream

Parameters:

stream - Stream to construct Sequence from

Returns:

fromIntStream
```
static ReactiveSeq<java.lang.Integer> fromIntStream(java.util.stream.IntStream stream)
```
Construct a ReactiveSeq from a Stream

Parameters:

stream - Stream to construct Sequence from

Returns:

fromLongStream
```
static ReactiveSeq<java.lang.Long> fromLongStream(java.util.stream.LongStream stream)
```
Construct a ReactiveSeq from a Stream

Parameters:

stream - Stream to construct Sequence from

Returns:

fromDoubleStream
```
static ReactiveSeq<java.lang.Double> fromDoubleStream(java.util.stream.DoubleStream stream)
```
Construct a ReactiveSeq from a Stream

Parameters:

stream - Stream to construct Sequence from

Returns:

fromList
```
static <T> ReactiveSeq<T> fromList(java.util.List<T> list)
```
Construct a ReactiveSeq from a List (prefer this method if the source is a list, as it allows more efficient Stream reversal).

Parameters:

iterable - to construct Sequence from

Returns:

ReactiveSeq

fromPublisher
```
static <T> ReactiveSeq<T> fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)
```
Construct a ReactiveSeq from an Publisher

Parameters:

iterable - to construct ReactiveSeq from

Returns:

ReactiveSeq

fromIterable
```
static <T> ReactiveSeq<T> fromIterable(java.lang.Iterable<T> iterable)
```
Construct a ReactiveSeq from an Iterable

Parameters:

iterable - to construct Sequence from

Returns:

ReactiveSeq

fromIterator
```
static <T> ReactiveSeq<T> fromIterator(java.util.Iterator<T> iterator)
```
Construct a ReactiveSeq from an Iterator

Parameters:

iterator - to construct Sequence from

Returns:

ReactiveSeq

iterate
```
static <T> ReactiveSeq<T> iterate(T seed,
 java.util.function.UnaryOperator<T> f)
```
Specified by:

iterate in interface org.jooq.lambda.Seq<T>

Specified by:

iterate in interface java.util.stream.Stream<T>

See Also:

Stream.iterate(Object, UnaryOperator)

unfold

static <U,T> ReactiveSeq<T> unfold(U seed,
                                   java.util.function.Function<? super U,java.util.Optional<org.jooq.lambda.tuple.Tuple2<T,U>>> unfolder)

Unfold a function into a ReactiveSeq

  
  ReactiveSeq.unfold(1,i->i<=6 ? Optional.of(Tuple.tuple(i,i+1)) : Optional.empty());
 
 //(1,2,3,4,5)

Specified by:: unfold in interface org.jooq.lambda.Seq<T>
Parameters:: seed - Initial value; unfolder - Iteratively applied function, terminated by an empty Optional
Returns:: ReactiveSeq generated by unfolder function

generate
```
static <T> ReactiveSeq<T> generate(java.util.function.Supplier<T> s)
```
Specified by:

generate in interface org.jooq.lambda.Seq<T>

Specified by:

generate in interface java.util.stream.Stream<T>

See Also:

Stream.generate(Supplier)

unzip

static <T,U> org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<U>> unzip(ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> sequence)

Unzip a zipped Stream

  
  unzip(ReactiveSeq.of(new Tuple2(1, "a"), new Tuple2(2, "b"), new Tuple2(3, "c")))
  
  // ReactiveSeq[1,2,3], ReactiveSeq[a,b,c]

unzip3

static <T1,T2,T3> org.jooq.lambda.tuple.Tuple3<ReactiveSeq<T1>,ReactiveSeq<T2>,ReactiveSeq<T3>> unzip3(ReactiveSeq<org.jooq.lambda.tuple.Tuple3<T1,T2,T3>> sequence)

Unzip a zipped Stream into 3

  
    unzip3(ReactiveSeq.of(new Tuple3(1, "a", 2l), new Tuple3(2, "b", 3l), new Tuple3(3,"c", 4l)))
 
 // ReactiveSeq[1,2,3], ReactiveSeq[a,b,c], ReactiveSeq[2l,3l,4l]

unzip4

static <T1,T2,T3,T4> org.jooq.lambda.tuple.Tuple4<ReactiveSeq<T1>,ReactiveSeq<T2>,ReactiveSeq<T3>,ReactiveSeq<T4>> unzip4(ReactiveSeq<org.jooq.lambda.tuple.Tuple4<T1,T2,T3,T4>> sequence)

Unzip a zipped Stream into 4

  
 unzip4(ReactiveSeq.of(new Tuple4(1, "a", 2l,'z'), new Tuple4(2, "b", 3l,'y'), new Tuple4(3,
 						"c", 4l,'x')));
 		
                // ReactiveSeq[1,2,3], ReactiveSeq[a,b,c], ReactiveSeq[2l,3l,4l], ReactiveSeq[z,y,x]

crossJoin

default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> crossJoin(java.util.stream.Stream<? extends U> other)

Specified by:: crossJoin in interface org.jooq.lambda.Seq<T>

crossJoin

default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> crossJoin(org.jooq.lambda.Seq<? extends U> other)

Specified by:: crossJoin in interface org.jooq.lambda.Seq<T>

crossJoin

default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> crossJoin(java.lang.Iterable<? extends U> other)

Specified by:: crossJoin in interface org.jooq.lambda.Seq<T>

innerJoin

default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> innerJoin(java.util.stream.Stream<? extends U> other,
                                                                     java.util.function.BiPredicate<? super T,? super U> predicate)

Specified by:: innerJoin in interface org.jooq.lambda.Seq<T>

innerJoin

default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> innerJoin(java.lang.Iterable<? extends U> other,
                                                                     java.util.function.BiPredicate<? super T,? super U> predicate)

Specified by:: innerJoin in interface org.jooq.lambda.Seq<T>

innerJoin

default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> innerJoin(org.jooq.lambda.Seq<? extends U> other,
                                                                     java.util.function.BiPredicate<? super T,? super U> predicate)

Specified by:: innerJoin in interface org.jooq.lambda.Seq<T>

innerJoin

default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> innerJoin(Streamable<? extends U> other,
                                                                     java.util.function.BiPredicate<? super T,? super U> predicate)

leftOuterJoin

default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> leftOuterJoin(java.util.stream.Stream<? extends U> other,
                                                                         java.util.function.BiPredicate<? super T,? super U> predicate)

Specified by:: leftOuterJoin in interface org.jooq.lambda.Seq<T>

leftOuterJoin

default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> leftOuterJoin(org.jooq.lambda.Seq<? extends U> other,
                                                                         java.util.function.BiPredicate<? super T,? super U> predicate)

Specified by:: leftOuterJoin in interface org.jooq.lambda.Seq<T>

leftOuterJoin

default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> leftOuterJoin(java.lang.Iterable<? extends U> other,
                                                                         java.util.function.BiPredicate<? super T,? super U> predicate)

Specified by:: leftOuterJoin in interface org.jooq.lambda.Seq<T>

leftOuterJoin

default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> leftOuterJoin(Streamable<? extends U> s,
                                                                         java.util.function.BiPredicate<? super T,? super U> predicate)

rightOuterJoin

default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> rightOuterJoin(java.util.stream.Stream<? extends U> other,
                                                                          java.util.function.BiPredicate<? super T,? super U> predicate)

Specified by:: rightOuterJoin in interface org.jooq.lambda.Seq<T>

rightOuterJoin

default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> rightOuterJoin(java.lang.Iterable<? extends U> other,
                                                                          java.util.function.BiPredicate<? super T,? super U> predicate)

Specified by:: rightOuterJoin in interface org.jooq.lambda.Seq<T>

rightOuterJoin

default <U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>> rightOuterJoin(org.jooq.lambda.Seq<? extends U> other,
                                                                          java.util.function.BiPredicate<? super T,? super U> predicate)

Specified by:: rightOuterJoin in interface org.jooq.lambda.Seq<T>

onEmptySwitch

default ReactiveSeq<T> onEmptySwitch(java.util.function.Supplier<? extends java.util.stream.Stream<T>> switchTo)

If this ReactiveSeq is empty replace it with a another Stream

  
 assertThat(ReactiveSeq.of(4,5,6)
 							.onEmptySwitch(()->ReactiveSeq.of(1,2,3))
 							.toList(),
 							equalTo(Arrays.asList(4,5,6)));

Parameters:: switchTo - Supplier that will generate the alternative Stream
Returns:: ReactiveSeq that will switch to an alternative Stream if empty

onEmpty
```
ReactiveSeq<T> onEmpty(T value)
```
Specified by:

onEmpty in interface org.jooq.lambda.Seq<T>

Specified by:

onEmpty in interface Traversable<T>

onEmptyGet
```
ReactiveSeq<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
```
Specified by:

onEmptyGet in interface org.jooq.lambda.Seq<T>

Specified by:

onEmptyGet in interface Traversable<T>

onEmptyThrow

default <X extends java.lang.Throwable> ReactiveSeq<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)

Specified by:: onEmptyThrow in interface org.jooq.lambda.Seq<T>
Specified by:: onEmptyThrow in interface Traversable<T>

concat

ReactiveSeq<T> concat(java.util.stream.Stream<? extends T> other)

Specified by:: concat in interface org.jooq.lambda.Seq<T>

concat
```
ReactiveSeq<T> concat(T other)
```
Specified by:

concat in interface org.jooq.lambda.Seq<T>

concat
```
ReactiveSeq<T> concat(T... other)
```
Specified by:

concat in interface org.jooq.lambda.Seq<T>

distinct

<U> ReactiveSeq<T> distinct(java.util.function.Function<? super T,? extends U> keyExtractor)

Specified by:: distinct in interface org.jooq.lambda.Seq<T>

shuffle
```
ReactiveSeq<T> shuffle(java.util.Random random)
```
Specified by:

shuffle in interface org.jooq.lambda.Seq<T>

Specified by:

shuffle in interface Traversable<T>

slice
```
ReactiveSeq<T> slice(long from,
 long to)
```
Specified by:

slice in interface org.jooq.lambda.Seq<T>

Specified by:

slice in interface Traversable<T>

sorted

<U extends java.lang.Comparable<? super U>> ReactiveSeq<T> sorted(java.util.function.Function<? super T,? extends U> function)

Specified by:: sorted in interface org.jooq.lambda.Seq<T>
Specified by:: sorted in interface Traversable<T>

xPer

ReactiveSeq<T> xPer(int x,
                    long time,
                    java.util.concurrent.TimeUnit t)

emit x elements per time period

 {
        @code
        SimpleTimer timer = new SimpleTimer();
        assertThat(ReactiveSeq.of(1, 2, 3, 4, 5, 6).xPer(6, 100000000, TimeUnit.NANOSECONDS).collect(Collectors.toList()).size(), is(6));
 
 }

Parameters:: x - number of elements to emit; time - period; t - Time unit
Returns:: ReactiveSeq that emits x elements per time period

onePer

ReactiveSeq<T> onePer(long time,
                      java.util.concurrent.TimeUnit t)

emit one element per time period

  
 ReactiveSeq.iterate("", last -> "next")
 				.limit(100)
 				.batchBySize(10)
 				.onePer(1, TimeUnit.MICROSECONDS)
 				.peek(batch -> System.out.println("batched : " + batch))
 				.flatMap(Collection::stream)
 				.peek(individual -> System.out.println("Flattened : "
 						+ individual))
 				.forEach(a->{});

Parameters:: time - period; t - Time unit
Returns:: ReactiveSeq that emits 1 element per time period

debounce

ReactiveSeq<T> debounce(long time,
                        java.util.concurrent.TimeUnit t)

Allow one element through per time period, drop all other elements in that time period

  
 ReactiveSeq.of(1,2,3,4,5,6)
          .debounce(1000,TimeUnit.SECONDS).toList();
          
 // 1

Parameters:: time -; t -
Returns:

fixedDelay

ReactiveSeq<T> fixedDelay(long l,
                          java.util.concurrent.TimeUnit unit)

emit elements after a fixed delay

 {
        @code
        SimpleTimer timer = new SimpleTimer();
        assertThat(ReactiveSeq.of(1, 2, 3, 4, 5, 6).fixedDelay(10000, TimeUnit.NANOSECONDS).collect(Collectors.toList()).size(), is(6));
        assertThat(timer.getElapsedNanoseconds(), greaterThan(60000l));
 }

Parameters:: l - time length in nanos of the delay; unit - for the delay
Returns:: ReactiveSeq that emits each element after a fixed delay

jitter

ReactiveSeq<T> jitter(long maxJitterPeriodInNanos)

Introduce a random jitter / time delay between the emission of elements

 {
        @code
        SimpleTimer timer = new SimpleTimer();
        assertThat(ReactiveSeq.of(1, 2, 3, 4, 5, 6).jitter(10000).collect(Collectors.toList()).size(), is(6));
        assertThat(timer.getElapsedNanoseconds(), greaterThan(20000l));
 }

Parameters:: maxJitterPeriodInNanos - - random number less than this is used for each jitter
Returns:: Sequence with a random jitter between element emission

recover

ReactiveSeq<T> recover(java.util.function.Function<java.lang.Throwable,? extends T> fn)

Recover from an exception with an alternative value

  
 assertThat(ReactiveSeq.of(1,2,3,4)
 						   .map(i->i+2)
 						   .map(u->{throw new RuntimeException();})
 						   .recover(e->"hello")
 						   .firstValue(),equalTo("hello"));

Parameters:: fn - Function that accepts a Throwable and returns an alternative value
Returns:: ReactiveSeq that can recover from an Exception

recover

<EX extends java.lang.Throwable> ReactiveSeq<T> recover(java.lang.Class<EX> exceptionClass,
                                                        java.util.function.Function<EX,? extends T> fn)

Recover from a particular exception type

  
 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"));

Parameters:: exceptionClass - Type to recover from; fn - That accepts an error and returns an alternative value
Returns:: Sequence that can recover from a particular exception

retry

default <R> ReactiveSeq<R> retry(java.util.function.Function<? super T,? extends R> fn)

Retry a transformation if it fails. Default settings are to retry up to 7 times, with an doubling backoff period starting @ 2 seconds delay before retry.

  
 given(serviceMock.apply(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");
 
 	
 		String result = ReactiveSeq.of( 1,  2, 3)
 				.retry(serviceMock)
 				.firstValue();
 
 		//result = 42

Parameters:: fn - Function to retry if fails

retry

default <R> ReactiveSeq<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. Retries up to retries times, with an doubling backoff period starting @ delay TimeUnits delay before retry.

  
 given(serviceMock.apply(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");
 
 	
 		String result = ReactiveSeq.of( 1,  2, 3)
 				.retry(serviceMock, 7, 2, TimeUnit.SECONDS)
 				.firstValue();
 
 		//result = 42

Parameters:: fn - Function to retry if fails; retries - Number of retries; delay - Delay in TimeUnits; TimeUnit - to use for delay

remove
```
default ReactiveSeq<T> remove(T t)
```
Remove all occurances of the specified element from the ReactiveSeq
```
 
 	ReactiveSeq.of(1,2,3,4,5,1,2,3).remove(1)
 
 //Streamable[2,3,4,5,2,3]
 
 
```
Specified by:

remove in interface org.jooq.lambda.Seq<T>

Parameters:

t - element to remove

Returns:

Filtered Stream / ReactiveSeq

permutations
```
default ReactiveSeq<ReactiveSeq<T>> permutations()
```
Generate the permutations based on values in the ReactiveSeq Makes use of Streamable to store intermediate stages in a collection

Specified by:

permutations in interface ExtendedTraversable<T>

Returns:

Permutations from this ReactiveSeq

subStream
```
default ReactiveSeq<T> subStream(int start,
 int end)
```
Return a Stream with elements before the provided start index removed, and elements after the provided end index removed
```
 
 ReactiveSeq.of(1,2,3,4,5,6).subStream(1,3);
 
 
 //ReactiveSeq[2,3]
 
 
```
Parameters:

start - index inclusive

end - index exclusive

Returns:

Sequence between supplied indexes of original Sequence

combinations

default ReactiveSeq<ReactiveSeq<T>> combinations(int size)

 
   ReactiveSeq.of(1,2,3).combinations(2)
   
   //ReactiveSeq[ReactiveSeq[1,2],ReactiveSeq[1,3],ReactiveSeq[2,3]]

Specified by:: combinations in interface ExtendedTraversable<T>
Parameters:: size - of combinations
Returns:: All combinations of the elements in this stream of the specified size

combinations

default ReactiveSeq<ReactiveSeq<T>> combinations()

 
   ReactiveSeq.of(1,2,3).combinations()
   
   //ReactiveSeq[ReactiveSeq[],ReactiveSeq[1],ReactiveSeq[2],ReactiveSeq[3].ReactiveSeq[1,2],ReactiveSeq[1,3],ReactiveSeq[2,3]
   			,ReactiveSeq[1,2,3]]

Specified by:: combinations in interface ExtendedTraversable<T>
Returns:: All combinations of the elements in this stream

schedule

HotStream<T> schedule(java.lang.String cron,
                      java.util.concurrent.ScheduledExecutorService ex)

Execute this Stream on a schedule

 
  //run at 8PM every night
  ReactiveSeq.generate(()->"next job:"+formatDate(new Date()))
            .map(this::processJob)
            .schedule("0 20 * * *",Executors.newScheduledThreadPool(1));

Connect to the Scheduled Stream

 {
        @code
        HotStream<Data> dataStream = ReactiveSeq.generate(() -> "next job:" + formatDate(new Date())).map(this::processJob)
                        .schedule("0 20 * * *", Executors.newScheduledThreadPool(1));
 
        data.connect().forEach(this::logToDB);
 }

Specified by:: schedule in interface Foldable<T>
Parameters:: cron - Expression that determines when each job will run; ex - ScheduledExecutorService
Returns:: Connectable HotStream of output from scheduled Stream

scheduleFixedDelay

HotStream<T> scheduleFixedDelay(long delay,
                                java.util.concurrent.ScheduledExecutorService ex)

Execute this Stream on a schedule

 
  //run every 60 seconds after last job completes
  ReactiveSeq.generate(()->"next job:"+formatDate(new Date()))
            .map(this::processJob)
            .scheduleFixedDelay(60_000,Executors.newScheduledThreadPool(1));

Connect to the Scheduled Stream

 {
        @code
        HotStream<Data> dataStream = ReactiveSeq.generate(() -> "next job:" + formatDate(new Date())).map(this::processJob)
                        .scheduleFixedDelay(60_000, Executors.newScheduledThreadPool(1));
 
        data.connect().forEach(this::logToDB);
 }

Specified by:: scheduleFixedDelay in interface Foldable<T>
Parameters:: delay - Between last element completes passing through the Stream until the next one starts; ex - ScheduledExecutorService
Returns:: Connectable HotStream of output from scheduled Stream

scheduleFixedRate

HotStream<T> scheduleFixedRate(long rate,
                               java.util.concurrent.ScheduledExecutorService ex)

Execute this Stream on a schedule

 
  //run every 60 seconds
  ReactiveSeq.generate(()->"next job:"+formatDate(new Date()))
            .map(this::processJob)
            .scheduleFixedRate(60_000,Executors.newScheduledThreadPool(1));

Connect to the Scheduled Stream

 {
        @code
        HotStream<Data> dataStream = ReactiveSeq.generate(() -> "next job:" + formatDate(new Date())).map(this::processJob)
                        .scheduleFixedRate(60_000, Executors.newScheduledThreadPool(1));
 
        data.connect().forEach(this::logToDB);
 }

Specified by:: scheduleFixedRate in interface Foldable<T>
Parameters:: rate - Time in millis between job runs; ex - ScheduledExecutorService
Returns:: Connectable HotStream of output from scheduled Stream

size
```
default int size()
```
[equivalent to count]

Returns:

size

forEach3

<R1,R2,R> ReactiveSeq<R> forEach3(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1,
                                  java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends java.util.stream.BaseStream<R2,?>>> stream2,
                                  java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)

Perform a three level nested internal iteration over this Stream and the supplied streams

  
 ReactiveSeq.of(1,2)
 						.forEach3(a->IntStream.range(10,13),
 						        a->b->Stream.of(""+(a+b),"hello world"),
 									a->b->c->c+":"a+":"+b);
 									
 
  //ReactiveSeq[11:1:2,hello world:1:2,14:1:4,hello world:1:4,12:1:2,hello world:1:2,15:1:5,hello world:1:5]

Parameters:: stream1 - Nested Stream to iterate over; stream2 - Nested Stream to iterate over; yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
Returns:: ReactiveSeq with elements generated via nested iteration

forEach3

<R1,R2,R> ReactiveSeq<R> forEach3(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1,
                                  java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends java.util.stream.BaseStream<R2,?>>> stream2,
                                  java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,java.lang.Boolean>>> filterFunction,
                                  java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)

Perform a three level nested internal iteration over this Stream and the supplied streams

  
 ReactiveSeq.of(1,2,3)
 						.forEach3(a->IntStream.range(10,13),
 						      a->b->Stream.of(""+(a+b),"hello world"),
 						         a->b->c-> c!=3,
 									a->b->c->c+":"a+":"+b);
 									
 
  //ReactiveSeq[11:1:2,hello world:1:2,14:1:4,hello world:1:4,12:1:2,hello world:1:2,15:1:5,hello world:1:5]

Parameters:: stream1 - Nested Stream to iterate over; stream2 - Nested Stream to iterate over; filterFunction - Filter to apply over elements before passing non-filtered values to the yielding function; yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
Returns:: ReactiveSeq with elements generated via nested iteration

forEach2

<R1,R> ReactiveSeq<R> forEach2(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1,
                               java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)

Perform a two level nested internal iteration over this Stream and the supplied stream

  
 ReactiveSeq.of(1,2,3)
 						.forEach2(a->IntStream.range(10,13),
 									a->b->a+b);
 									
 
  //ReactiveSeq[11,14,12,15,13,16]

Parameters:: stream1 - Nested Stream to iterate over; yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
Returns:: ReactiveSeq with elements generated via nested iteration

forEach2

<R1,R> ReactiveSeq<R> forEach2(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1,
                               java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Boolean>> filterFunction,
                               java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)

Perform a two level nested internal iteration over this Stream and the supplied stream

  
 ReactiveSeq.of(1,2,3)
 						.forEach2(a->IntStream.range(10,13),
 						            a->b-> a<3 && b>10,
 									a->b->a+b);
 									
 
  //ReactiveSeq[14,15]

Parameters:: stream1 - Nested Stream to iterate over; filterFunction - Filter to apply over elements before passing non-filtered values to the yielding function; yieldingFunction - Function with pointers to the current element from both Streams that generates the new elements
Returns:: ReactiveSeq with elements generated via nested iteration

count
```
default long count()
```
Specified by:

count in interface org.jooq.lambda.Collectable<T>

Specified by:

count in interface CyclopsCollectable<T>

Specified by:

count in interface org.jooq.lambda.Seq<T>

Specified by:

count in interface java.util.stream.Stream<T>

collect
```
default <R,A> R collect(java.util.stream.Collector<? super T,A,R> collector)
```
Specified by:

collect in interface org.jooq.lambda.Collectable<T>

Specified by:

collect in interface CyclopsCollectable<T>

Specified by:

collect in interface java.util.stream.Stream<T>

collectable
```
default org.jooq.lambda.Collectable<T> collectable()
```
Description copied from interface: CyclopsCollectable

Narrow this class to a Collectable

Specified by:

collectable in interface CyclopsCollectable<T>

Specified by:

collectable in interface IterableFunctor<T>

Returns:

Collectable

patternMatch

default <R> ReactiveSeq<R> patternMatch(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,R>> case1,
                                        java.util.function.Supplier<? extends R> otherwise)

Description copied from interface: Functor

Transform the elements of this Stream with a Pattern Matching case and default value

 
 List<String> result = CollectionX.of(1,2,3,4)
                                              .patternMatch(
                                                        c->c.valuesWhere(i->"even", (Integer i)->i%2==0 )
                                                      )
 
 // CollectionX["odd","even","odd","even"]

Specified by:: patternMatch in interface Functor<T>
Parameters:: case1 - Function to generate a case (or chain of cases as a single case); otherwise - Value if supplied case doesn't match
Returns:: CollectionX where elements are transformed by pattern matching

count
```
default long count(java.util.function.Predicate<? super T> predicate)
```
Specified by:

count in interface org.jooq.lambda.Collectable<T>

Specified by:

count in interface CyclopsCollectable<T>

countDistinct
```
default long countDistinct(java.util.function.Predicate<? super T> predicate)
```
Specified by:

countDistinct in interface org.jooq.lambda.Collectable<T>

Specified by:

countDistinct in interface CyclopsCollectable<T>

countDistinctBy

default <U> long countDistinctBy(java.util.function.Function<? super T,? extends U> function,
                                 java.util.function.Predicate<? super U> predicate)

Specified by:: countDistinctBy in interface org.jooq.lambda.Collectable<T>
Specified by:: countDistinctBy in interface CyclopsCollectable<T>

countDistinct
```
default long countDistinct()
```
Specified by:

countDistinct in interface org.jooq.lambda.Collectable<T>

Specified by:

countDistinct in interface CyclopsCollectable<T>

countDistinctBy
```
default  long countDistinctBy(java.util.function.Function<? super T,? extends U> function)
```
Specified by:

countDistinctBy in interface org.jooq.lambda.Collectable<T>

Specified by:

countDistinctBy in interface CyclopsCollectable<T>

mode
```
default java.util.Optional<T> mode()
```
Specified by:

mode in interface org.jooq.lambda.Collectable<T>

Specified by:

mode in interface CyclopsCollectable<T>

sum
```
default java.util.Optional<T> sum()
```
Specified by:

sum in interface org.jooq.lambda.Collectable<T>

Specified by:

sum in interface CyclopsCollectable<T>

sum
```
default  java.util.Optional sum(java.util.function.Function<? super T,? extends U> function)
```
Specified by:

sum in interface org.jooq.lambda.Collectable<T>

Specified by:

sum in interface CyclopsCollectable<T>

sumInt
```
default int sumInt(java.util.function.ToIntFunction<? super T> function)
```
Specified by:

sumInt in interface org.jooq.lambda.Collectable<T>

Specified by:

sumInt in interface CyclopsCollectable<T>

sumLong
```
default long sumLong(java.util.function.ToLongFunction<? super T> function)
```
Specified by:

sumLong in interface org.jooq.lambda.Collectable<T>

Specified by:

sumLong in interface CyclopsCollectable<T>

sumDouble
```
default double sumDouble(java.util.function.ToDoubleFunction<? super T> function)
```
Specified by:

sumDouble in interface org.jooq.lambda.Collectable<T>

Specified by:

sumDouble in interface CyclopsCollectable<T>

avg
```
default java.util.Optional<T> avg()
```
Specified by:

avg in interface org.jooq.lambda.Collectable<T>

Specified by:

avg in interface CyclopsCollectable<T>

avg
```
default  java.util.Optional avg(java.util.function.Function<? super T,? extends U> function)
```
Specified by:

avg in interface org.jooq.lambda.Collectable<T>

Specified by:

avg in interface CyclopsCollectable<T>

avgInt
```
default double avgInt(java.util.function.ToIntFunction<? super T> function)
```
Specified by:

avgInt in interface org.jooq.lambda.Collectable<T>

Specified by:

avgInt in interface CyclopsCollectable<T>

avgLong
```
default double avgLong(java.util.function.ToLongFunction<? super T> function)
```
Specified by:

avgLong in interface org.jooq.lambda.Collectable<T>

Specified by:

avgLong in interface CyclopsCollectable<T>

avgDouble
```
default double avgDouble(java.util.function.ToDoubleFunction<? super T> function)
```
Specified by:

avgDouble in interface org.jooq.lambda.Collectable<T>

Specified by:

avgDouble in interface CyclopsCollectable<T>

min
```
default java.util.Optional<T> min()
```
Specified by:

min in interface org.jooq.lambda.Collectable<T>

Specified by:

min in interface CyclopsCollectable<T>

min

default <U extends java.lang.Comparable<? super U>> java.util.Optional<U> min(java.util.function.Function<? super T,? extends U> function)

Specified by:: min in interface org.jooq.lambda.Collectable<T>
Specified by:: min in interface CyclopsCollectable<T>

min

default <U> java.util.Optional<U> min(java.util.function.Function<? super T,? extends U> function,
                                      java.util.Comparator<? super U> comparator)

Specified by:: min in interface org.jooq.lambda.Collectable<T>
Specified by:: min in interface CyclopsCollectable<T>

minBy

default <U extends java.lang.Comparable<? super U>> java.util.Optional<T> minBy(java.util.function.Function<? super T,? extends U> function)

Specified by:: minBy in interface org.jooq.lambda.Collectable<T>
Specified by:: minBy in interface CyclopsCollectable<T>

minBy

default <U> java.util.Optional<T> minBy(java.util.function.Function<? super T,? extends U> function,
                                        java.util.Comparator<? super U> comparator)

Specified by:: minBy in interface org.jooq.lambda.Collectable<T>
Specified by:: minBy in interface CyclopsCollectable<T>

max
```
default java.util.Optional<T> max()
```
Specified by:

max in interface org.jooq.lambda.Collectable<T>

Specified by:

max in interface CyclopsCollectable<T>

max

default <U extends java.lang.Comparable<? super U>> java.util.Optional<U> max(java.util.function.Function<? super T,? extends U> function)

Specified by:: max in interface org.jooq.lambda.Collectable<T>
Specified by:: max in interface CyclopsCollectable<T>

max

default <U> java.util.Optional<U> max(java.util.function.Function<? super T,? extends U> function,
                                      java.util.Comparator<? super U> comparator)

Specified by:: max in interface org.jooq.lambda.Collectable<T>
Specified by:: max in interface CyclopsCollectable<T>

maxBy

default <U extends java.lang.Comparable<? super U>> java.util.Optional<T> maxBy(java.util.function.Function<? super T,? extends U> function)

Specified by:: maxBy in interface org.jooq.lambda.Collectable<T>
Specified by:: maxBy in interface CyclopsCollectable<T>

maxBy

default <U> java.util.Optional<T> maxBy(java.util.function.Function<? super T,? extends U> function,
                                        java.util.Comparator<? super U> comparator)

Specified by:: maxBy in interface org.jooq.lambda.Collectable<T>
Specified by:: maxBy in interface CyclopsCollectable<T>

median
```
default java.util.Optional<T> median()
```
Specified by:

median in interface org.jooq.lambda.Collectable<T>

Specified by:

median in interface CyclopsCollectable<T>

median
```
default java.util.Optional<T> median(java.util.Comparator<? super T> comparator)
```
Specified by:

median in interface org.jooq.lambda.Collectable<T>

Specified by:

median in interface CyclopsCollectable<T>

medianBy

default <U extends java.lang.Comparable<? super U>> java.util.Optional<T> medianBy(java.util.function.Function<? super T,? extends U> function)

Specified by:: medianBy in interface org.jooq.lambda.Collectable<T>
Specified by:: medianBy in interface CyclopsCollectable<T>

medianBy

default <U> java.util.Optional<T> medianBy(java.util.function.Function<? super T,? extends U> function,
                                           java.util.Comparator<? super U> comparator)

Specified by:: medianBy in interface org.jooq.lambda.Collectable<T>
Specified by:: medianBy in interface CyclopsCollectable<T>

percentile
```
default java.util.Optional<T> percentile(double percentile)
```
Specified by:

percentile in interface org.jooq.lambda.Collectable<T>

Specified by:

percentile in interface CyclopsCollectable<T>

percentile

default java.util.Optional<T> percentile(double percentile,
                                         java.util.Comparator<? super T> comparator)

Specified by:: percentile in interface org.jooq.lambda.Collectable<T>
Specified by:: percentile in interface CyclopsCollectable<T>

percentileBy

default <U extends java.lang.Comparable<? super U>> java.util.Optional<T> percentileBy(double percentile,
                                                                                       java.util.function.Function<? super T,? extends U> function)

Specified by:: percentileBy in interface org.jooq.lambda.Collectable<T>
Specified by:: percentileBy in interface CyclopsCollectable<T>

percentileBy

default <U> java.util.Optional<T> percentileBy(double percentile,
                                               java.util.function.Function<? super T,? extends U> function,
                                               java.util.Comparator<? super U> comparator)

Specified by:: percentileBy in interface org.jooq.lambda.Collectable<T>
Specified by:: percentileBy in interface CyclopsCollectable<T>

toList
```
default <L extends java.util.List<T>> L toList(java.util.function.Supplier<L> factory)
```
Specified by:

toList in interface org.jooq.lambda.Collectable<T>

Specified by:

toList in interface CyclopsCollectable<T>

toSet
```
default <S extends java.util.Set<T>> S toSet(java.util.function.Supplier<S> factory)
```
Specified by:

toSet in interface org.jooq.lambda.Collectable<T>

Specified by:

toSet in interface CyclopsCollectable<T>

toMap

default <K,V> java.util.Map<K,V> toMap(java.util.function.Function<? super T,? extends K> keyMapper,
                                       java.util.function.Function<? super T,? extends V> valueMapper)

Specified by:: toMap in interface org.jooq.lambda.Collectable<T>
Specified by:: toMap in interface CyclopsCollectable<T>

toString
```
default java.lang.String toString(java.lang.CharSequence delimiter)
```
Specified by:

toString in interface org.jooq.lambda.Collectable<T>

Specified by:

toString in interface CyclopsCollectable<T>

toString

default java.lang.String toString(java.lang.CharSequence delimiter,
                                  java.lang.CharSequence prefix,
                                  java.lang.CharSequence suffix)

Specified by:: toString in interface org.jooq.lambda.Collectable<T>
Specified by:: toString in interface CyclopsCollectable<T>

max
```
default java.util.Optional<T> max(java.util.Comparator<? super T> comparator)
```
Specified by:

max in interface org.jooq.lambda.Collectable<T>

Specified by:

max in interface CyclopsCollectable<T>

Specified by:

max in interface java.util.stream.Stream<T>

min
```
default java.util.Optional<T> min(java.util.Comparator<? super T> comparator)
```
Specified by:

min in interface org.jooq.lambda.Collectable<T>

Specified by:

min in interface CyclopsCollectable<T>

Specified by:

min in interface java.util.stream.Stream<T>

printErr
```
default void printErr()
```
Specified by:

printErr in interface Foldable<T>

Specified by:

printErr in interface org.jooq.lambda.Seq<T>

print
```
default void print(java.io.PrintWriter writer)
```
Specified by:

print in interface Foldable<T>

Specified by:

print in interface org.jooq.lambda.Seq<T>

print
```
default void print(java.io.PrintStream stream)
```
Specified by:

print in interface Foldable<T>

Specified by:

print in interface org.jooq.lambda.Seq<T>

Interface ReactiveSeq<T>

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.stream.Stream

Method Summary

Methods inherited from interface com.aol.cyclops.types.stream.JoolManipulation

Methods inherited from interface com.aol.cyclops.types.TransformerTraversable

Methods inherited from interface com.aol.cyclops.types.IterableFoldable

Methods inherited from interface com.aol.cyclops.types.stream.CyclopsCollectable

Methods inherited from interface com.aol.cyclops.types.stream.JoolWindowing

Methods inherited from interface org.jooq.lambda.Seq

Methods inherited from interface java.util.stream.Stream

Methods inherited from interface java.util.stream.BaseStream

Methods inherited from interface com.aol.cyclops.types.stream.reactive.ReactiveStreamsTerminalOperations

Methods inherited from interface com.aol.cyclops.types.applicative.zipping.ZippingApplicativable

Methods inherited from interface com.aol.cyclops.types.IterableFunctor

Methods inherited from interface com.aol.cyclops.types.Foldable

Methods inherited from interface com.aol.cyclops.types.Traversable

Methods inherited from interface com.aol.cyclops.types.stream.ConvertableSequence

Methods inherited from interface java.lang.Iterable

Method Detail

unitIterator

unit

foldRight

printOut

applicatives

ap1

zip

zip

zip

unwrap

flatten

cycle

cycle

duplicateSequence

triplicate

quadruplicate

splitSequenceAtHead

splitAt

splitBy

partitionSequence

cycle

cycleWhile

cycleUntil

zip

zip

zip

zip3

zip4

zipWithIndex

zipStream

sliding

sliding

grouped

groupedStatefullyWhile

groupedBySizeAndTime

groupedBySizeAndTime

groupedByTime

groupedByTime

grouped

groupedUntil

groupedWhile

groupedWhile

groupedUntil

grouped

grouped

groupBy

distinct

scanLeft

scanLeft

scanRight

scanRight

sorted

combine

sorted

takeWhile

dropWhile

takeUntil

dropUntil

dropRight

takeRight