ReactiveStreamX (cyclops-reactor 9.0.0-FINAL API)

java.lang.Object
- com.aol.cyclops2.internal.stream.BaseExtendedStream<T>
- - com.aol.cyclops2.internal.stream.ReactiveStreamX<T>

All Implemented Interfaces:

Convert<Higher<Witness.reactiveSeq,T>>, Higher<Witness.reactiveSeq,T>, Unit<T>, Filters<T>, CyclopsCollectable<T>, Folds<T>, To<ReactiveSeq<T>>, FilterableTransformable<T>, Transformable<T>, TransformerTraversable<T>, ReactiveStreamsTerminalOperations<T>, OnEmpty<T>, OnEmptySwitch<T,java.util.stream.Stream<T>>, ExtendedTraversable<T>, FoldableTraversable<T>, IterableFilterable<T>, Sequential<T>, Traversable<T>, Unwrapable, Zippable<T>, ReactiveSeq<T>, java.lang.AutoCloseable, java.lang.Iterable<T>, java.util.stream.BaseStream<T,java.util.stream.Stream<T>>, java.util.stream.Stream<T>, org.reactivestreams.Publisher<T>
```
public class ReactiveStreamX<T>
extends BaseExtendedStream<T>
```

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class ReactiveStreamX.Type
- Nested classes/interfaces inherited from interface cyclops.stream.ReactiveSeq
 ReactiveSeq.Instances
- Nested classes/interfaces inherited from interface java.util.stream.Stream
 java.util.stream.Stream.Builder<T>

Nested Classes
Modifier and Type	Class and Description
`static class`	`ReactiveStreamX.Type`

Constructor Summary

Constructors
Constructor and Description

ReactiveStreamX(Operator<T> source)

ReactiveStreamX(Operator<T> source, ReactiveStreamX.Type async)

Constructors
Constructor and Description
`ReactiveStreamX(Operator<T> source)`
`ReactiveStreamX(Operator<T> source, ReactiveStreamX.Type async)`

Method Summary

All Methods Static Methods Instance Methods Concrete 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
`boolean`	`anyMatch(java.util.function.Predicate<? super T> c)` True if a singleUnsafe element matches when Monad converted to a Stream
`ReactiveSeq<T>`	`append(java.lang.Iterable<? extends T> other)`
`ReactiveSeq<T>`	`append(T... other)` Append values to the take of this ReactiveSeq
`ReactiveSeq<T>`	`append(T other)`
`ReactiveSeq<T>`	`appendS(java.util.stream.Stream<? extends T> other)` Append Stream to this ReactiveSeq
`ReactiveSeq<T>`	`backpressureAware()`
`Topic<T>`	`broadcast()`
`ReactiveSeq<T>`	`changes()`
`<R> ReactiveSeq<R>`	`coflatMap(java.util.function.Function<? super ReactiveSeq<T>,? extends R> fn)` coflatMap pattern, can be used to perform maybe reductions / collections / folds and other terminal operations
`<R,A> R`	`collect(java.util.stream.Collector<? super T,A,R> collector)` Performs a mutable reduction operation on the elements of this reactiveStream using a `Collector`.
`<R> R`	`collect(java.util.function.Supplier<R> supplier, java.util.function.BiConsumer<R,? super T> accumulator, java.util.function.BiConsumer<R,R> combiner)` Performs a mutable reduction operation on the elements of this reactiveStream.
`<R,A> ReactiveSeq<R>`	`collectStream(java.util.stream.Collector<? super T,A,R> collector)`
`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 and reduction operation.
`ReactiveSeq<T>`	`complete(java.lang.Runnable fn)` Provide a simpler method to handle stream or async operations.
`long`	`count()` Returns the count of elements in this reactiveStream.
`protected <R> ReactiveSeq<R>`	`createSeq(java.util.stream.Stream<R> rStream)`
`ReactiveSeq<T>`	`cycle()` Convert to a Stream with the values infinitely cycled
`ReactiveSeq<T>`	`cycle(long times)` Convert to a Stream with the values repeated specified times
`ReactiveSeq<T>`	`distinct()`
`<U> ReactiveSeq<T>`	`distinct(java.util.function.Function<? super T,? extends U> keyExtractor)`
`org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>`	`duplicate()` Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading reactiveStream.
`org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>`	`duplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)`
`ReactiveSeq<T>`	`filter(java.util.function.Predicate<? super T> fn)` Keep only elements for which the supplied predicates hold e.g.
`ReactiveSeq<T>`	`filterLazyPredicate(java.util.function.Supplier<java.util.function.Predicate<? super T>> fn)`
`java.util.Optional<T>`	`findFirst()`
`static <T> java.util.Optional<T>`	`findFirstCallAll(ReactiveStreamX<T> stream)`
`Either<java.lang.Throwable,T>`	`findFirstOrError()` Lazy / reactiveBuffer look up of first value , capturing the first error, if one occurs.
`Maybe<T>`	`findOne()` Lazy / reactiveBuffer analogue of findFirst / findAny from JDK For push based reactiveBuffer-streams (created via Spouts.XXX) data will be pushed to the returned Maybe on arrival.
`<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<Witness.stream,? extends R>> fn)` Allows flatMap return type to be any Monad type
`<R> ReactiveSeq<R>`	`flatMapI(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>`	`flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)`
`<R> ReactiveSeq<R>`	`flatMapP(int maxConcurency, java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)`
`void`	`forEach(java.util.function.Consumer<? super T> action)` Performs an action for each element of this Stream.
`<X extends java.lang.Throwable> void`	`forEach(java.util.function.Consumer<? super T> consumerElement, java.util.function.Consumer<? super java.lang.Throwable> consumerError)` Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers,
`<X extends java.lang.Throwable> void`	`forEach(java.util.function.Consumer<? super T> consumerElement, java.util.function.Consumer<? super java.lang.Throwable> consumerError, java.lang.Runnable onComplete)` Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers when the entire Stream has been processed an onComplete event will be recieved.
`<X extends java.lang.Throwable> org.reactivestreams.Subscription`	`forEach(long numberOfElements, java.util.function.Consumer<? super T> consumer)` Perform a forEach operation over the Stream, without closing it, consuming only the specified number of elements from the Stream, at this time.
`<X extends java.lang.Throwable> org.reactivestreams.Subscription`	`forEach(long numberOfElements, java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.Throwable> consumerError)` Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time.
`<X extends java.lang.Throwable> org.reactivestreams.Subscription`	`forEach(long numberOfElements, java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.Throwable> consumerError, java.lang.Runnable onComplete)` Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time.
`void`	`forEachAsync(java.util.function.Consumer<? super T> action)` A potentially non-blocking analog of `ReactiveSeq.forEach(java.util.function.Consumer<? super T>)`.
`void`	`forEachOrdered(java.util.function.Consumer<? super T> consumer)`
`<X extends java.lang.Throwable> org.reactivestreams.Subscription`	`forEachSubscribe(java.util.function.Consumer<? super T> consumer)` Perform a forEach operation over the Stream, without closing it, consuming only the specified number of elements from the Stream, at this time.
`<X extends java.lang.Throwable> org.reactivestreams.Subscription`	`forEachSubscribe(java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.Throwable> consumerError)` Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time.
`<X extends java.lang.Throwable> org.reactivestreams.Subscription`	`forEachSubscribe(java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.Throwable> consumerError, java.lang.Runnable onComplete)` Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time.
`java.lang.String`	`format()`
`ReactiveStreamX.Type`	`getType()`
`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> factory)` Batch elements in a Stream by size into a toX 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 toX created by the supplied factory
`<C extends java.util.Collection<? super T>,R> ReactiveSeq<R>`	`groupedBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory, java.util.function.Function<? super C,? extends R> finalizer)`
`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 toX created by the supplied factory
`<C extends java.util.Collection<? super T>,R> ReactiveSeq<R>`	`groupedByTime(long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory, java.util.function.Function<? super C,? extends R> finalizer)`
`<C extends java.util.Collection<T>,R> ReactiveSeq<R>`	`groupedStatefullyUntil(java.util.function.BiPredicate<C,? super T> predicate, java.util.function.Supplier<C> factory, java.util.function.Function<? super C,? extends R> finalizer)`
`ReactiveSeq<ListX<T>>`	`groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)` Create ReactiveSeq of ListX where each ListX is populated while the supplied bipredicate holds.
`<C extends java.util.Collection<T>,R> ReactiveSeq<R>`	`groupedStatefullyWhile(java.util.function.BiPredicate<C,? super T> predicate, java.util.function.Supplier<C> factory, java.util.function.Function<? super C,? extends R> finalizer)`
`ReactiveSeq<ListX<T>>`	`groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)`
`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
`java.util.Iterator<T>`	`iterator()`
`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.
`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
`ReactiveSeq<T>`	`limitWhileClosed(java.util.function.Predicate<? super T> predicate)`
`<R> ReactiveSeq<R>`	`map(java.util.function.Function<? super T,? extends R> fn)` Transform this functor using the supplied transformation function
`<R> ReactiveSeq<R>`	`mapLazyFn(java.util.function.Supplier<java.util.function.Function<? super T,? extends R>> fn)`
`ReactiveSeq<T>`	`mergeP(org.reactivestreams.Publisher<T>... publishers)` A potentially asynchronous merge operation where data from each publisher may arrive out of order (if publishers are configured to publish asynchronously, users can use the overloaded @see `IterableFunctor#mergePublisher(Collection, QueueFactory)` method to forEachAsync asynchronously also.
`ReactiveSeq<T>`	`mergeP(QueueFactory<T> factory, org.reactivestreams.Publisher<T>... publishers)` A potentially asynchronous merge operation where data from each publisher may arrive out of order (if publishers are configured to publish asynchronously.
`ListX<ReactiveSeq<T>>`	`multicast(int num)` Broadcast the contents of this Stream to multiple downstream Streams (determined by supplier parameter).
`ReactiveSeq<T>`	`onEmpty(T value)` If this Container instance is zero, create a new instance containing the provided value
`ReactiveSeq<T>`	`onEmptyGet(java.util.function.Supplier<? extends T> supplier)` If this Container instance is zero, create a new instance containing the value returned from the provided Supplier
`ReactiveSeq<T>`	`onEmptySwitch(java.util.function.Supplier<? extends java.util.stream.Stream<T>> switchTo)` If this ReactiveSeq is empty one it with a another Stream
`<X extends java.lang.Throwable> ReactiveSeq<T>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)` If this container instance is zero, throw the exception returned by the provided Supplier
`org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>`	`partition(java.util.function.Predicate<? super T> splitter)` Partition a Stream into two one a per element basis, based on predicate's boolean value
`ReactiveSeq<T>`	`prepend(java.lang.Iterable<? extends T> other)`
`ReactiveSeq<T>`	`prepend(T... other)` Prepend given values to the skip of the Stream
`ReactiveSeq<T>`	`prepend(T other)`
`ReactiveSeq<T>`	`prependS(java.util.stream.Stream<? extends T> other)` Prepend Stream to this ReactiveSeq
`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 reactiveStream.
`org.jooq.lambda.tuple.Tuple4<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>>`	`quadruplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)`
`<EX extends java.lang.Throwable> ReactiveSeq<T>`	`recover(java.lang.Class<EX> exceptionClass, java.util.function.Function<? super EX,? extends T> fn)` Recover from a particular exception type
`ReactiveSeq<T>`	`recover(java.util.function.Function<? super 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)` An equivalent function to `Stream.reduce(BinaryOperator)`
`T`	`reduce(T identity, java.util.function.BinaryOperator<T> accumulator)` An equivalent function to `Stream.reduce(Object, BinaryOperator)`
`<U> U`	`reduce(U identity, java.util.function.BiFunction<U,? super T,U> accumulator, java.util.function.BinaryOperator<U> combiner)` An equivalent function to `Stream.reduce(Object, BiFunction, BinaryOperator)`
`ReactiveSeq<T>`	`reduceAll(T identity, java.util.function.BinaryOperator<T> accumulator)`
`ReactiveSeq<T>`	`reverse()` Potentially efficient Stream reversal.
`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
`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
`Maybe<T>`	`single()` `//Maybe[1] ReactiveSeq.of(1).singleUnsafe(); //Maybe.none ReactiveSeq.of().singleUnsafe(); //Maybe.none ReactiveSeq.of(1,2,3).singleUnsafe();`
`Maybe<T>`	`single(java.util.function.Predicate<? super T> predicate)`
`T`	`singleUnsafe()` `//1 ReactiveSeq.of(1).singleUsafe(); //UnsupportedOperationException ReactiveSeq.of().singleUnsafe(); //UnsupportedOperationException ReactiveSeq.of(1,2,3).singleUnsafe();`
`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(CyclopsCollectors.toList()),equalTo(Arrays.asList(1,2,3)));
`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>`	`skipWhileClosed(java.util.function.Predicate<? super T> predicate)`
`ReactiveSeq<VectorX<T>>`	`sliding(int windowSize, int increment)` Create a sliding view over this Sequence
`org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>`	`splitAt(int where)` Split at supplied location
`org.jooq.lambda.tuple.Tuple2<java.util.Optional<T>,ReactiveSeq<T>>`	`splitAtHead()` Split a Stream at it's head (similar to headAndTail)
`org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>`	`splitBy(java.util.function.Predicate<T> splitter)` Split reactiveStream at point where predicate no longer holds
`java.util.Spliterator<T>`	`spliterator()` Returns a spliterator for the elements of this reactiveStream.
`void`	`subscribe(org.reactivestreams.Subscriber<? super T> sub)`
`Maybe<T>`	`takeOne()`
`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 reactiveStream.
`org.jooq.lambda.tuple.Tuple3<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>>`	`triplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)`
`<T> ReactiveSeq<T>`	`unit(T unit)`
`<U> ReactiveSeq<U>`	`unitIterator(java.util.Iterator<U> it)` Create an IterableFunctor instance of the same type from an Iterator
`java.util.stream.Stream<T>`	`unwrapStream()`
`<R> R`	`visit(java.util.function.Function<? super ReactiveSeq<T>,? extends R> sync, java.util.function.Function<? super ReactiveSeq<T>,? extends R> reactiveStreams, java.util.function.Function<? super ReactiveSeq<T>,? extends R> asyncNoBackPressure)`
`<S,U> ReactiveSeq<org.jooq.lambda.tuple.Tuple3<T,S,U>>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third)` zip 3 Streams into one
`<T2,T3,T4> ReactiveSeq<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>`	`zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth)` zip 4 Streams into 1
`<U,R> ReactiveSeq<R>`	`zipLatest(org.reactivestreams.Publisher<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`<U> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipS(java.util.stream.Stream<? extends U> other)` Zip 2 streams into one
`<U,R> ReactiveSeq<R>`	`zipS(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Stream, using the supplied combining function

Methods inherited from class com.aol.cyclops2.internal.stream.BaseExtendedStream
anyM, close, debounce, endsWith, endsWithIterable, findAny, firstValue, fixedDelay, flatMapBufferedReader, flatMapCharSequence, flatMapCompletableFuture, flatMapFile, flatMapOptional, flatMapStream, flatMapToDouble, flatMapToInt, flatMapToLong, flatMapURL, foldLeft, foldLeft, foldLeftMapToType, foldRight, foldRight, foldRight, foldRightMapToType, headAndTail, isParallel, jitter, join, join, join, mapReduce, mapReduce, mapToDouble, mapToInt, mapToLong, max, maxBy, min, minBy, noneMatch, onClose, onePer, parallel, reduce, reduce, reduce, sequential, sorted, startsWith, startsWithIterable, stream, toArray, toArray, toList, toSet, unordered, xMatch, xPer

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface com.aol.cyclops2.types.Unwrapable
unwrap, unwrapIfInstance, unwrapNested

Methods inherited from interface cyclops.stream.ReactiveSeq
allTypeclasses, allTypeclasses, ambWith, ambWith, cast, collectAll, combinations, combinations, combinationsT, combinationsT, combine, concat, concat, concat, concat, concatDoubles, concatInts, concatLongs, coproduct, crossJoin, cycle, cycleUntil, cycleWhile, deferred, deferredI, deferredP, deleteBetween, doubles, drop, dropRight, dropUntil, dropWhile, elapsed, elementAt, empty, enqueued, enqueued, enqueued, enqueuedAll, enums, enums, enums, enumsFromTo, fanOut, fanOut, fanOut, fanOutZipIn, fanOutZipIn, fanOutZipIn, fill, filterInts, filterLongs, filterLongs, filterNot, flatMapDoubles, flatMapInts, flatMapLongs, flatten, flattenI, flattenO, foldJool, foldParallel, foldParallel, forEach2, forEach2, forEach3, forEach3, forEach4, forEach4, fromCharSequence, fromDoubleStream, fromIntStream, fromIterable, fromIterator, fromList, fromLongStream, fromPublisher, fromSpliterator, fromStream, generate, generate, get, groupBy, grouped, grouped, groupedUntil, groupedUntil, hotStream, insertAt, insertAtS, intersperse, ints, isEmpty, isReplayable, iterate, iterate, jool, kindCokleisli, kindKleisli, liftM, limitDouble, limitInts, limitLongs, limitUntilClosed, longs, mapDoubles, mapInts, mapLongs, mapM, merge, narrowK, nested, notNull, of, of, ofDoubles, ofInts, ofLongs, ofNullable, ofType, oneShotList, oneShotStream, parallel, parallel, parallelFanOut, parallelFanOut, parallelFanOut, parallelFanOutZipIn, parallelFanOutZipIn, parallelFanOutZipIn, pausableHotStream, peek, permutations, permutationsT, primedHotStream, primedPausableHotStream, print, print, printErr, printOut, product, product, publishTo, publishTo, range, range, rangeLong, rangeLong, reactiveSeq, reduce, remove, removeAll, removeAllI, removeAllS, retainAll, retainAllI, retainAllS, retry, retry, reversedListOf, reversedOf, scanRight, scanRight, seq, shuffle, shuffle, size, skipDoubles, skipInts, skipLongs, skipUntil, skipUntilClosed, slice, sliding, sorted, sorted, sorted, subStream, tailRec, take, takeRight, takeUntil, takeWhile, timestamp, trampoline, unfold, unzip, unzip3, unzip4, widen, zip, zip, zip, zip3, zip4, zipP, zipP, zipWith, zipWithIndex, zipWithP, zipWithS

Methods inherited from interface com.aol.cyclops2.types.foldable.To
to

Methods inherited from interface java.util.stream.Stream
builder

Methods inherited from interface com.aol.cyclops2.types.traversable.FoldableTraversable
asFunction, foldFuture, foldLazy, foldTry, runFuture, runLazy, toListX, toSetX, visit

Methods inherited from interface com.aol.cyclops2.types.foldable.CyclopsCollectable
collectors, commonPrefix, commonSuffix, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, mode, sum, sumDouble, sumInt, sumLong, to, toMap, toMap, toString, toString

Methods inherited from interface com.aol.cyclops2.types.foldable.Folds
foldLeft, foldLeft

Methods inherited from interface com.aol.cyclops2.types.traversable.Traversable
traversable

Methods inherited from interface com.aol.cyclops2.types.functor.TransformerTraversable
groupedStatefullyUntilT, groupedT, groupedUntilT, groupedWhileT, slidingT, slidingT

Methods inherited from interface com.aol.cyclops2.hkt.Higher
applyHKT_, applyHKT, applyHKT

Methods inherited from interface com.aol.cyclops2.hkt.Convert
convert

Constructor Detail

ReactiveStreamX

public ReactiveStreamX(Operator<T> source)

ReactiveStreamX

public ReactiveStreamX(Operator<T> source,
                       ReactiveStreamX.Type async)

Method Detail

getType
```
public ReactiveStreamX.Type getType()
```

reverse
```
public ReactiveSeq<T> reverse()
```
Description copied from interface: Traversable
Potentially efficient Stream reversal. Is efficient if - Sequence created via a range - Sequence created via a List - Sequence created via an Array / var args Otherwise Sequence collected into a Collection prior to reversal
```
 assertThat( of(1, 2, 3).reverse().toList(),
 equalTo(asList(3, 2, 1))); 
```

combine
```
public 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 and reduction operation. The emitted of a combination may in turn be combined with it's neighbour
```
 
 ReactiveSeq.of(1,1,2,3)
 .combine((a, b)->a.equals(b),SemigroupK.intSum)
 .listX()
 
 //ListX(3,4) 
 
```
Parameters:

predicate - Test to see if two neighbours should be joined. The first parameter to the bi-predicate is the currently accumulated result and the second is the next element

op - BinaryOperator to combine neighbours

Returns:

Combined / Partially Reduced Traversable

reduceAll

public ReactiveSeq<T> reduceAll(T identity,
                                java.util.function.BinaryOperator<T> accumulator)

collectStream

public <R,A> ReactiveSeq<R> collectStream(java.util.stream.Collector<? super T,A,R> collector)

iterator

public java.util.Iterator<T> iterator()

coflatMap

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

Description copied from interface: ReactiveSeq

coflatMap pattern, can be used to perform maybe reductions / collections / folds and other terminal operations

 

      ReactiveSeq.of(1,2,3)
                 .map(i->i*2)
                 .coflatMap(s -> s.reduce(0,(a,b)->a+b))

      //ReactiveSeq[12]

Returns:

findOne
```
public Maybe<T> findOne()
```
Description copied from interface: ReactiveSeq

Lazy / reactiveBuffer analogue of findFirst / findAny from JDK For push based reactiveBuffer-streams (created via Spouts.XXX) data will be pushed to the returned Maybe on arrival. For pull based Streams (created via ReactiveSeq.XXX) the Stream will be executed when the Maybe is first accessed.

Returns:

findFirstOrError
```
public Either<java.lang.Throwable,T> findFirstOrError()
```
Description copied from interface: ReactiveSeq

Lazy / reactiveBuffer look up of first value , capturing the first error, if one occurs. If no values are present a NoSuchElementException is returned. For push based reactiveBuffer-streams (created via Spouts.XXX) data will be pushed to the returned Either on arrival. For pull based Streams (created via ReactiveSeq.XXX) the Stream will be executed when the Either is first accessed.

Returns:

findFirst

public final java.util.Optional<T> findFirst()

Returns:

First matching element in sequential order

 
 ReactiveSeq.of(1,2,3,4,5).filter(it -> it <3).findFirst().get();

 //3

(deterministic)

findFirstCallAll

public static final <T> java.util.Optional<T> findFirstCallAll(ReactiveStreamX<T> stream)

sliding

public final ReactiveSeq<VectorX<T>> sliding(int windowSize,
                                             int increment)

Description copied from interface: ReactiveSeq

Create a sliding view over this Sequence

 
  List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(3, 2).collect(CyclopsCollectors.toList());

  assertThat(list.get(0), hasItems(1, 2, 3));
  assertThat(list.get(1), hasItems(3, 4, 5));

Parameters:: windowSize - number of elements in each batch; increment - for each window
Returns:: ReactiveSeq with sliding view

grouped

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

Description copied from interface: ReactiveSeq

Group elements in a Stream

 
  List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).grouped(3).collect(CyclopsCollectors.toList());

  assertThat(list.get(0), hasItems(1, 2, 3));
  assertThat(list.get(1), hasItems(4, 5, 6));

Parameters:: groupSize - Size of each Group
Returns:: Stream with elements grouped by size

groupedStatefullyWhile

public ReactiveSeq<ListX<T>> groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)

groupedStatefullyWhile

public <C extends java.util.Collection<T>,R> ReactiveSeq<R> groupedStatefullyWhile(java.util.function.BiPredicate<C,? super T> predicate,
                                                                                   java.util.function.Supplier<C> factory,
                                                                                   java.util.function.Function<? super C,? extends R> finalizer)

groupedStatefullyUntil
```
public ReactiveSeq<ListX<T>> groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
```
Description copied from interface: ReactiveSeq
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
```
 
 ReactiveSeq.of(1,2,3,4,5,6)
 .groupedStatefullyUntil((s,i)-> s.contains(4) ? true : false)
 .toList()
 .size()
 //5
 
 
```
Parameters:

predicate - Window while true

Returns:

ReactiveSeq windowed while predicate holds

groupedStatefullyUntil

public <C extends java.util.Collection<T>,R> ReactiveSeq<R> groupedStatefullyUntil(java.util.function.BiPredicate<C,? super T> predicate,
                                                                                   java.util.function.Supplier<C> factory,
                                                                                   java.util.function.Function<? super C,? extends R> finalizer)

distinct

public final ReactiveSeq<T> distinct()

scanLeft

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

Description copied from interface: ReactiveSeq

Scan left using supplied Monoid

 

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

Returns:: ReactiveSeq with values combined scanning left

scanLeft

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

Description copied from interface: ReactiveSeq

Scan left

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

skipWhile
```
public final ReactiveSeq<T> skipWhile(java.util.function.Predicate<? super T> p)
```
Description copied from interface: ReactiveSeq
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)));
 
 
```
Parameters:

p - Predicate to skip while true

Returns:

Stream with elements skipped while predicate holds

limitWhile
```
public final ReactiveSeq<T> limitWhile(java.util.function.Predicate<? super T> p)
```
Description copied from interface: ReactiveSeq
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)));
 
```
Parameters:

p - Limit while predicate is true

Returns:

Stream with limited elements

limitUntil
```
public final ReactiveSeq<T> limitUntil(java.util.function.Predicate<? super T> p)
```
Description copied from interface: ReactiveSeq
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))); 
 
```
Parameters:

p - Limit until predicate is true

Returns:

Stream with limited elements

skipWhileClosed

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

limitWhileClosed

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

format
```
public java.lang.String format()
```

map
```
public final <R> ReactiveSeq<R> map(java.util.function.Function<? super T,? extends R> fn)
```
Description copied from interface: Transformable
Transform this functor using the supplied transformation function
```
 


 of(1,2,3).map(i->i*2)

 //[2,4,6]

 
 
```
Parameters:

fn - Transformation function

Returns:

Transformed Transformable

flatMap

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

Description copied from interface: ReactiveSeq

flatMap operation

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

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

flatMapAnyM

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

Description copied from interface: ReactiveSeq

Allows flatMap return type to be any Monad type

 
 	assertThat(ReactiveSeq.of(1,2,3)).flatMapAnyM(i-> fromEither5(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

flatMapI

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

Description copied from interface: ReactiveSeq

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

Returns:

flatMapP

public final <R> ReactiveSeq<R> flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)

flatMapP

public final <R> ReactiveSeq<R> flatMapP(int maxConcurency,
                                         java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)

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

fn - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

spliterator
```
public java.util.Spliterator<T> spliterator()
```
Description copied from interface: ReactiveSeq

Returns a spliterator for the elements of this reactiveStream.

This is a terminal operation.

Returns:

the element spliterator for this reactiveStream

unwrapStream
```
public java.util.stream.Stream<T> unwrapStream()
```
Specified by:

unwrapStream in class BaseExtendedStream<T>

createSeq

protected <R> ReactiveSeq<R> createSeq(java.util.stream.Stream<R> rStream)

Specified by:: createSeq in class BaseExtendedStream<T>

mapLazyFn

public <R> ReactiveSeq<R> mapLazyFn(java.util.function.Supplier<java.util.function.Function<? super T,? extends R>> fn)

Specified by:: mapLazyFn in class BaseExtendedStream<T>

filterLazyPredicate

public final ReactiveSeq<T> filterLazyPredicate(java.util.function.Supplier<java.util.function.Predicate<? super T>> fn)

Specified by:: filterLazyPredicate in class BaseExtendedStream<T>

changes
```
public ReactiveSeq<T> changes()
```
Returns:

A Stream that contains only changes in the values in the current Stream, useful for converting a Continuous sequence into one with discrete steps

zipLatest

public <U,R> ReactiveSeq<R> zipLatest(org.reactivestreams.Publisher<? extends U> other,
                                      java.util.function.BiFunction<? super T,? super U,? extends R> zipper)

forEachAsync
```
public void forEachAsync(java.util.function.Consumer<? super T> action)
```
Description copied from interface: ReactiveSeq

A potentially non-blocking analog of ReactiveSeq.forEach(java.util.function.Consumer<? super T>). For push based reactiveBuffer Stream types (created via Spouts or FutureStream)

Parameters:

action - a non-interfering action to perform on the elements

forEach
```
public void forEach(java.util.function.Consumer<? super T> action)
```
Description copied from interface: ReactiveSeq

Performs an action for each element of this Stream. For potentially non-blocking analogs see ReactiveSeq.forEachAsync(Consumer) and forEach overloads such as FoldableTraversable.forEach(Consumer, Consumer) and FoldableTraversable.forEach(Consumer, Consumer,Runnable) This method overrides the JDK Stream.forEach(Consumer) and maintains it's blocking semantics. Other forEach overloads in ReactiveSeq are non-blocking for asynchronously executing Streams.

This is a terminal operation.

The behavior of this operation is explicitly nondeterministic. For parallel reactiveStream pipelines, this operation does not guarantee to respect the encounter order of the reactiveStream, as doing so would sacrifice the benefit of parallelism. For any given element, the action may be performed at whatever time and in whatever thread the library chooses. If the action accesses shared state, it is responsible for providing the required synchronization.

Parameters:

action - a non-interfering action to perform on the elements

count
```
public long count()
```
Description copied from interface: ReactiveSeq
Returns the count of elements in this reactiveStream. This is a special case of a reduction and is equivalent to:
```
     return mapToLong(e -> 1L).sum();
 
```
This is a terminal operation.
Returns:

the count of elements in this reactiveStream

unitIterator
```
public  ReactiveSeq unitIterator(java.util.Iterator it)
```
Description copied from interface: Traversable
Create an IterableFunctor instance of the same type from an Iterator
```
 
 ReactiveSeq<Integer> newSeq = seq.unitIterable(myIterator);

 
 
```
Parameters:

it - Iterator to create new IterableFunctor from

Returns:

New IterableFunctor instance

backpressureAware

public ReactiveSeq<T> backpressureAware()

public void subscribe(org.reactivestreams.Subscriber<? super T> sub)

onEmpty
```
public ReactiveSeq<T> onEmpty(T value)
```
Description copied from interface: OnEmpty

If this Container instance is zero, create a new instance containing the provided value

Returns:

New instance containing value if container is zero, otherwise returns this container

onEmptySwitch

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

Description copied from interface: ReactiveSeq

If this ReactiveSeq is empty one 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

onEmptyGet
```
public ReactiveSeq<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
```
Description copied from interface: OnEmpty

If this Container instance is zero, create a new instance containing the value returned from the provided Supplier

Parameters:

supplier - to determine new value for container

Returns:

New Container with value if this is zero, otherwise this container

onEmptyThrow
```
public <X extends java.lang.Throwable> ReactiveSeq<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
```
Description copied from interface: OnEmpty

If this container instance is zero, throw the exception returned by the provided Supplier

Parameters:

supplier - to create exception from

Returns:

Throw exception if zero, otherwise this container

appendS

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

Description copied from interface: ReactiveSeq

Append Stream to this ReactiveSeq

 
  List<String> result = ReactiveSeq.of(1, 2, 3).appendStream(ReactiveSeq.of(100, 200, 300)).map(it -> it + "!!").collect(CyclopsCollectors.toList());

  assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "3!!", "100!!", "200!!", "300!!")));     *

Returns:: ReactiveSeq with Stream appended

append

public ReactiveSeq<T> append(java.lang.Iterable<? extends T> other)

append

public ReactiveSeq<T> append(T other)

append

public ReactiveSeq<T> append(T... other)

Description copied from interface: ReactiveSeq

Append values to the take of this ReactiveSeq

 
  List<String> result = ReactiveSeq.of(1, 2, 3).append(100, 200, 300).map(it -> it + "!!").collect(CyclopsCollectors.toList());

  assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "3!!", "100!!", "200!!", "300!!")));     *

Parameters:: other - to append
Returns:: ReactiveSeq with appended values

prependS

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

Description copied from interface: ReactiveSeq

Prepend Stream to this ReactiveSeq

 
  List<String> result = ReactiveSeq.of(1, 2, 3)
                                   .prependS(of(100, 200, 300))
                                   .map(it -> it + "!!")
                                   .collect(CyclopsCollectors.toList());

  assertThat(result, equalTo(Arrays.asList("100!!", "200!!", "300!!", "1!!", "2!!", "3!!")));

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

prepend

public ReactiveSeq<T> prepend(java.lang.Iterable<? extends T> other)

prepend

public ReactiveSeq<T> prepend(T other)

prepend

public ReactiveSeq<T> prepend(T... other)

Description copied from interface: ReactiveSeq

Prepend given values to the skip of the Stream

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

 			assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));

Parameters:: other - to prepend
Returns:: ReactiveSeq with values prepended

distinct

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

groupedBySizeAndTime

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

Description copied from interface: ReactiveSeq

Batch elements by size into a List

 
 ReactiveSeq.of(1,2,3,4,5,6)
              .groupedBySizeAndTime(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 singleUnsafe batch in; t - time unit for batch
Returns:: ReactiveSeq batched by size and time

groupedByTime

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

Description copied from interface: ReactiveSeq

Batch elements in a Stream by time period

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

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

skip

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

Description copied from interface: ReactiveSeq

Skip all elements until specified time period has passed

 
  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

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

Description copied from interface: ReactiveSeq

Return all elements until specified time period has elapsed

 
  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

groupedWhile
```
public ReactiveSeq<ListX<T>> groupedWhile(java.util.function.Predicate<? super T> predicate)
```
Description copied from interface: ReactiveSeq
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));

 
 
```
Parameters:

predicate - Batch while predicate holds, applyHKT open next batch

Returns:

ReactiveSeq batched into lists determined by the predicate supplied

groupedWhile

public <C extends java.util.Collection<? super T>> ReactiveSeq<C> groupedWhile(java.util.function.Predicate<? super T> predicate,
                                                                               java.util.function.Supplier<C> factory)

Description copied from interface: ReactiveSeq

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

Parameters:: predicate - Batch while predicate holds, applyHKT open next batch; factory - Collection factory
Returns:: ReactiveSeq batched into collections determined by the predicate supplied

groupedBySizeAndTime

public <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)

Description copied from interface: ReactiveSeq

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

 
 ReactiveSeq.of(1,2,3,4,5,6)
              .groupedBySizeAndTime(3,10,TimeUnit.SECONDS,()->SetX.empty())
              .toList();

 //[[1,2,3],[4,5,6]]

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

groupedBySizeAndTime

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

groupedByTime

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

groupedByTime

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

Description copied from interface: ReactiveSeq

Batch elements by time into a toX 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 singleUnsafe batch in; unit - time unit for batch; factory - Collection factory
Returns:: ReactiveSeq batched into toX types by time period

grouped

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

Description copied from interface: ReactiveSeq

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

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

Parameters:: size - batch size; factory - Collection factory
Returns:: ReactiveSeq batched into toX types by size

skipLast
```
public ReactiveSeq<T> skipLast(int num)
```
Description copied from interface: ReactiveSeq

assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(1,2,3)));

Returns:

limitLast
```
public ReactiveSeq<T> limitLast(int num)
```
Description copied from interface: ReactiveSeq
Limit results to the last x elements in a ReactiveSeq
```
 
 	assertThat(ReactiveSeq.of(1,2,3,4,5)
 							.limitLast(2)
 							.collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(4,5)));

 
```
Parameters:

num - of elements to return (last elements)

Returns:

ReactiveSeq limited to last num elements

complete
```
public ReactiveSeq<T> complete(java.lang.Runnable fn)
```
Description copied from interface: ReactiveSeq

Provide a simpler method to handle stream or async operations.

Parameters:

fn - Function that accepts and returns completed value

Returns:

ReactiveSeq that can handle stream or async operations simpler

recover

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

Description copied from interface: ReactiveSeq

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

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

Description copied from interface: ReactiveSeq

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:: ReactiveSeq that can recover from a particular exception

forEachOrdered
```
public void forEachOrdered(java.util.function.Consumer<? super T> consumer)
```
Specified by:

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

Overrides:

forEachOrdered in class BaseExtendedStream<T>

forEachSubscribe

public <X extends java.lang.Throwable> org.reactivestreams.Subscription forEachSubscribe(java.util.function.Consumer<? super T> consumer)

Description copied from interface: ReactiveStreamsTerminalOperations

Perform a forEach operation over the Stream, without closing it, consuming only the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription e.g.

 
     Subscription next = Spouts.of(1,2,3,4)
          					    .forEachSubscribe(System.out::println);

     next.request(2);
     Thread.sleep(500);
     System.out.println("First batch processed!");

     next.request(2);

      System.out.println("Second batch processed!");

     //prints
     1
     2
     First batch processed!
     3
     4
     Second batch processed!

Parameters:: consumer - To accept incoming events from the Stream
Returns:: Subscription so that further processing can be continued or cancelled.

forEachSubscribe

public <X extends java.lang.Throwable> org.reactivestreams.Subscription forEachSubscribe(java.util.function.Consumer<? super T> consumer,
                                                                                         java.util.function.Consumer<? super java.lang.Throwable> consumerError)

Description copied from interface: ReactiveStreamsTerminalOperations

Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription

 
     Subscription next = ReactiveSeq.of(()->1,()->2,()->throw new RuntimeException(),()->4)
                                  .map(Supplier::get)
          					    .forEachSubscribe(System.out::println, e->e.printStackTrace());

      next.request(2);
     System.out.println("First batch processed!");

     next.request(2);

      System.out.println("Second batch processed!");

     //prints
     1
     2
     First batch processed!

     RuntimeException Stack Trace on System.err

     4
     Second batch processed!

Parameters:: consumer - To accept incoming elements from the Stream; consumerError - To accept incoming processing errors from the Stream
Returns:: Subscription so that further processing can be continued or cancelled.

forEachSubscribe

public <X extends java.lang.Throwable> org.reactivestreams.Subscription forEachSubscribe(java.util.function.Consumer<? super T> consumer,
                                                                                         java.util.function.Consumer<? super java.lang.Throwable> consumerError,
                                                                                         java.lang.Runnable onComplete)

Description copied from interface: ReactiveStreamsTerminalOperations

 
     Subscription next = ReactiveSeq.of(()->1,()->2,()->throw new RuntimeException(),()->4)
                                  .map(Supplier::get)
          					    .forEachSubscribe(System.out::println, e->e.printStackTrace(),()->System.out.println("the take!"));

      next.request(2);
     System.out.println("First batch processed!");

     next.request(2);

      System.out.println("Second batch processed!");

     //prints
     1
     2
     First batch processed!

     RuntimeException Stack Trace on System.err

     4
     Second batch processed!
     The take!

Parameters:: consumer - To accept incoming elements from the Stream; consumerError - To accept incoming processing errors from the Stream; onComplete - To run after an onComplete event
Returns:: Subscription so that further processing can be continued or cancelled.

forEach

public <X extends java.lang.Throwable> org.reactivestreams.Subscription forEach(long numberOfElements,
                                                                                java.util.function.Consumer<? super T> consumer)

Description copied from interface: ReactiveStreamsTerminalOperations

 
     Subscription next = ReactiveSeq.of(1,2,3,4)
          					    .forEach(2,System.out::println);
          
     System.out.println("First batch processed!");
     
     next.request(2);
     
      System.out.println("Second batch processed!");
      
     //prints
     1
     2
     First batch processed!
     3
     4 
     Second batch processed!

Parameters:: numberOfElements - To consume from the Stream at this time; consumer - To accept incoming events from the Stream
Returns:: Subscription so that further processing can be continued or cancelled.

forEach

public <X extends java.lang.Throwable> org.reactivestreams.Subscription forEach(long numberOfElements,
                                                                                java.util.function.Consumer<? super T> consumer,
                                                                                java.util.function.Consumer<? super java.lang.Throwable> consumerError)

Description copied from interface: ReactiveStreamsTerminalOperations

 
     Subscription next = ReactiveSeq.of(()->1,()->2,()->throw new RuntimeException(),()->4)
                                  .map(Supplier::get)
          					    .forEach(2,System.out::println, e->e.printStackTrace());
          
     System.out.println("First batch processed!");
     
     next.request(2);
     
      System.out.println("Second batch processed!");
      
     //prints
     1
     2
     First batch processed!
     
     RuntimeException Stack Trace on System.err
     
     4 
     Second batch processed!

Parameters:: numberOfElements - To consume from the Stream at this time; consumer - To accept incoming elements from the Stream; consumerError - To accept incoming processing errors from the Stream
Returns:: Subscription so that further processing can be continued or cancelled.

forEach

public <X extends java.lang.Throwable> org.reactivestreams.Subscription forEach(long numberOfElements,
                                                                                java.util.function.Consumer<? super T> consumer,
                                                                                java.util.function.Consumer<? super java.lang.Throwable> consumerError,
                                                                                java.lang.Runnable onComplete)

Description copied from interface: ReactiveStreamsTerminalOperations

 
     Subscription next = ReactiveSeq.of(()->1,()->2,()->throw new RuntimeException(),()->4)
                                  .map(Supplier::get)
          					    .forEach(2,System.out::println, e->e.printStackTrace(),()->System.out.println("the take!"));
          
     System.out.println("First batch processed!");
     
     next.request(2);
     
      System.out.println("Second batch processed!");
      
     //prints
     1
     2
     First batch processed!
     
     RuntimeException Stack Trace on System.err
     
     4 
     Second batch processed!
     The take!

Parameters:: numberOfElements - To consume from the Stream at this time; consumer - To accept incoming elements from the Stream; consumerError - To accept incoming processing errors from the Stream; onComplete - To run after an onComplete event
Returns:: Subscription so that further processing can be continued or cancelled.

forEach

public <X extends java.lang.Throwable> void forEach(java.util.function.Consumer<? super T> consumerElement,
                                                    java.util.function.Consumer<? super java.lang.Throwable> consumerError)

Description copied from interface: ReactiveStreamsTerminalOperations

Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers,

 
     Subscription next = ReactiveSeq.of(()->1,()->2,()->throw new RuntimeException(),()->4)
                                  .map(Supplier::get)
          					    .forEach(System.out::println, e->e.printStackTrace());
          
     System.out.println("processed!");
     
    
      
     //prints
     1
     2
     RuntimeException Stack Trace on System.err
     4
     processed!

Parameters:: consumerElement - To accept incoming elements from the Stream; consumerError - To accept incoming processing errors from the Stream

forEach

public <X extends java.lang.Throwable> void forEach(java.util.function.Consumer<? super T> consumerElement,
                                                    java.util.function.Consumer<? super java.lang.Throwable> consumerError,
                                                    java.lang.Runnable onComplete)

Description copied from interface: ReactiveStreamsTerminalOperations

Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers when the entire Stream has been processed an onComplete event will be recieved.

 
     Subscription next = ReactiveSeq.of(()->1,()->2,()->throw new RuntimeException(),()->4)
                                  .map(Supplier::get)
          					    .forEachEvents(System.out::println, e->e.printStackTrace(),()->System.out.println("the take!"));
          
     System.out.println("processed!");
     
      
     //prints
     1
     2
     RuntimeException Stack Trace on System.err
      4 
     processed!

Parameters:: consumerElement - To accept incoming elements from the Stream; consumerError - To accept incoming processing errors from the Stream; onComplete - To run after an onComplete event

mergeP
```
public ReactiveSeq<T> mergeP(QueueFactory<T> factory,
 org.reactivestreams.Publisher<T>... publishers)
```
Description copied from interface: ReactiveSeq

A potentially asynchronous merge operation where data from each publisher may arrive out of order (if publishers are configured to publish asynchronously. The QueueFactory parameter can be used by pull based Streams to control the maximum queued elements @see QueueFactories Push based reactiveBuffer-streams signal demand via their subscription.

mergeP
```
public ReactiveSeq<T> mergeP(org.reactivestreams.Publisher<T>... publishers)
```
Description copied from interface: ReactiveSeq

A potentially asynchronous merge operation where data from each publisher may arrive out of order (if publishers are configured to publish asynchronously, users can use the overloaded @see IterableFunctor#mergePublisher(Collection, QueueFactory) method to forEachAsync asynchronously also. Max concurrency is determined by the publishers toX size, along with a default limit of 5k queued values before backpressure is applied.

Parameters:

publishers - Publishers to merge

Returns:

Return Stream of merged data

broadcast
```
public Topic<T> broadcast()
```

unit

public <T> ReactiveSeq<T> unit(T unit)

zipS
```
public <U,R> ReactiveSeq<R> zipS(java.util.stream.Stream<? extends U> other,
 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
```
Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Stream, using the supplied combining function

Parameters:

other - Stream to combine with

zipper - Zip / combining function

Returns:

Combined zippable

schedule

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

Description copied from interface: ReactiveSeq

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

 

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

  data.connect().forEach(this::logToDB);

Parameters:: cron - Expression that determines when each job will run; ex - ScheduledExecutorService
Returns:: Connectable HotStream of emitted from scheduled Stream

scheduleFixedDelay

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

Description copied from interface: ReactiveSeq

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

 
  HotStream<Data> dataStream = ReactiveSeq.generate(() -> "next job:" + formatDate(new Date())).map(this::processJob)
          .scheduleFixedDelay(60_000, Executors.newScheduledThreadPool(1));

  data.connect().forEach(this::logToDB);

Parameters:: delay - Between last element completes passing through the Stream until the next one starts; ex - ScheduledExecutorService
Returns:: Connectable HotStream of emitted from scheduled Stream

scheduleFixedRate

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

Description copied from interface: ReactiveSeq

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

 
  HotStream<Data> dataStream = ReactiveSeq.generate(() -> "next job:" + formatDate(new Date())).map(this::processJob)
          .scheduleFixedRate(60_000, Executors.newScheduledThreadPool(1));

  data.connect().forEach(this::logToDB);

Parameters:: rate - Time in millis between job runs; ex - ScheduledExecutorService
Returns:: Connectable HotStream of emitted from scheduled Stream

limit
```
public ReactiveSeq<T> limit(long num)
```
Description copied from interface: ReactiveSeq
```
 assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
 
```
Parameters:

num - Limit element size to num

Returns:

Monad converted to Stream with elements up to num

skip
```
public ReactiveSeq<T> skip(long num)
```
Description copied from interface: ReactiveSeq
```
 assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); 
 
```
Parameters:

num - Number of elemenets to skip

Returns:

Stream with specified number of elements skipped

cycle
```
public ReactiveSeq<T> cycle()
```
Description copied from interface: ReactiveSeq
Convert to a Stream with the values infinitely cycled
```
 
 ReactiveSeq.of(1).cycle().limit(6).toList());
 //List[1, 1, 1, 1, 1,1]
 
 
```
Returns:

Stream with values repeated

duplicate

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

Description copied from interface: ReactiveSeq

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

 

 	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 reactiveStream

duplicate

public org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> duplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)

triplicate

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

Description copied from interface: ReactiveSeq

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

 
 	Tuple3<ReactiveSeq<Tuple3<T1, T2, T3>>, ReactiveSeq<Tuple3<T1, T2, T3>>, ReactiveSeq<Tuple3<T1, T2, T3>>> Tuple3 = sequence.triplicate();

triplicate

public org.jooq.lambda.tuple.Tuple3<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>> triplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)

multicast
```
public ListX<ReactiveSeq<T>> multicast(int num)
```
Description copied from interface: ReactiveSeq

Broadcast the contents of this Stream to multiple downstream Streams (determined by supplier parameter). For pull based Streams this Stream will be buffered. For push based Streams elements are broadcast downstream on receipt, the emitted downstream Streams remain asynchonous This contrasts with ReactiveSeq.duplicate() ReactiveSeq#triplate ReactiveSeq.quadruplicate() Which buffer all Stream types and produce a synchronous downstream stream.

Parameters:

num - Number of downstream Streams to multicast to

Returns:

List of Streams that recieve data from this Stream

quadruplicate

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

Description copied from interface: ReactiveSeq

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

 
 	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:: Tuple4 containing 4 duplicated ReactiveSeqs

quadruplicate

public org.jooq.lambda.tuple.Tuple4<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>> quadruplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)

splitAtHead

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

Description copied from interface: ReactiveSeq

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

 
 ReactiveSeq.of(1,2,3)
            .splitAtHead()

  //Optional[1], ReactiveSeq[2,3]

splitAt

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

Description copied from interface: ReactiveSeq

Split at supplied location

 
 ReactiveSeq.of(1,2,3)
            .splitAt(1)

  //ReactiveSeq[1], ReactiveSeq[2,3]

splitBy

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

Description copied from interface: ReactiveSeq

Split reactiveStream 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]

partition

public org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> partition(java.util.function.Predicate<? super T> splitter)

Description copied from interface: ReactiveSeq

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]

zipS

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

Description copied from interface: ReactiveSeq

Zip 2 streams into one

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

Parameters:: other - Stream to combine with
Returns:: Combined Zippable

zip3

public <S,U> ReactiveSeq<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.lang.Iterable<? extends S> second,
                                                                   java.lang.Iterable<? extends U> third)

Description copied from interface: ReactiveSeq

zip 3 Streams into one

 
  List<Tuple3<Integer, Integer, Character>> list = of(1, 2, 3, 4, 5, 6).zip3(of(100, 200, 300, 400), of('a', 'b', 'c')).collect(CyclopsCollectors.toList());

  // [[1,100,'a'],[2,200,'b'],[3,300,'c']]

zip4

public <T2,T3,T4> ReactiveSeq<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.lang.Iterable<? extends T2> second,
                                                                             java.lang.Iterable<? extends T3> third,
                                                                             java.lang.Iterable<? extends T4> fourth)

Description copied from interface: ReactiveSeq

zip 4 Streams into 1

 
  List<Tuple4<Integer, Integer, Character, String>> list = of(1, 2, 3, 4, 5, 6).zip4(of(100, 200, 300, 400), of('a', 'b', 'c'), of("hello", "world"))
          .collect(CyclopsCollectors.toList());

 
 // [[1,100,'a',"hello"],[2,200,'b',"world"]]

cycle
```
public ReactiveSeq<T> cycle(long times)
```
Description copied from interface: ReactiveSeq
Convert to a Stream with the values repeated specified times
```
 
 		ReactiveSeq.of(1,2,2)
 								.cycle(3)
 								.collect(CyclopsCollectors.toList());

 		//List[1,2,2,1,2,2,1,2,2]

 
 
```
Parameters:

times - Times values should be repeated within a Stream

Returns:

Stream with values repeated

reduce
```
public  U reduce(U identity,
 java.util.function.BiFunction<U,? super T,U> accumulator,
 java.util.function.BinaryOperator combiner)
```
Description copied from interface: Folds

An equivalent function to Stream.reduce(Object, BiFunction, BinaryOperator)

Specified by:

reduce in interface Folds<T>

Specified by:

reduce in interface ReactiveSeq<T>

Specified by:

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

Overrides:

reduce in class BaseExtendedStream<T>

reduce
```
public T reduce(T identity,
 java.util.function.BinaryOperator<T> accumulator)
```
Description copied from interface: Folds

An equivalent function to Stream.reduce(Object, BinaryOperator)

Specified by:

reduce in interface Folds<T>

Specified by:

reduce in interface ReactiveSeq<T>

Specified by:

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

Overrides:

reduce in class BaseExtendedStream<T>

accumulator - Combiner function

Returns:

Value emitted by applying the current accumulated value and the next value to the combiner function as this Folds is traversed from left to right

collect
```
public final <R,A> R collect(java.util.stream.Collector<? super T,A,R> collector)
```
Description copied from interface: ReactiveSeq

Performs a mutable reduction operation on the elements of this reactiveStream using a Collector. A Collector encapsulates the function used as arguments to ReactiveSeq.collect(Supplier, BiConsumer, BiConsumer), allowing for reuse of toX strategies and composition of collect operations such as multiple-level grouping or partitioning.

If the reactiveStream is parallel, and the Collector is concurrent, and lazy the reactiveStream is unordered or the collector is unordered, applyHKT a concurrent reduction will be performed (see Collector for details on concurrent reduction.)

This is a terminal operation.

When executed in parallel, multiple intermediate results may be instantiated, populated, and merged so as to maintain isolation of mutable data structures. Therefore, even when executed in parallel with non-thread-safe data structures (such as ArrayList), no additional synchronization is needed for a parallel reduction.

Specified by:

collect in interface CyclopsCollectable<T>

Specified by:

collect in interface ReactiveSeq<T>

Specified by:

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

Overrides:

collect in class BaseExtendedStream<T>

Parameters:

collector - the Collector describing the reduction

Returns:

the result of the reduction

See Also:

ReactiveSeq.collect(Supplier, BiConsumer, BiConsumer), Collectors

collect
```
public <R> R collect(java.util.function.Supplier<R> supplier,
 java.util.function.BiConsumer<R,? super T> accumulator,
 java.util.function.BiConsumer<R,R> combiner)
```
Description copied from interface: ReactiveSeq
Performs a mutable reduction operation on the elements of this reactiveStream. A mutable reduction is one in which the reduced value is a mutable result container, such as an ArrayList, and elements are incorporated by updating the state of the result rather than by replacing the result. This produces a result equivalent to:
```
 R result = supplier.get();
 for (T element : this reactiveStream)
 accumulator.accept(result, element);
 return result;
 
```
Like ReactiveSeq.reduce(Object, BinaryOperator), collect operations can be parallelized without requiring additional synchronization.

This is a terminal operation.
Specified by:

collect in interface ReactiveSeq<T>

Specified by:

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

Overrides:

collect in class BaseExtendedStream<T>

Parameters:

supplier - a function that creates a new result container. For a parallel execution, this function may be called multiple times and must return a fresh value each time.

accumulator - an associative, non-interfering, stateless function for incorporating an additional element into a result

combiner - an associative, non-interfering, stateless function for combining two values, which must be compatible with the accumulator function

Returns:

the result of the reduction

reduce
```
public java.util.Optional<T> reduce(java.util.function.BinaryOperator<T> accumulator)
```
Description copied from interface: Folds
An equivalent function to Stream.reduce(BinaryOperator)
```
 
 
 ReactiveSeq.of(1,2,3,4,5).map(it -> it*100).reduce(
 (acc,next) -> acc+next)
 //Optional[1500]
 
 
```
Specified by:

reduce in interface Folds<T>

Specified by:

reduce in interface ReactiveSeq<T>

Specified by:

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

Overrides:

reduce in class BaseExtendedStream<T>

Parameters:

accumulator - Combiner function

allMatch
```
public final boolean allMatch(java.util.function.Predicate<? super T> c)
```
Description copied from interface: ReactiveSeq
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 CyclopsCollectable<T>

Specified by:

allMatch in interface ReactiveSeq<T>

Specified by:

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

Overrides:

allMatch in class BaseExtendedStream<T>

Parameters:

c - Predicate to check if all match

anyMatch
```
public final boolean anyMatch(java.util.function.Predicate<? super T> c)
```
Description copied from interface: ReactiveSeq
True if a singleUnsafe 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 CyclopsCollectable<T>

Specified by:

anyMatch in interface ReactiveSeq<T>

Specified by:

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

Overrides:

anyMatch in class BaseExtendedStream<T>

Parameters:

c - Predicate to check if any match

visit

public <R> R visit(java.util.function.Function<? super ReactiveSeq<T>,? extends R> sync,
                   java.util.function.Function<? super ReactiveSeq<T>,? extends R> reactiveStreams,
                   java.util.function.Function<? super ReactiveSeq<T>,? extends R> asyncNoBackPressure)

singleUnsafe

public T singleUnsafe()

Description copied from interface: ReactiveSeq

 

    //1
    ReactiveSeq.of(1).singleUsafe();

    //UnsupportedOperationException
    ReactiveSeq.of().singleUnsafe();

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

Returns:: a singleUnsafe value or an UnsupportedOperationException if 0/1 values in this Stream

single

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

single

public Maybe<T> single()

Description copied from interface: ReactiveSeq

 

    //Maybe[1]
    ReactiveSeq.of(1).singleUnsafe();

    //Maybe.none
    ReactiveSeq.of().singleUnsafe();

     //Maybe.none
    ReactiveSeq.of(1,2,3).singleUnsafe();

Returns:: An Maybe with singleUnsafe value if this Stream has exactly one element, otherwise Maybe.none

takeOne
```
public Maybe<T> takeOne()
```

Class ReactiveStreamX<T>

Nested Class Summary

Nested classes/interfaces inherited from interface cyclops.stream.ReactiveSeq

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

Constructor Summary

Method Summary

Methods inherited from class com.aol.cyclops2.internal.stream.BaseExtendedStream

Methods inherited from class java.lang.Object

Methods inherited from interface com.aol.cyclops2.types.Unwrapable

Methods inherited from interface cyclops.stream.ReactiveSeq

Methods inherited from interface com.aol.cyclops2.types.foldable.To

Methods inherited from interface java.util.stream.Stream

Methods inherited from interface com.aol.cyclops2.types.traversable.FoldableTraversable

Methods inherited from interface com.aol.cyclops2.types.foldable.CyclopsCollectable

Methods inherited from interface com.aol.cyclops2.types.foldable.Folds

Methods inherited from interface com.aol.cyclops2.types.traversable.Traversable

Methods inherited from interface com.aol.cyclops2.types.functor.TransformerTraversable

Methods inherited from interface com.aol.cyclops2.hkt.Higher

Methods inherited from interface com.aol.cyclops2.hkt.Convert

Constructor Detail

ReactiveStreamX

ReactiveStreamX

Method Detail

getType

reverse

combine

reduceAll

collectStream

iterator

coflatMap

findOne

findFirstOrError

findFirst

findFirstCallAll

sliding

grouped

groupedStatefullyWhile

groupedStatefullyWhile

groupedStatefullyUntil

groupedStatefullyUntil

distinct

scanLeft

scanLeft

skipWhile

limitWhile

limitUntil

skipWhileClosed

limitWhileClosed

format

map

flatMap

flatMapAnyM

flatMapI

flatMapP

flatMapP

filter

spliterator

unwrapStream

createSeq

mapLazyFn

filterLazyPredicate

changes

zipLatest

forEachAsync

forEach

count

unitIterator

backpressureAware

subscribe

onEmpty

onEmptySwitch

onEmptyGet

onEmptyThrow

appendS

append

append

append

prependS

prepend

prepend