cyclops.reactive

Interface ReactiveSeq<T>

Type Parameters:

T - Data type of elements within the Stream

All Superinterfaces:

java.lang.AutoCloseable, java.util.stream.BaseStream<T,java.util.stream.Stream<T>>, Contains<T>, Convert<Higher<DataWitness.reactiveSeq,T>>, FilterableTransformable<T>, Filters<T>, Folds<T>, Higher<DataWitness.reactiveSeq,T>, io.kindedj.Hk<DataWitness.reactiveSeq,T>, java.lang.Iterable<T>, IterableFilterable<T>, IterableX<T>, OnEmpty<T>, OnEmptySwitch<T,java.util.stream.Stream<T>>, org.reactivestreams.Publisher<T>, ReactiveStreamsTerminalOperations<T>, ReactiveTransformable<T>, RecoverableTraversable<T>, java.util.stream.Stream<T>, To<ReactiveSeq<T>>, Transformable<T>, Traversable<T>, Unit<T>, Zippable<T>

public interface ReactiveSeq<T>
extends To<ReactiveSeq<T>>, java.util.stream.Stream<T>, OnEmptySwitch<T,java.util.stream.Stream<T>>, IterableX<T>, Contains<T>, Unit<T>, RecoverableTraversable<T>, ReactiveTransformable<T>, Higher<DataWitness.reactiveSeq,T>

A powerful Streaming interface. Use factory methods on this class for performant, synchronous Streams Use factory methods on Spouts for asynchronous streaming with and without back pressure Use factory methods on FutureStream (cyclops-futurestream) for powerful parallel streaming Features include Asynchronous execution Scheduling Error handling Retries Zipping Duplication Cartesian zip operations (e.g. crossJoin, forEach2) Subscriptions and fined grained control Interoperability Parallelism via FutureStream Lazy grouping (group by size, time, state) Sliding windows n`\ Efficient reversal foldRight / scanLeft / scanRight Zipping and Combining Data insertion and removal Time based operations (debouncing, onePer, xPer) SQL style Window operations Reduction and partial reduction Mathematical terminal operations Lazy execution Empty handling Cycling / repeating Controlled iteration (forEach) Event handling (on next, on error, on complete)

Nested Class Summary

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

java.util.stream.Stream.Builder<T>

Field Summary

Fields

Modifier and Type	Field and Description
static ReactiveSeq<?>	empty

Method Summary

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
default ReactiveSeq<T>	ambWith(org.reactivestreams.Publisher<T>... racers)
default ReactiveSeq<T>	ambWith(org.reactivestreams.Publisher<T> racer)
boolean	anyMatch(java.util.function.Predicate<? super T> c) True if a single element matches when Monad converted to a Stream
ReactiveSeq<T>	append(T value)
default ReactiveSeq<T>	appendAll(java.lang.Iterable<? extends T> value)
ReactiveSeq<T>	appendAll(T... values) Append values to the take of this ReactiveSeq
ReactiveSeq<T>	appendStream(java.util.stream.Stream<? extends T> other) Append Stream to this ReactiveSeq
default ReactiveSeq<T>	backpressureAware()
default 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 stream using a Collector.
default <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 stream.
default <R,A> ReactiveSeq<R>	collectAll(java.util.stream.Collector<? super T,A,R> collector)
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 and reduction operation.
default ReactiveSeq<T>	combine(Monoid<T> op, java.util.function.BiPredicate<? super T,? super T> predicate) Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation.
static <T> ReactiveSeq<T>	concat(java.util.Spliterator<? extends T>... array)
static <T> ReactiveSeq<T>	concat(java.util.Spliterator<? extends T> left, java.util.Spliterator<? extends T> right)
static <T> ReactiveSeq<T>	concat(java.util.stream.Stream<? extends T>... streams)
static <T> ReactiveSeq<T>	concat(java.util.stream.Stream<? extends T> left, java.util.stream.Stream<? extends T> right)
static java.util.function.Function<? super ReactiveSeq<java.lang.Double>,? extends ReactiveSeq<java.lang.Double>>	concatDoubles(ReactiveSeq<java.lang.Double> b)
static java.util.function.Function<? super ReactiveSeq<java.lang.Integer>,? extends ReactiveSeq<java.lang.Integer>>	concatInts(ReactiveSeq<java.lang.Integer> b)
static java.util.function.Function<? super ReactiveSeq<java.lang.Long>,? extends ReactiveSeq<java.lang.Long>>	concatLongs(ReactiveSeq<java.lang.Long> b)
<R> ReactiveSeq<R>	concatMap(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
static java.util.function.Function<? super ReactiveSeq<java.lang.Integer>,? extends ReactiveSeq<java.lang.Integer>>	concatMapnts(java.util.function.IntFunction<? extends java.util.stream.IntStream> b)
long	count() Returns the count of elements in this stream.
default <U> ReactiveSeq<Tuple2<T,U>>	crossJoin(ReactiveSeq<? extends U> other) crossJoin two Streams forming a cartesian zip over both
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
default ReactiveSeq<T>	cycle(Monoid<T> m, long times) Convert to a Stream with the result of a reduction operation repeated specified times
default ReactiveSeq<T>	cycleUntil(java.util.function.Predicate<? super T> predicate) Repeat in a Stream until specified predicate holds
default 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
static <T> ReactiveSeq<T>	defer(java.util.function.Supplier<? extends java.lang.Iterable<? extends T>> lazy)
static <T> ReactiveSeq<T>	deferFromPublisher(java.util.function.Supplier<? extends org.reactivestreams.Publisher<? extends T>> lazy)
static <T> ReactiveSeq<T>	deferFromStream(java.util.function.Supplier<? extends java.util.stream.Stream<? extends T>> lazy)
default 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<java.lang.Double>	doubles(java.util.function.ToDoubleFunction<? super T> fn, java.util.function.Function<? super java.util.stream.DoubleStream,? extends java.util.stream.DoubleStream> mapper) Peform intermediate operations on a primitive IntStream (gives improved performance when working with Integers) If this ReactiveSeq has an OfInt Spliterator it will be converted directly to an IntStream, otherwise the provided conversion function will be used.
default ReactiveSeq<T>	drop(long drop) assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7)));
default ReactiveSeq	drop(long time, java.util.concurrent.TimeUnit unit)
default ReactiveSeq<T>	dropRight(int num) Generate a new Traversable that drops the specified number elements from the take of this Traversable
default ReactiveSeq<T>	dropUntil(java.util.function.Predicate<? super T> p) Generate a new Traversable that drops elements from this Traversable until the predicate holds
default ReactiveSeq<T>	dropWhile(java.util.function.Predicate<? super T> p) Generate a new Traversable that drops elements from this Traversable as long as the predicate holds
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 stream.
Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>	duplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)
default ReactiveSeq<Tuple2<T,java.lang.Long>>	elapsed() ReactiveSeq.of(1,2,3,4,5) .elapsed() .forEach(System.out::println);
default Maybe<T>	elementAt(long index) Return the elementAt index or Optional.empty
default Tuple2<T,ReactiveSeq<T>>	elementAtAndStream(long index) Gets the element at index, and returns a Tuple containing the element (it must be present) and a maybe copy of the Sequence for further processing.
static <T> ReactiveSeq<T>	empty()
boolean	endsWith(java.lang.Iterable<T> iterable) assertTrue(ReactiveSeq.of(1,2,3,4,5,6) .endsWith(Arrays.asList(5,6)));
static <T> ReactiveSeq<T>	enqueued(java.util.function.Consumer<? super org.reactivestreams.Subscriber<T>> sub) Create a Stream that accepts data via the Subsriber passed into the supplied Consumer.
static <T> ReactiveSeq<T>	enqueued(Queue<T> q, java.util.function.Consumer<? super org.reactivestreams.Subscriber<T>> sub)
static <T> ReactiveSeq<T>	enqueued(QueueFactory<T> factory, java.util.function.Consumer<? super org.reactivestreams.Subscriber<T>>... subs)
static <T> ReactiveSeq<T>	enqueuedAll(java.util.function.Consumer<? super org.reactivestreams.Subscriber<T>>... subs)
static <E extends java.lang.Enum<E>> ReactiveSeq<E>	enums(java.lang.Class<E> c) Stream over the values of an enum
static <E extends java.lang.Enum<E>> ReactiveSeq<E>	enums(java.lang.Class<E> c, E start) Stream over the values of an enum
static <E extends java.lang.Enum<E>> ReactiveSeq<E>	enums(java.lang.Class<E> c, E start, E step, E end) Stream over the values of an enum
static <E extends java.lang.Enum<E>> ReactiveSeq<E>	enumsFromTo(java.lang.Class<E> c, E start, E end) Stream over the values of an enum
default <R> ReactiveSeq<R>	fanOut(java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R>> path1, java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R>> path2)
default <R> ReactiveSeq<R>	fanOut(java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R>> path1, java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R>> path2, java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R>> path3)
default <R> ReactiveSeq<R>	fanOut(java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R>> path1, java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R>> path2, java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R>> path3, java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R>> path4)
default <R1,R2,R3> ReactiveSeq<R3>	fanOutZipIn(java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R1>> path1, java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R2>> path2, java.util.function.BiFunction<? super R1,? super R2,? extends R3> zipFn)
default <R1,R2,R3,R4,R5> ReactiveSeq<R5>	fanOutZipIn(java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R1>> path1, java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R2>> path2, java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R3>> path3, java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R4>> path4, Function4<? super R1,? super R2,? super R3,? super R4,? extends R5> zipFn)
default <R1,R2,R3,R4> ReactiveSeq<R4>	fanOutZipIn(java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R1>> path1, java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R2>> path2, java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R3>> path3, Function3<? super R1,? super R2,? super R3,? extends R4> zipFn)
static <T> ReactiveSeq<T>	fill(T t) Construct a Stream consisting of a single value repeatedly infinitely (use take / drop etc to switch to a finite Stream)
ReactiveSeq<T>	filter(java.util.function.Predicate<? super T> fn) Keep only elements for which the supplied predicates hold e.g.
static java.util.function.Function<? super ReactiveSeq<java.lang.Integer>,? extends ReactiveSeq<java.lang.Integer>>	filterInts(java.util.function.IntPredicate b)
static java.util.function.Function<? super ReactiveSeq<java.lang.Double>,? extends ReactiveSeq<java.lang.Double>>	filterLongs(java.util.function.DoublePredicate b)
static java.util.function.Function<? super ReactiveSeq<java.lang.Long>,? extends ReactiveSeq<java.lang.Long>>	filterLongs(java.util.function.LongPredicate b)
default ReactiveSeq<T>	filterNot(java.util.function.Predicate<? super T> predicate) Remove any elements for which the predicate holds (inverse operation to filter) e.g.
java.util.Optional<T>	findAny()
java.util.Optional<T>	findFirst()
LazyEither<java.lang.Throwable,T>	findFirstOrError() Lazy / reactive look up of first value , capturing the first error, if one occurs.
T	firstValue(T alt) 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
static java.util.function.Function<? super ReactiveSeq<java.lang.Double>,? extends ReactiveSeq<java.lang.Double>>	flatMapDoubles(java.util.function.DoubleFunction<? extends java.util.stream.DoubleStream> b)
static java.util.function.Function<? super ReactiveSeq<java.lang.Long>,? extends ReactiveSeq<java.lang.Long>>	flatMapLongs(java.util.function.LongFunction<? extends java.util.stream.LongStream> b)
<R> ReactiveSeq<R>	flatMapStream(java.util.function.Function<? super T,java.util.stream.BaseStream<? extends R,?>> fn) flatMap operation
static <T1> ReactiveSeq<T1>	flatten(ReactiveSeq<? extends ReactiveSeq<T1>> nested) join / flatten one level of a nest hierarchy
static <T1> ReactiveSeq<T1>	flattenIterable(ReactiveSeq<? extends java.lang.Iterable<T1>> nested)
<R> R	fold(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)
<R> R	foldMap(java.util.function.Function<? super T,? extends R> mapper, Monoid<R> reducer) ReactiveSeq.of("one","two","three","four") .foldMap(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; }
<R> R	foldMap(Reducer<R,T> reducer) ReactiveSeq.of("hello","2","world","4").foldMap(Reducers.toCountInt()); //4
<R> R	foldMapRight(Reducer<R,T> reducer) Attempt to transform this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
default <R> R	foldParallel(java.util.concurrent.ForkJoinPool fj, java.util.function.Function<? super java.util.stream.Stream<T>,? extends R> fn)
default <R> R	foldParallel(java.util.function.Function<? super java.util.stream.Stream<T>,? extends R> fn)
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
<U> U	foldRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> accumulator) Immutable reduction from right to left
void	forEach(java.util.function.Consumer<? super T> action) Performs an action for each element of this Stream.
default <R1,R> ReactiveSeq<R>	forEach2(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction) Perform a two level nested internal iteration over this Stream and the supplied stream
default <R1,R> ReactiveSeq<R>	forEach2(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction) Perform a two level nested internal iteration over this Stream and the supplied stream
default <R1,R2,R> ReactiveSeq<R>	forEach3(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.BiFunction<? super T,? super R1,? extends java.util.stream.BaseStream<R2,?>> stream2, Function3<? super T,? super R1,? super R2,? extends R> yieldingFunction) Perform a three level nested internal iteration over this Stream and the supplied streams
default <R1,R2,R> ReactiveSeq<R>	forEach3(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.BiFunction<? super T,? super R1,? extends java.util.stream.BaseStream<R2,?>> stream2, Function3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction, Function3<? super T,? super R1,? super R2,? extends R> yieldingFunction) Perform a three level nested internal iteration over this Stream and the supplied streams
default <R1,R2,R3,R> ReactiveSeq<R>	forEach4(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.BiFunction<? super T,? super R1,? extends java.util.stream.BaseStream<R2,?>> stream2, Function3<? super T,? super R1,? super R2,? extends java.util.stream.BaseStream<R3,?>> stream3, Function4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction) Perform a four level nested internal iteration over this Stream and the supplied streams
default <R1,R2,R3,R> ReactiveSeq<R>	forEach4(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.BiFunction<? super T,? super R1,? extends java.util.stream.BaseStream<R2,?>> stream2, Function3<? super T,? super R1,? super R2,? extends java.util.stream.BaseStream<R3,?>> stream3, Function4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, Function4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction) Perform a four level nested internal iteration over this Stream and the supplied streams
default void	forEachAsync(java.util.function.Consumer<? super T> action) A potentially non-blocking analog of forEach(java.util.function.Consumer<? super T>).
static com.oath.cyclops.internal.stream.OneShotStreamX<java.lang.Integer>	fromCharSequence(java.lang.CharSequence input) Construct a ReactiveSeq from a String
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>	fromSpliterator(java.util.Spliterator<T> spliterator) Construct a ReactiveSeq from the Supplied Spliterator
static <T> ReactiveSeq<T>	fromStream(java.util.stream.Stream<T> stream) Construct a ReactiveSeq from a Stream
static <T> ReactiveSeq<T>	generate(Generator<T> gen)
static <T> ReactiveSeq<T>	generate(java.util.function.Supplier<T> s)
default <K> HashMap<K,Vector<T>>	groupBy(java.util.function.Function<? super T,? extends K> classifier) Use classifier function to group elements in this Sequence into a Map
ReactiveSeq<Vector<T>>	grouped(int groupSize) Group elements in a Stream
<C extends PersistentCollection<? super T>> ReactiveSeq<C>	grouped(int size, java.util.function.Supplier<C> supplier) Batch elements in a Stream by size into a toX created by the supplied factory
ReactiveSeq<Vector<T>>	groupedBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit t) Batch elements by size into a List
<C extends PersistentCollection<? 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 PersistentCollection<? 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<Vector<T>>	groupedByTime(long time, java.util.concurrent.TimeUnit t) Batch elements in a Stream by time period
<C extends PersistentCollection<? 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 PersistentCollection<? 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 PersistentCollection<T>,R> ReactiveSeq<R>	groupedUntil(java.util.function.BiPredicate<C,? super T> predicate, java.util.function.Supplier<C> factory, java.util.function.Function<? super C,? extends R> finalizer)
ReactiveSeq<Vector<T>>	groupedUntil(java.util.function.BiPredicate<Vector<? super T>,? super T> predicate) Create ReactiveSeq of Seq where each Seq is populated while the supplied bipredicate holds.
default ReactiveSeq<Vector<T>>	groupedUntil(java.util.function.Predicate<? super T> predicate) Create a ReactiveSeq batched by List, where each batch is populated until the predicate holds
default <C extends PersistentCollection<? 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
<C extends PersistentCollection<T>,R> ReactiveSeq<R>	groupedWhile(java.util.function.BiPredicate<C,? super T> predicate, java.util.function.Supplier<C> factory, java.util.function.Function<? super C,? extends R> finalizer)
ReactiveSeq<Vector<T>>	groupedWhile(java.util.function.BiPredicate<Vector<? super T>,? super T> predicate)
ReactiveSeq<Vector<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 PersistentCollection<? 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
default Option<T>	headOption()
default Connectable<T>	hotStream(java.util.concurrent.Executor e) Turns this ReactiveSeq into a Connectable, a connectable Stream, being executed on a thread on the supplied executor, that is producing data.
default ReactiveSeq<T>	insertAt(int pos, java.lang.Iterable<? extends T> values)
default ReactiveSeq<T>	insertAt(int pos, ReactiveSeq<? extends T> values)
default ReactiveSeq<T>	insertAt(int pos, T... values) Insert data into a ReactiveSeq at a given position
default ReactiveSeq<T>	insertAt(int pos, T value)
default ReactiveSeq<T>	insertStreamAt(int pos, java.util.stream.Stream<T> stream) Insert a Stream into the middle of this stream at the specified position
default ReactiveSeq<T>	intersperse(T value) Returns a stream with a given value interspersed between any two values of this stream.
default ReactiveSeq<java.lang.Integer>	ints(java.util.function.ToIntFunction<? super T> fn, java.util.function.Function<? super java.util.stream.IntStream,? extends java.util.stream.IntStream> mapper) Peform intermediate operations on a primitive IntStream (gives improved performance when working with Integers) If this ReactiveSeq has an OfInt Spliterator it will be converted directly to an IntStream, otherwise the provided conversion function will be used.
default boolean	isEmpty()
default boolean	isReplayable()
static <T> ReactiveSeq<T>	iterate(T seed, java.util.function.Predicate<? super T> pred, java.util.function.UnaryOperator<T> f)
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());
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
static java.util.function.Function<? super ReactiveSeq<java.lang.Double>,? extends ReactiveSeq<java.lang.Double>>	limitDouble(long maxSize)
static java.util.function.Function<? super ReactiveSeq<java.lang.Integer>,? extends ReactiveSeq<java.lang.Integer>>	limitInts(long maxSize)
ReactiveSeq<T>	limitLast(int num) Limit results to the last x elements in a ReactiveSeq
static java.util.function.Function<? super ReactiveSeq<java.lang.Long>,? extends ReactiveSeq<java.lang.Long>>	limitLongs(long maxSize)
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>	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
ReactiveSeq<T>	limitWhileClosed(java.util.function.Predicate<? super T> predicate)
default ReactiveSeq<java.lang.Long>	longs(java.util.function.ToLongFunction<? super T> fn, java.util.function.Function<? super java.util.stream.LongStream,? extends java.util.stream.LongStream> mapper) Peform intermediate operations on a primitive IntStream (gives improved performance when working with Integers) If this ReactiveSeq has an OfInt Spliterator it will be converted directly to an IntStream, otherwise the provided conversion function will be used.
<R> ReactiveSeq<R>	map(java.util.function.Function<? super T,? extends R> fn) Transform this functor using the supplied transformation function
static java.util.function.Function<? super ReactiveSeq<java.lang.Double>,? extends ReactiveSeq<java.lang.Double>>	mapDoubles(java.util.function.DoubleUnaryOperator b)
static java.util.function.Function<? super ReactiveSeq<java.lang.Integer>,? extends ReactiveSeq<java.lang.Integer>>	mapInts(java.util.function.IntUnaryOperator b)
static java.util.function.Function<? super ReactiveSeq<java.lang.Long>,? extends ReactiveSeq<java.lang.Long>>	mapLongs(java.util.function.LongUnaryOperator b)
default java.util.stream.DoubleStream	mapToDouble(java.util.function.ToDoubleFunction<? super T> fn)
default java.util.stream.IntStream	mapToInt(java.util.function.ToIntFunction<? super T> fn)
default java.util.stream.LongStream	mapToLong(java.util.function.ToLongFunction<? super T> fn)
default java.util.Optional<T>	max(java.util.Comparator<? super T> comparator)
default ReactiveSeq<T>	merge(Adapter<T>... adapters)
<R> ReactiveSeq<R>	mergeMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
<R> ReactiveSeq<R>	mergeMap(int maxConcurrency, java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
default ReactiveSeq<T>	mergeP(org.reactivestreams.Publisher<T>... publishers)
default 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.
default java.util.Optional<T>	min(java.util.Comparator<? super T> comparator)
default Seq<ReactiveSeq<T>>	multicast(int num) Broadcast the contents of this Stream to multiple downstream Streams (determined by supplier parameter).
static <T> ReactiveSeq<T>	narrow(ReactiveSeq<? extends T> broad)
static <T> ReactiveSeq<T>	narrowK(Higher<DataWitness.reactiveSeq,T> future) Convert the raw Higher Kinded Type for ReactiveSeq types into the ReactiveSeq type definition class
boolean	noneMatch(java.util.function.Predicate<? super T> c)
default ReactiveSeq<T>	notNull() Filter elements retaining only values which are not null
static <T> ReactiveSeq<T>	of(T... elements) Create an efficiently reversable Sequence from the provided elements
static <T> ReactiveSeq<T>	of(T value) Efficiently construct a ReactiveSeq from a single value
static ReactiveSeq<java.lang.Double>	ofDoubles(double... values)
static ReactiveSeq<java.lang.Integer>	ofInts(int... values)
static ReactiveSeq<java.lang.Long>	ofLongs(long... values)
static <T> ReactiveSeq<T>	ofNullable(T nullable)
default <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>	onComplete(java.lang.Runnable fn) Provide a simpler method to handle stream or async operations.
default ReactiveSeq<T>	onEmpty(T value) If this Container instance is zero, create a new instance containing the provided value
<X extends java.lang.Throwable> ReactiveSeq<T>	onEmptyError(java.util.function.Supplier<? extends X> supplier)
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
ReactiveSeq<T>	onePer(long time, java.util.concurrent.TimeUnit t) emit one element per time period
static <T> ReactiveSeq<T>	oneShotList(java.util.List<T> list)
static <T> ReactiveSeq<T>	oneShotStream(java.util.stream.Stream<T> stream)
ReactiveSeq<T>	parallel()
default <R> ReactiveSeq<R>	parallel(java.util.concurrent.ForkJoinPool fj, java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R>> fn)
default <R> ReactiveSeq<R>	parallel(java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R>> fn)
default <R> ReactiveSeq<R>	parallelFanOut(java.util.concurrent.ForkJoinPool fj, java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R>> path1, java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R>> path2)
default <R> ReactiveSeq<R>	parallelFanOut(java.util.concurrent.ForkJoinPool fj, java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R>> path1, java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R>> path2, java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R>> path3)
default <R> ReactiveSeq<R>	parallelFanOut(java.util.concurrent.ForkJoinPool fj, java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R>> path1, java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R>> path2, java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R>> path3, java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R>> path4)
default <R1,R2,R3> ReactiveSeq<R3>	parallelFanOutZipIn(java.util.concurrent.ForkJoinPool fj, java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R1>> path1, java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R2>> path2, java.util.function.BiFunction<? super R1,? super R2,? extends R3> zipFn)
default <R1,R2,R3,R4,R5> ReactiveSeq<R5>	parallelFanOutZipIn(java.util.concurrent.ForkJoinPool fj, java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R1>> path1, java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R2>> path2, java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R3>> path3, java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R4>> path4, Function4<? super R1,? super R2,? super R3,? super R4,? extends R5> zipFn)
default <R1,R2,R3,R4> ReactiveSeq<R4>	parallelFanOutZipIn(java.util.concurrent.ForkJoinPool fj, java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R1>> path1, java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R2>> path2, java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R3>> path3, Function3<? super R1,? super R2,? super R3,? extends R4> zipFn)
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
default PausableConnectable<T>	pausableHotStream(java.util.concurrent.Executor e) Turns this ReactiveSeq into a Connectable, a connectable & pausable Stream, being executed on a thread on the supplied executor, that is producing data.
default ReactiveSeq<T>	peek(java.util.function.Consumer<? super T> c) Peek at the current value of this Transformable, without transforming it
default ReactiveSeq<ReactiveSeq<T>>	permutations() Generate the permutations based on values in the ReactiveSeq Makes use of Streamable to store intermediate stages in a toX
default ReactiveSeq<T>	plus(T value)
default ReactiveSeq<T>	plusAll(java.lang.Iterable<? extends T> list)
ReactiveSeq<T>	prepend(T value)
ReactiveSeq<T>	prependAll(java.lang.Iterable<? extends T> other)
ReactiveSeq<T>	prependAll(T... values) Prepend given values to the skip of the Stream
ReactiveSeq<T>	prependStream(java.util.stream.Stream<? extends T> stream) Prepend Stream to this ReactiveSeq
default Connectable<T>	primedHotStream(java.util.concurrent.Executor e) Return a Connectable that will skip emitting data when the first connecting Stream connects.
default PausableConnectable<T>	primedPausableHotStream(java.util.concurrent.Executor e) Return a pausable Connectable that will skip emitting data when the first connecting Stream connects.
default void	print(java.io.PrintStream stream) Write each element within this Folds in turn to the supplied PrintStream
default void	print(java.io.PrintWriter writer) Write each element within this Folds in turn to the supplied PrintWriter
default void	printErr() Print each value in this Folds to the error console in turn (left-to-right)
default void	printOut() Print each value in this Folds to the console in turn (left-to-right)
default ReactiveSeq<T>	publishTo(Adapter<T>... adapters)
default ReactiveSeq<T>	publishTo(Signal<T>... signals)
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.
Tuple4<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>>	quadruplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)
static ReactiveSeq<java.lang.Integer>	range(int start, int end) Create an efficiently reversable Sequence that produces the integers between skip and take
static ReactiveSeq<java.lang.Integer>	range(int start, int step, int end)
static ReactiveSeq<java.lang.Long>	rangeLong(long start, long end) Create an efficiently reversable Sequence that produces the integers between skip and take
static ReactiveSeq<java.lang.Long>	rangeLong(long start, long step, long end)
static <T> ReactiveSeq<T>	reactiveSeq(java.lang.Iterable<T> iterable)
<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)
Seq<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
T	reduce(T identity, java.util.function.BinaryOperator<T> accumulator)
default <U> U	reduce(U identity, java.util.function.BiFunction<U,? super T,U> accumulator)
<U> U	reduce(U identity, java.util.function.BiFunction<U,? super T,U> accumulator, java.util.function.BinaryOperator<U> combiner)
default <R> ReactiveSeq<R>	reduceAll(R identity, java.util.function.BiFunction<R,? super T,R> accumulator)
default ReactiveSeq<T>	removeAll(java.lang.Iterable<? extends T> it) Remove all elements in the supplied Iterable from this filterable
default ReactiveSeq<T>	removeAll(T... values) Remove all supplied elements from this filterable
default ReactiveSeq<T>	removeAt(int pos)
default ReactiveSeq<T>	removeAt(long index)
default ReactiveSeq<T>	removeFirst(java.util.function.Predicate<? super T> pred)
default ReactiveSeq<T>	removeStream(java.util.stream.Stream<? extends T> stream) Remove all elements in the supplied Stream from this filterable
default ReactiveSeq<T>	removeValue(T t) Remove all occurances of the specified element from the ReactiveSeq
default ReactiveSeq<T>	retainAll(java.lang.Iterable<? extends T> it) Retain only the supplied elements in the returned Filters
default ReactiveSeq<T>	retainAll(T... values) Retain only the supplied elements in the returned Filters
default ReactiveSeq<T>	retainStream(java.util.stream.Stream<? extends T> stream) Retain only the supplied elements in the returned Filters
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() Potentially efficient Stream reversal.
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 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
default ReactiveSeq<T>	scanRight(Monoid<T> monoid) Scan right
default <U> ReactiveSeq<U>	scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner) Scan right
default Connectable<T>	schedule(java.lang.String cron, java.util.concurrent.ScheduledExecutorService ex) Execute this Stream on a schedule
default Connectable<T>	scheduleFixedDelay(long delay, java.util.concurrent.ScheduledExecutorService ex) Execute this Stream on a schedule
default Connectable<T>	scheduleFixedRate(long rate, java.util.concurrent.ScheduledExecutorService ex) Execute this Stream on a schedule
ReactiveSeq<T>	sequential()
default ReactiveSeq<T>	shuffle()
default ReactiveSeq<T>	shuffle(java.util.Random random)
default Maybe<T>	single() //Maybe[1] ReactiveSeq.of(1).single(); //Maybe.none ReactiveSeq.of().single(); //Maybe.none ReactiveSeq.of(1,2,3).single();
default Maybe<T>	single(java.util.function.Predicate<? super T> predicate)
default T	singleOrElse(T alt) //1 ReactiveSeq.of(1).singleUsafe(); //UnsupportedOperationException ReactiveSeq.of().single(); //UnsupportedOperationException ReactiveSeq.of(1,2,3).single();
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
static java.util.function.Function<? super ReactiveSeq<java.lang.Double>,? extends ReactiveSeq<java.lang.Double>>	skipDoubles(long skip)
static java.util.function.Function<? super ReactiveSeq<java.lang.Integer>,? extends ReactiveSeq<java.lang.Integer>>	skipInts(long skip)
ReactiveSeq<T>	skipLast(int num) assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(1,2,3)));
static java.util.function.Function<? super ReactiveSeq<java.lang.Long>,? extends ReactiveSeq<java.lang.Long>>	skipLongs(long skip)
default 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>	skipWhileClosed(java.util.function.Predicate<? super T> predicate)
default ReactiveSeq<T>	slice(long from, long to)
default ReactiveSeq<Seq<T>>	sliding(int windowSize) Create a sliding view over this Sequence
ReactiveSeq<Seq<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)));
default 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)));
default <U extends java.lang.Comparable<? super U>> ReactiveSeq<T>	sorted(java.util.function.Function<? super T,? extends U> function)
default <U> ReactiveSeq<T>	sorted(java.util.function.Function<? super T,? extends U> function, java.util.Comparator<? super U> comparator)
Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>	splitAt(int where) Split at supplied location
Tuple2<Option<T>,ReactiveSeq<T>>	splitAtHead() Split a Stream at it's head (similar to headAndTail)
Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>	splitBy(java.util.function.Predicate<T> splitter) Split stream at point where predicate no longer holds
java.util.Spliterator<T>	spliterator() Returns a spliterator for the elements of this stream.
boolean	startsWith(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
default ReactiveSeq<T>	subStream(int start, int end) Return a Stream with elements before the provided skip index removed, and elements after the provided take index removed
static <T,R> ReactiveSeq<R>	tailRec(T initial, java.util.function.Function<? super T,? extends ReactiveSeq<? extends Either<T,R>>> fn)
default ReactiveSeq<T>	take(long take) assertThat(ReactiveSeq.of(4,3,6,7).take(2).toList(),equalTo(Arrays.asList(4,3));
default ReactiveSeq	take(long time, java.util.concurrent.TimeUnit unit)
Maybe<T>	takeOne() Lazy / reactive analogue of findFirst / findAny from JDK For push based reactive-streams (created via Spouts.XXX) data will be pushed to the returned Maybe on arrival.
default ReactiveSeq<T>	takeRight(int num) Generate a new Traversable that takes the specified number elements from the take of this Traversable
default ReactiveSeq<T>	takeUntil(java.util.function.Predicate<? super T> p) Generate a new Traversable that takes elements from this Traversable until the predicate holds
default ReactiveSeq<T>	takeWhile(java.util.function.Predicate<? super T> p) Generate a new Traversable that takes elements from this Traversable as long as the predicate holds
default ReactiveSeq<Tuple2<T,java.lang.Long>>	timestamp() ReactiveSeq.of(1,2,3,4,5) .timestamp() .forEach(System.out::println)
java.lang.Object[]	toArray()
<A> A[]	toArray(java.util.function.IntFunction<A[]> generator)
default java.util.List<T>	toList()
default java.util.Set<T>	toSet() Collect the collectable into a LinkedHashSet.
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.
Tuple3<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>>	triplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)
static <U,T> ReactiveSeq<T>	unfold(U seed, java.util.function.Function<? super U,Option<Tuple2<T,U>>> unfolder) Unfold a function into a ReactiveSeq
<T> ReactiveSeq<T>	unit(T unit)
ReactiveSeq<T>	unordered()
static <T,U> Tuple2<ReactiveSeq<T>,ReactiveSeq<U>>	unzip(ReactiveSeq<Tuple2<T,U>> sequence) Unzip a zipped Stream
static <T1,T2,T3> Tuple3<ReactiveSeq<T1>,ReactiveSeq<T2>,ReactiveSeq<T3>>	unzip3(ReactiveSeq<Tuple3<T1,T2,T3>> sequence) Unzip a zipped Stream into 3
static <T1,T2,T3,T4> Tuple4<ReactiveSeq<T1>,ReactiveSeq<T2>,ReactiveSeq<T3>,ReactiveSeq<T4>>	unzip4(ReactiveSeq<Tuple4<T1,T2,T3,T4>> sequence) Unzip a zipped Stream into 4
default ReactiveSeq<T>	updateAt(int i, T e)
static <T> Higher<DataWitness.reactiveSeq,T>	widen(ReactiveSeq<T> narrow)
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,R> ReactiveSeq<R>	zip(java.util.function.BiFunction<? super T,? super U,? extends R> zipper, org.reactivestreams.Publisher<? extends U> other) Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
default <U> ReactiveSeq<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) Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
<S,U> ReactiveSeq<Tuple3<T,S,U>>	zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third) zip 3 Streams into one
default <S,U,R> ReactiveSeq<R>	zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third, Function3<? super T,? super S,? super U,? extends R> fn3)
<T2,T3,T4> ReactiveSeq<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
default <T2,T3,T4,R> ReactiveSeq<R>	zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth, Function4<? super T,? super T2,? super T3,? super T4,? extends R> fn)
default <U,R> ReactiveSeq<R>	zipLatest(org.reactivestreams.Publisher<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
default ReactiveSeq<Tuple2<T,java.lang.Long>>	zipWithIndex() Add an index to the current Stream
default <U> ReactiveSeq<Tuple2<T,U>>	zipWithPublisher(org.reactivestreams.Publisher<? extends U> other)
<U> ReactiveSeq<Tuple2<T,U>>	zipWithStream(java.util.stream.Stream<? extends U> other) Zip 2 streams into one
<U,R> ReactiveSeq<R>	zipWithStream(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)

Methods inherited from interface com.oath.cyclops.types.foldable.To

to

Methods inherited from interface java.util.stream.Stream

builder, flatMapToDouble, flatMapToInt, flatMapToLong, forEachOrdered

Methods inherited from interface java.util.stream.BaseStream

close, isParallel, iterator

Methods inherited from interface com.oath.cyclops.types.traversable.IterableX

asFunction, containsValue, equalToIteration, foldFuture, foldLazy, foldTry, forEach, forEach, forEach, forEach, forEach, forEachSubscribe, forEachSubscribe, forEachSubscribe, runFuture, runLazy, to, toHashSet, toSeq, unitIterable

Methods inherited from interface com.oath.cyclops.types.traversable.Traversable

subscribe, traversable

Methods inherited from interface java.lang.Iterable

iterator

Methods inherited from interface com.oath.cyclops.types.foldable.Contains

contains

Methods inherited from interface com.oath.cyclops.types.foldable.Folds

atPercentile, bankersQueue, collect, collect, countDistinct, doubleStats, foldLeft, foldLeft, foldLeft, foldLeft, foldLeft, foldLeft, hashSet, indexOf, indexOfSlice, intStats, iterableTo, lastIndexOf, lastIndexOfSlice, lazySeq, longStats, maxBy, maxBy, maximum, mean, median, minBy, minBy, minimum, mode, nonEmptyList, occurances, populationVariance, scheduleStream, seq, stdDeviation, sumDouble, sumInt, sumLong, toCollection, toHashMap, toHashMap, toMap, toMap, treeSet, variance, vector, withPercentiles

Methods inherited from interface com.oath.cyclops.hkt.Higher

applyHKT_, applyHKT, applyHKT

Methods inherited from interface com.oath.cyclops.hkt.Convert

convert

Field Detail

empty

static final ReactiveSeq<?> empty

Method Detail

toArray

java.lang.Object[] toArray()

Specified by:

toArray in interface Folds<T>

Specified by:

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

toArray

<A> A[] toArray(java.util.function.IntFunction<A[]> generator)

Specified by:

toArray in interface Folds<T>

Specified by:

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

removeFirst

default ReactiveSeq<T> removeFirst(java.util.function.Predicate<? super T> pred)

Specified by:

removeFirst in interface IterableX<T>

Specified by:

removeFirst in interface Traversable<T>

plusAll

default ReactiveSeq<T> plusAll(java.lang.Iterable<? extends T> list)

Specified by:

plusAll in interface IterableX<T>

plus

default ReactiveSeq<T> plus(T value)

Specified by:

plus in interface IterableX<T>

updateAt

default ReactiveSeq<T> updateAt(int i,
                                T e)

Specified by:

updateAt in interface IterableX<T>

Specified by:

updateAt in interface Traversable<T>

removeAt

default ReactiveSeq<T> removeAt(int pos)

Specified by:

removeAt in interface IterableX<T>

Specified by:

removeAt in interface Traversable<T>

enums

static <E extends java.lang.Enum<E>> ReactiveSeq<E> enums(java.lang.Class<E> c)

Stream over the values of an enum

     
     ReactiveSeq.enums(Days.class)
                      .printOut();
     

     Monday
     Tuesday
     Wednesday
     Thursday
     Friday
     Saturday
     Sunday
 

Type Parameters:

E - Enum type

Parameters:

c - Enum to process

Returns:

Stream over enum

enums

static <E extends java.lang.Enum<E>> ReactiveSeq<E> enums(java.lang.Class<E> c,
                                                          E start)

Stream over the values of an enum

     
     ReactiveSeq.enums(Days.class,Days.Wednesday)
                     .printOut();
     

     Wednesday
     Thursday
     Friday
     Saturday
     Sunday
 

Type Parameters:

E - Enum type

Parameters:

c - Enum to process

start - Start value

Returns:

Stream over enum

enumsFromTo

static <E extends java.lang.Enum<E>> ReactiveSeq<E> enumsFromTo(java.lang.Class<E> c,
                                                                E start,
                                                                E end)

Stream over the values of an enum

     
     ReactiveSeq.enums(Days.class,Days.Wednesday,Days.Friday)
    .printOut();
     

     Wednesday
     Thursday
     Friday
 

Type Parameters:

E - Enum type

Parameters:

c - Enum to process

start - Start value

end - End value

Returns:

Stream over enum

enums

static <E extends java.lang.Enum<E>> ReactiveSeq<E> enums(java.lang.Class<E> c,
                                                          E start,
                                                          E step,
                                                          E end)

Stream over the values of an enum

     
     ReactiveSeq.enums(Days.class,Days.Monday,Days.Wednesday,Days.Friday)
                      .printOut();
     
     Monday
     Wednesday
     Friday
 

Type Parameters:

E - Enum type

Parameters:

c - Enum to process

start - Start value

step - Values for which the Distance from start in terms of the enum ordinal determines the stepping function

end - End value

Returns:

Stream over enum

widen

static <T> Higher<DataWitness.reactiveSeq,T> widen(ReactiveSeq<T> narrow)

enqueued

static <T> ReactiveSeq<T> enqueued(java.util.function.Consumer<? super org.reactivestreams.Subscriber<T>> sub)

Create a Stream that accepts data via the Subsriber passed into the supplied Consumer. reactive-streams susbscription can be used to determine demand (or ignored and data passed via onNext, onError) excess supply over demand is enqueued

     
      ReactiveSeq<Integer> input = ReactiveSeq.enqueued(subscriber->{
                                                          listener.onEvent(subscriber::onNext);
                                                          listener.onError(susbscriber::onError);
                                                          closeListener.onEvent(subscriber::onClose);
                                                      });
      
 

Type Parameters:

T -

Parameters:

sub -

Returns:

enqueuedAll

static <T> ReactiveSeq<T> enqueuedAll(java.util.function.Consumer<? super org.reactivestreams.Subscriber<T>>... subs)

enqueued

static <T> ReactiveSeq<T> enqueued(Queue<T> q,
                                   java.util.function.Consumer<? super org.reactivestreams.Subscriber<T>> sub)

enqueued

static <T> ReactiveSeq<T> enqueued(QueueFactory<T> factory,
                                   java.util.function.Consumer<? super org.reactivestreams.Subscriber<T>>... subs)

fromCharSequence

static com.oath.cyclops.internal.stream.OneShotStreamX<java.lang.Integer> fromCharSequence(java.lang.CharSequence input)

Construct a ReactiveSeq from a String

Parameters:

input - String to construct ReactiveSeq from

Returns:

ReactiveSeq from a String

ofInts

static ReactiveSeq<java.lang.Integer> ofInts(int... values)

Parameters:

values - ints to populate Stream from

Returns:

ReactiveSeq of multiple Integers

limitInts

static java.util.function.Function<? super ReactiveSeq<java.lang.Integer>,? extends ReactiveSeq<java.lang.Integer>> limitInts(long maxSize)

skipInts

static java.util.function.Function<? super ReactiveSeq<java.lang.Integer>,? extends ReactiveSeq<java.lang.Integer>> skipInts(long skip)

mapInts

static java.util.function.Function<? super ReactiveSeq<java.lang.Integer>,? extends ReactiveSeq<java.lang.Integer>> mapInts(java.util.function.IntUnaryOperator b)

filterInts

static java.util.function.Function<? super ReactiveSeq<java.lang.Integer>,? extends ReactiveSeq<java.lang.Integer>> filterInts(java.util.function.IntPredicate b)

concatMapnts

static java.util.function.Function<? super ReactiveSeq<java.lang.Integer>,? extends ReactiveSeq<java.lang.Integer>> concatMapnts(java.util.function.IntFunction<? extends java.util.stream.IntStream> b)

concatInts

static java.util.function.Function<? super ReactiveSeq<java.lang.Integer>,? extends ReactiveSeq<java.lang.Integer>> concatInts(ReactiveSeq<java.lang.Integer> b)

ofLongs

static ReactiveSeq<java.lang.Long> ofLongs(long... values)

Parameters:

values - longs to populate Stream from

Returns:

ReactiveSeq of multiple Longs

limitLongs

static java.util.function.Function<? super ReactiveSeq<java.lang.Long>,? extends ReactiveSeq<java.lang.Long>> limitLongs(long maxSize)

skipLongs

static java.util.function.Function<? super ReactiveSeq<java.lang.Long>,? extends ReactiveSeq<java.lang.Long>> skipLongs(long skip)

mapLongs

static java.util.function.Function<? super ReactiveSeq<java.lang.Long>,? extends ReactiveSeq<java.lang.Long>> mapLongs(java.util.function.LongUnaryOperator b)

filterLongs

static java.util.function.Function<? super ReactiveSeq<java.lang.Long>,? extends ReactiveSeq<java.lang.Long>> filterLongs(java.util.function.LongPredicate b)

flatMapLongs

static java.util.function.Function<? super ReactiveSeq<java.lang.Long>,? extends ReactiveSeq<java.lang.Long>> flatMapLongs(java.util.function.LongFunction<? extends java.util.stream.LongStream> b)

concatLongs

static java.util.function.Function<? super ReactiveSeq<java.lang.Long>,? extends ReactiveSeq<java.lang.Long>> concatLongs(ReactiveSeq<java.lang.Long> b)

ofDoubles

static ReactiveSeq<java.lang.Double> ofDoubles(double... values)

Parameters:

values - longs to populate Stream from

Returns:

ReactiveSeq of multiple Longs

limitDouble

static java.util.function.Function<? super ReactiveSeq<java.lang.Double>,? extends ReactiveSeq<java.lang.Double>> limitDouble(long maxSize)

skipDoubles

static java.util.function.Function<? super ReactiveSeq<java.lang.Double>,? extends ReactiveSeq<java.lang.Double>> skipDoubles(long skip)

mapDoubles

static java.util.function.Function<? super ReactiveSeq<java.lang.Double>,? extends ReactiveSeq<java.lang.Double>> mapDoubles(java.util.function.DoubleUnaryOperator b)

filterLongs

static java.util.function.Function<? super ReactiveSeq<java.lang.Double>,? extends ReactiveSeq<java.lang.Double>> filterLongs(java.util.function.DoublePredicate b)

flatMapDoubles

static java.util.function.Function<? super ReactiveSeq<java.lang.Double>,? extends ReactiveSeq<java.lang.Double>> flatMapDoubles(java.util.function.DoubleFunction<? extends java.util.stream.DoubleStream> b)

concatDoubles

static java.util.function.Function<? super ReactiveSeq<java.lang.Double>,? extends ReactiveSeq<java.lang.Double>> concatDoubles(ReactiveSeq<java.lang.Double> b)

of

static <T> ReactiveSeq<T> of(T value)

Efficiently construct a ReactiveSeq from a single value

Specified by:

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

Parameters:

value - Value to construct ReactiveSeq from

Returns:

ReactiveSeq of one value

fromSpliterator

static <T> ReactiveSeq<T> fromSpliterator(java.util.Spliterator<T> spliterator)

Construct a ReactiveSeq from the Supplied Spliterator

Parameters:

spliterator - Spliterator to construct a Stream from

Returns:

ReactiveSeq created from Spliterator

ints

default ReactiveSeq<java.lang.Integer> ints(java.util.function.ToIntFunction<? super T> fn,
                                            java.util.function.Function<? super java.util.stream.IntStream,? extends java.util.stream.IntStream> mapper)

Peform intermediate operations on a primitive IntStream (gives improved performance when working with Integers) If this ReactiveSeq has an OfInt Spliterator it will be converted directly to an IntStream, otherwise the provided conversion function will be used.

 {@code
 ReactiveSeq.range(1, 1000)
            .ints(i->i,s->s.map(i->i*2).filter(i->i<500))
                  .size(),
       //249

 

Parameters:

fn -

mapper -

Returns:

mapToInt

default java.util.stream.IntStream mapToInt(java.util.function.ToIntFunction<? super T> fn)

Specified by:

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

longs

default ReactiveSeq<java.lang.Long> longs(java.util.function.ToLongFunction<? super T> fn,
                                          java.util.function.Function<? super java.util.stream.LongStream,? extends java.util.stream.LongStream> mapper)

Peform intermediate operations on a primitive IntStream (gives improved performance when working with Integers) If this ReactiveSeq has an OfInt Spliterator it will be converted directly to an IntStream, otherwise the provided conversion function will be used.

 {@code
 ReactiveSeq.range(1, 1000)
            .longs(i->i.longValue(),s->s.map(i->i*2).filter(i->i<500))
                  .size(),
       //249

 

Parameters:

fn -

mapper -

Returns:

mapToLong

default java.util.stream.LongStream mapToLong(java.util.function.ToLongFunction<? super T> fn)

Specified by:

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

doubles

default ReactiveSeq<java.lang.Double> doubles(java.util.function.ToDoubleFunction<? super T> fn,
                                              java.util.function.Function<? super java.util.stream.DoubleStream,? extends java.util.stream.DoubleStream> mapper)

Peform intermediate operations on a primitive IntStream (gives improved performance when working with Integers) If this ReactiveSeq has an OfInt Spliterator it will be converted directly to an IntStream, otherwise the provided conversion function will be used.

 {@code
 ReactiveSeq.range(1, 1000)
            .doubles(i->i.doubleValue(),s->s.map(i->i*2).filter(i->i<500))
                  .size(),
       //249

 

Parameters:

fn -

mapper -

Returns:

mapToDouble

default java.util.stream.DoubleStream mapToDouble(java.util.function.ToDoubleFunction<? super T> fn)

Specified by:

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

fill

static <T> ReactiveSeq<T> fill(T t)

Construct a Stream consisting of a single value repeatedly infinitely (use take / drop etc to switch to a finite Stream)

Parameters:

t - Value to fill Stream with

Returns:

Infinite ReactiveSeq consisting of a single value

coflatMap

<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

 

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

      //ReactiveSeq[12]
 
 

Parameters:

fn -

Returns:

unit

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

Specified by:

unit in interface Unit<T>

parallel

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

parallel

default <R> ReactiveSeq<R> parallel(java.util.concurrent.ForkJoinPool fj,
                                    java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R>> fn)

foldParallel

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

foldParallel

default <R> R foldParallel(java.util.concurrent.ForkJoinPool fj,
                           java.util.function.Function<? super java.util.stream.Stream<T>,? extends R> fn)

foldRight

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

Description copied from interface: Folds

Immutable reduction from right to left

Specified by:

foldRight in interface Folds<T>

Parameters:

identity - Identity value for the combiner function (leaves the input unchanged)

accumulator - Combining function

Returns:

Reduced value

printOut

default void printOut()

Description copied from interface: Folds

Print each value in this Folds to the console in turn (left-to-right)

Specified by:

printOut in interface Folds<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)

Description copied from interface: Zippable

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

Specified by:

zip in interface IterableX<T>

Specified by:

zip in interface Traversable<T>

Specified by:

zip in interface Zippable<T>

Parameters:

other - to zip with

zipper - Zip function

Returns:

Combined zippable

zip

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

Description copied from interface: Zippable

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

Specified by:

zip in interface IterableX<T>

Specified by:

zip in interface Traversable<T>

Specified by:

zip in interface Zippable<T>

Parameters:

zipper - Zip / combining function

other - to combine with

Returns:

Combined zippable

zipWithStream

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

Specified by:

zipWithStream in interface IterableX<T>

Specified by:

zipWithStream in interface Traversable<T>

flatten

static <T1> ReactiveSeq<T1> flatten(ReactiveSeq<? extends ReactiveSeq<T1>> nested)

join / flatten one level of a nest hierarchy

 
  ReactiveSeq.of(Arrays.asList(1,2))
             .to(ReactiveSeq::flatten));

  //stream of (1,  2);



 

 

Returns:

Flattened / joined one level

flattenIterable

static <T1> ReactiveSeq<T1> flattenIterable(ReactiveSeq<? extends java.lang.Iterable<T1>> nested)

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]
   
 

Returns:

Stream with values repeated

duplicate

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 stream. Not thread-safe.

 

 	Tuple2<ReactiveSeq<Integer>, ReactiveSeq<Integer>> copies = of(1, 2, 3, 4, 5, 6)
                                                                  .duplicate();
 	assertTrue(copies._1.anyMatch(i > i == 2));
 	assertTrue(copies._2.anyMatch(i > i == 2));

 
 

Returns:

duplicated stream

duplicate

Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> duplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)

triplicate

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.

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

 
 

triplicate

Tuple3<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>> triplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)

quadruplicate

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.

 
 	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

Tuple4<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>> quadruplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)

splitAtHead

Tuple2<Option<T>,ReactiveSeq<T>> splitAtHead()

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

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

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

 

splitAt

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

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]
 
 

partition

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.of(1, 2, 3, 4, 5, 6).partition(i -> i % 2 != 0)

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

 

cycle

default ReactiveSeq<T> cycle(Monoid<T> m,
                             long 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(CyclopsCollectors.toList());
   //List[3,3,3];
   
 

Specified by:

cycle in interface IterableX<T>

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

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

Repeat in a Stream while specified predicate holds

 

 	MutableInt count = MutableInt.of(0);
 	ReactiveSeq.of(1, 2, 2).cycleWhile(next -> count++ < 6)
             .collect(CyclopsCollectors.toList());

 	// List(1,2,2,1,2,2)
 
 

Specified by:

cycleWhile in interface IterableX<T>

Specified by:

cycleWhile in interface Traversable<T>

Parameters:

predicate - repeat while true

Returns:

Repeating Stream

cycleUntil

default 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.getValue()>6)
 		 		.peek(i-> count.mutate(i->i+1))
 		 		.collect(CyclopsCollectors.toList());

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

Specified by:

cycleUntil in interface IterableX<T>

Specified by:

cycleUntil in interface Traversable<T>

Parameters:

predicate - repeat while true

Returns:

Repeating Stream

zipWithStream

<U> ReactiveSeq<Tuple2<T,U>> zipWithStream(java.util.stream.Stream<? extends U> other)

Zip 2 streams into one

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

Specified by:

zipWithStream in interface IterableX<T>

Specified by:

zipWithStream in interface Traversable<T>

zipLatest

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

zip

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

Specified by:

zip in interface IterableX<T>

Specified by:

zip in interface Traversable<T>

Specified by:

zip in interface Zippable<T>

zip3

<S,U> ReactiveSeq<Tuple3<T,S,U>> zip3(java.lang.Iterable<? extends S> second,
                                      java.lang.Iterable<? extends U> third)

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']]
 

 

Specified by:

zip3 in interface IterableX<T>

Specified by:

zip3 in interface Traversable<T>

Specified by:

zip3 in interface Zippable<T>

zip4

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

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

Specified by:

zip4 in interface IterableX<T>

Specified by:

zip4 in interface Traversable<T>

Specified by:

zip4 in interface Zippable<T>

shuffle

default ReactiveSeq<T> shuffle(java.util.Random random)

Specified by:

shuffle in interface IterableX<T>

Specified by:

shuffle in interface Traversable<T>

slice

default ReactiveSeq<T> slice(long from,
                             long to)

Specified by:

slice in interface IterableX<T>

Specified by:

slice in interface Traversable<T>

sorted

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

Specified by:

sorted in interface IterableX<T>

Specified by:

sorted in interface Traversable<T>

shuffle

default ReactiveSeq<T> shuffle()

Specified by:

shuffle in interface IterableX<T>

Specified by:

shuffle in interface Traversable<T>

reduce

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

sorted

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

zipWithIndex

default ReactiveSeq<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 IterableX<T>

Specified by:

zipWithIndex in interface Traversable<T>

sliding

default ReactiveSeq<Seq<T>> sliding(int windowSize)

Create a sliding view over this Sequence

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

  assertThat(list.getValue(0), hasItems(1, 2));
  assertThat(list.getValue(1), hasItems(2, 3));

 

 

Specified by:

sliding in interface IterableX<T>

Specified by:

sliding in interface Traversable<T>

Parameters:

windowSize - Size of sliding window

Returns:

ReactiveSeq with sliding view

sliding

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

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.getValue(0), hasItems(1, 2, 3));
  assertThat(list.getValue(1), hasItems(3, 4, 5));

 

 

Specified by:

sliding in interface IterableX<T>

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<Vector<T>> grouped(int groupSize)

Group elements in a Stream

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

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

 
 

Specified by:

grouped in interface IterableX<T>

Specified by:

grouped in interface Traversable<T>

Parameters:

groupSize - Size of each Group

Returns:

Stream with elements grouped by size

groupedUntil

ReactiveSeq<Vector<T>> groupedUntil(java.util.function.BiPredicate<Vector<? super T>,? super T> predicate)

Create ReactiveSeq of Seq where each Seq is populated while the supplied bipredicate holds. The bipredicate recieves the Seq 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)
               .groupedUntil((s,i)-> s.contains(4) ? true : false)
               .toList()
               .size()
     //5
 
 

Specified by:

groupedUntil in interface IterableX<T>

Specified by:

groupedUntil in interface Traversable<T>

Parameters:

predicate - Window while true

Returns:

ReactiveSeq windowed while predicate holds

groupedUntil

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

groupedWhile

ReactiveSeq<Vector<T>> groupedWhile(java.util.function.BiPredicate<Vector<? super T>,? super T> predicate)

groupedWhile

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

groupedBySizeAndTime

ReactiveSeq<Vector<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)
              .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 single batch in

t - time unit for batch

Returns:

ReactiveSeq batched by size and time

groupedBySizeAndTime

<C extends PersistentCollection<? 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

 
 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 single batch in

unit - time unit for batch

factory - Collection factory

Returns:

ReactiveSeq batched by size and time

groupedBySizeAndTime

<C extends PersistentCollection<? 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

<C extends PersistentCollection<? 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

ReactiveSeq<Vector<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(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 single batch in

t - time unit for batch

Returns:

ReactiveSeq batched into lists by time period

groupedByTime

<C extends PersistentCollection<? 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

 
   assertThat(ReactiveSeq.of(1,1,1,1,1,1)
                       .batchByTime(1500,TimeUnit.MICROSECONDS,()->TreeSet.empty())
                       .toList()
                       .getValue(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 toX types by time period

grouped

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

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()
                      .getValue(0)
                      .size(),is(1));
 
 

Specified by:

grouped in interface IterableX<T>

Specified by:

grouped in interface Traversable<T>

Parameters:

size - batch size

supplier - Collection factory

Returns:

ReactiveSeq batched into toX types by size

groupedUntil

default ReactiveSeq<Vector<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 IterableX<T>

Specified by:

groupedUntil in interface Traversable<T>

Parameters:

predicate - Batch until predicate holds, applyHKT open next batch

Returns:

ReactiveSeq batched into lists determined by the predicate supplied

groupedWhile

ReactiveSeq<Vector<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 IterableX<T>

Specified by:

groupedWhile in interface Traversable<T>

Parameters:

predicate - Batch while predicate holds, applyHKT open next batch

Returns:

ReactiveSeq batched into lists determined by the predicate supplied

groupedWhile

<C extends PersistentCollection<? 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 IterableX<T>

Specified by:

groupedWhile in interface Traversable<T>

Parameters:

predicate - Batch while predicate holds, applyHKT open next batch

factory - Collection factory

Returns:

ReactiveSeq batched into collections determined by the predicate supplied

groupedUntil

default <C extends PersistentCollection<? 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 IterableX<T>

Specified by:

groupedUntil in interface Traversable<T>

Parameters:

predicate - Batch until predicate holds, applyHKT open next batch

factory - Collection factory

Returns:

ReactiveSeq batched into collections determined by the predicate supplied

groupBy

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

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

 
  HashMap<Integer, Vector<Integer>> map1 = of(1, 2, 3, 4).groupBy(i -> i % 2);
  assertEquals(Vector.of(2, 4), map1.getOrElse(0,Vector.empty()));
  assertEquals(Vector.of(1, 3), map1.getOrElse(1,Vector.empty()));
  assertEquals(2, map1.size());

 

 

Specified by:

groupBy in interface Folds<T>

distinct

ReactiveSeq<T> distinct()

Specified by:

distinct in interface IterableX<T>

Specified by:

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

Specified by:

distinct in interface Traversable<T>

scanLeft

default 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 IterableX<T>

Specified by:

scanLeft in interface Traversable<T>

Parameters:

monoid -

Returns:

ReactiveSeq with values combined scanning left

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 IterableX<T>

Specified by:

scanLeft in interface Traversable<T>

scanRight

default 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 IterableX<T>

Specified by:

scanRight in interface Traversable<T>

scanRight

default <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 IterableX<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 IterableX<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 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()

  //Seq(3,4)
 

Specified by:

combine in interface IterableX<T>

Specified by:

combine in interface Traversable<T>

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

combine

default ReactiveSeq<T> combine(Monoid<T> op,
                               java.util.function.BiPredicate<? super T,? super T> predicate)

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 result of a combination may in turn be combined with it's neighbour

 
  ReactiveSeq.of(1,1,2,3)
                  .combine(Monoids.intMult,(a, b)->a.equals(b))
                  .listX()

  //Seq(1)
 

Simalar to @see Traversable.combine(BiPredicate, BinaryOperator) but differs in that the first comparison is always to the Monoid zero This allows us to terminate with just a single value

Specified by:

combine in interface IterableX<T>

Specified by:

combine in interface Traversable<T>

Parameters:

op - Monoid to combine neighbours

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

Returns:

Combined / Partially Reduced Traversable

sorted

default 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 IterableX<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)

Description copied from interface: Traversable

Generate a new Traversable that takes elements from this Traversable as long as the predicate holds

 
     Seq.of(1,2,3).takeWhile(i<3);
     //[1,2]
 
 

Specified by:

takeWhile in interface IterableX<T>

Specified by:

takeWhile in interface Traversable<T>

Parameters:

p - Predicate to determine when values should be taken

Returns:

Traversable generated by application of the predicate to the elements in this Traversable in order

drop

default ReactiveSeq<T> drop(long drop)

Description copied from interface: Traversable

  assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7))); 
 

Specified by:

drop in interface IterableX<T>

Specified by:

drop in interface Traversable<T>

Parameters:

drop - Number of elemenets to drop

Returns:

Traversable with specified number of elements skipped

take

default ReactiveSeq<T> take(long take)

Description copied from interface: Traversable

  assertThat(ReactiveSeq.of(4,3,6,7).take(2).toList(),equalTo(Arrays.asList(4,3));
 

Specified by:

take in interface IterableX<T>

Specified by:

take in interface Traversable<T>

Parameters:

take - Limit element size to num

Returns:

Monad converted to Stream with elements up to num

dropWhile

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

Description copied from interface: Traversable

Generate a new Traversable that drops elements from this Traversable as long as the predicate holds

 
     Seq.of(1,2,3).dropWhile(i<3);
     //[3]
 
 

Specified by:

dropWhile in interface IterableX<T>

Specified by:

dropWhile in interface Traversable<T>

Parameters:

p - Predicate to determine when values should be dropped

Returns:

Traversable generated by application of the predicate to the elements in this Traversable in order

takeUntil

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

Description copied from interface: Traversable

Generate a new Traversable that takes elements from this Traversable until the predicate holds

 
     Seq.of(1,2,3).takeUntil(i<2);
     //[1,2]
 
 

Specified by:

takeUntil in interface IterableX<T>

Specified by:

takeUntil in interface Traversable<T>

Parameters:

p - Predicate to determine when values should be taken until

Returns:

Traversable generated by application of the predicate to the elements in this Traversable in order

dropUntil

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

Description copied from interface: Traversable

Generate a new Traversable that drops elements from this Traversable until the predicate holds

 
     Seq.of(1,2,3).dropUntil(i>2);
     //[3]
 
 

Specified by:

dropUntil in interface IterableX<T>

Specified by:

dropUntil in interface Traversable<T>

Parameters:

p - Predicate to determine when values should be dropped

Returns:

Traversable generated by application of the predicate to the elements in this Traversable in order

dropRight

default ReactiveSeq<T> dropRight(int num)

Description copied from interface: Traversable

Generate a new Traversable that drops the specified number elements from the take of this Traversable

 
     Seq.of(1,2,3).dropRight(2);
     //[1]
 
 

Specified by:

dropRight in interface IterableX<T>

Specified by:

dropRight in interface Traversable<T>

Parameters:

num - Drop this number of elements from the take of this Traversable

Returns:

Traversable generated by application of the predicate to the elements in this Traversable in order

takeRight

default ReactiveSeq<T> takeRight(int num)

Description copied from interface: Traversable

Generate a new Traversable that takes the specified number elements from the take of this Traversable

 
     Seq.of(1,2,3).takeRight(2);
     //[2,3]
 
 

Specified by:

takeRight in interface IterableX<T>

Specified by:

takeRight in interface Traversable<T>

Parameters:

num - Take this number of elements from the take of this Traversable

Returns:

Traversable generated by application of the predicate to the elements in this Traversable in order

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 IterableX<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

forEach

void forEach(java.util.function.Consumer<? super T> action)

Performs an action for each element of this Stream. For potentially non-blocking analogs see forEachAsync(Consumer) and forEach overloads such as IterableX.forEach(Consumer, Consumer) and IterableX.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 stream pipelines, this operation does not guarantee to respect the encounter order of the stream, 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.

Specified by:

forEach in interface java.lang.Iterable<T>

Specified by:

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

Parameters:

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

forEachAsync

default void forEachAsync(java.util.function.Consumer<? super T> action)

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

Parameters:

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

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 IterableX<T>

Specified by:

skipWhile in interface Traversable<T>

Parameters:

p - Predicate to skip while true

Returns:

Stream with elements skipped while predicate holds

skipUntil

default 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 IterableX<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)

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 IterableX<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 IterableX<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 IterableX<T>

Specified by:

limitUntil in interface Traversable<T>

Parameters:

p - Limit until predicate is true

Returns:

Stream with limited elements

limitUntilClosed

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

parallel

ReactiveSeq<T> parallel()

Specified by:

parallel in interface java.util.stream.BaseStream<T,java.util.stream.Stream<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 Folds<T>

Specified by:

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

Parameters:

c - Predicate to check if all fold

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 Folds<T>

Specified by:

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

Parameters:

c - Predicate to check if any fold

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 Folds<T>

noneMatch

boolean noneMatch(java.util.function.Predicate<? super T> c)

Specified by:

noneMatch in interface Folds<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 Folds<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 Folds<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 Folds<T>

Returns:

Stream as concatenated String

findFirst

java.util.Optional<T> findFirst()

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().getValue();

 //3
 
 

(deterministic)

takeOne

Maybe<T> takeOne()

Lazy / reactive analogue of findFirst / findAny from JDK For push based reactive-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.

Specified by:

takeOne in interface Folds<T>

Returns:

findFirstOrError

LazyEither<java.lang.Throwable,T> findFirstOrError()

Lazy / reactive look up of first value , capturing the first error, if one occurs. If no values are present a NoSuchElementException is returned. For push based reactive-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:

findAny

java.util.Optional<T> findAny()

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().getValue();

 //3
 
 

(non-deterministic)

foldMap

<R> R foldMap(Reducer<R,T> reducer)

 
 ReactiveSeq.of("hello","2","world","4").foldMap(Reducers.toCountInt());

 //4
 
 

Specified by:

foldMap in interface Folds<T>

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

foldMap

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

  
  ReactiveSeq.of("one","two","three","four")
           .foldMap(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:

foldMap in interface Folds<T>

Parameters:

mapper - Function to transform 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
 
 

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 java.util.stream.Stream<T>

reduce

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

Specified by:

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

reduceAll

default <R> ReactiveSeq<R> reduceAll(R identity,
                                     java.util.function.BiFunction<R,? super T,R> accumulator)

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 java.util.stream.Stream<T>

collect

default <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 stream. 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.getValue();
     for (T element : this stream)
         accumulator.accept(result, element);
     return result;
 

Like reduce(Object, BinaryOperator), collect operations can be parallelized without requiring additional synchronization.

This is a terminal operation.

Specified by:

collect in interface Folds<T>

Specified by:

collect in interface java.util.stream.Stream<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

collectAll

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

collect

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

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

If the stream is parallel, and the Collector is concurrent, and lazy the stream 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 Folds<T>

Specified by:

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

Parameters:

collector - the Collector describing the reduction

Returns:

the result of the reduction

See Also:

collect(Supplier, BiConsumer, BiConsumer), Collectors

reduce

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

 

Parameters:

reducers -

Returns:

foldRight

T foldRight(Monoid<T> reducer)

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

         // "cab"
         
 

Specified by:

foldRight in interface Folds<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 Folds<T>

Parameters:

identity - Identity value for the combiner function (leaves the input unchanged)

accumulator - Combining function

Returns:

Reduced value

foldMapRight

<R> R foldMapRight(Reducer<R,T> reducer)

Attempt to transform 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:

foldMapRight in interface Folds<T>

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

toSet

default java.util.Set<T> toSet()

Description copied from interface: Folds

Collect the collectable into a LinkedHashSet.

Specified by:

toSet in interface Folds<T>

Returns:

This Stream converted to a set

toList

default java.util.List<T> toList()

Specified by:

toList in interface Folds<T>

Returns:

this Stream converted to a list

stream

ReactiveSeq<T> stream()

Convert this ReactiveSeq into a Stream

Specified by:

stream in interface Folds<T>

Specified by:

stream in interface IterableX<T>

Specified by:

stream in interface Traversable<T>

Returns:

This Traversable converted to a Stream

startsWith

boolean startsWith(java.lang.Iterable<T> iterable)

 
  assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Arrays.asList(1,2,3)));
 
 

Specified by:

startsWith in interface Folds<T>

Parameters:

iterable -

Returns:

True if Monad starts with Iterable sequence of data

map

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

 
 

Specified by:

map in interface FilterableTransformable<T>

Specified by:

map in interface IterableX<T>

Specified by:

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

Specified by:

map in interface Transformable<T>

Specified by:

map in interface Traversable<T>

Parameters:

fn - Transformation function

Returns:

Transformed Transformable

peek

default ReactiveSeq<T> peek(java.util.function.Consumer<? super T> c)

Description copied from interface: Transformable

Peek at the current value of this Transformable, without transforming it

 


    of(1,2,3).map(System.out::println)

    1
    2
    3

 
 

Specified by:

peek in interface IterableX<T>

Specified by:

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

Specified by:

peek in interface Transformable<T>

Parameters:

c - Consumer that recieves each element from this Transformable

Returns:

Transformable 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 java.util.stream.Stream<T>

Parameters:

fn - to be applied

Returns:

new stage in Sequence with flatMap operation to be lazily applied

concatMap

<R> ReactiveSeq<R> concatMap(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
 
 

Specified by:

concatMap in interface IterableX<T>

Parameters:

fn -

Returns:

mergeMap

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

Specified by:

mergeMap in interface IterableX<T>

mergeMap

<R> ReactiveSeq<R> mergeMap(int maxConcurrency,
                            java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)

Specified by:

mergeMap in interface IterableX<T>

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: Filters

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 FilterableTransformable<T>

Specified by:

filter in interface Filters<T>

Specified by:

filter in interface IterableX<T>

Specified by:

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

Parameters:

fn - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

spliterator

java.util.Spliterator<T> spliterator()

Returns a spliterator for the elements of this stream.

This is a terminal operation.

Specified by:

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

Specified by:

spliterator in interface java.lang.Iterable<T>

Returns:

the element spliterator for this stream

sequential

ReactiveSeq<T> sequential()

Specified by:

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

unordered

ReactiveSeq<T> unordered()

Specified by:

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

intersperse

default 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 IterableX<T>

Specified by:

intersperse in interface Traversable<T>

ofType

default <U> ReactiveSeq<U> 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 Filters<T>

Specified by:

ofType in interface IterableX<T>

reverse

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

Specified by:

reverse in interface IterableX<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>>

prependStream

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

Prepend Stream to this ReactiveSeq

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

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

Specified by:

prependStream in interface IterableX<T>

Specified by:

prependStream in interface Traversable<T>

Parameters:

stream - to Prepend

Returns:

ReactiveSeq with Stream prepended

appendAll

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

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

Specified by:

appendAll in interface IterableX<T>

Specified by:

appendAll in interface Traversable<T>

Parameters:

values - to append

Returns:

ReactiveSeq with appended values

append

ReactiveSeq<T> append(T value)

Specified by:

append in interface IterableX<T>

Specified by:

append in interface Traversable<T>

prepend

ReactiveSeq<T> prepend(T value)

Specified by:

prepend in interface IterableX<T>

Specified by:

prepend in interface Traversable<T>

prependAll

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

Prepend given values to the skip of the Stream

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

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

Specified by:

prependAll in interface IterableX<T>

Specified by:

prependAll in interface Traversable<T>

Parameters:

values - to prependAll

Returns:

ReactiveSeq with values prepended

insertAt

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

Insert data into a ReactiveSeq at a given position

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

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

Specified by:

insertAt in interface IterableX<T>

Specified by:

insertAt in interface Traversable<T>

Parameters:

pos - to insert data at

values - to insert

Returns:

Stream with new data inserted

insertAt

default ReactiveSeq<T> insertAt(int pos,
                                T value)

Specified by:

insertAt in interface IterableX<T>

insertAt

default ReactiveSeq<T> insertAt(int pos,
                                java.lang.Iterable<? extends T> values)

Specified by:

insertAt in interface IterableX<T>

Specified by:

insertAt in interface Traversable<T>

insertAt

default ReactiveSeq<T> insertAt(int pos,
                                ReactiveSeq<? extends T> values)

Specified by:

insertAt in interface Traversable<T>

deleteBetween

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

Delete elements between given indexes in a Stream

 
  List<String> result = ReactiveSeq.of(1, 2, 3, 4, 5, 6).deleteBetween(2, 4).map(it -> it + "!!").collect(CyclopsCollectors.toList());

  assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "5!!", "6!!")));     * 
 

Specified by:

deleteBetween in interface IterableX<T>

Specified by:

deleteBetween in interface Traversable<T>

Parameters:

start - index

end - index

Returns:

Stream with elements removed

insertStreamAt

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

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

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

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

Specified by:

insertStreamAt in interface IterableX<T>

Specified by:

insertStreamAt in interface Traversable<T>

Parameters:

pos - to insert Stream at

stream - to insert

Returns:

newly conjoined ReactiveSeq

endsWith

boolean endsWith(java.lang.Iterable<T> iterable)

 
  assertTrue(ReactiveSeq.of(1,2,3,4,5,6)
 				.endsWith(Arrays.asList(5,6)));

 

Specified by:

endsWith in interface Folds<T>

Parameters:

iterable - Values to check

Returns:

true if ReactiveSeq ends with values in the supplied iterable

skip

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

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

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

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

take

default ReactiveSeq take(long time,
                         java.util.concurrent.TimeUnit unit)

drop

default ReactiveSeq drop(long time,
                         java.util.concurrent.TimeUnit unit)

skipLast

ReactiveSeq<T> skipLast(int num)

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

Specified by:

skipLast in interface IterableX<T>

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(CyclopsCollectors.toList()),equalTo(Arrays.asList(4,5)));

 

Specified by:

limitLast in interface IterableX<T>

Specified by:

limitLast in interface Traversable<T>

Parameters:

num - of elements to return (last elements)

Returns:

ReactiveSeq limited to last num elements

hotStream

default Connectable<T> hotStream(java.util.concurrent.Executor e)

Turns this ReactiveSeq into a Connectable, a connectable Stream, being executed on a thread on the supplied executor, that is producing data. Note this method creates a Connectable that starts emitting data immediately. For a hotStream that waits until the first user streams connect @see primedHotStream(Executor). The generated Connectable is not pausable, for a pausable Connectable @see pausableHotStream(Executor). Turns this ReactiveSeq into a Connectable, a connectable Stream, being executed on a thread on the supplied executor, that is producing data

 
  Connectable<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 Connectable

primedHotStream

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

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

 
 
  Connectable<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

default PausableConnectable<T> pausableHotStream(java.util.concurrent.Executor e)

Turns this ReactiveSeq into a Connectable, a connectable & pausable Stream, being executed on a thread on the supplied executor, that is producing data. Note this method creates a Connectable that starts emitting data immediately. For a hotStream that waits until the first user streams connect @see primedPausableHotStream(Executor). The generated Connectable is pausable, for a unpausable Connectable (slightly faster execution) @see hotStream(Executor).

 
  Connectable<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 Connectable

primedPausableHotStream

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

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

 
 
  Connectable<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(T alt)

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

Specified by:

firstValue in interface Folds<T>

Parameters:

alt -

Returns:

first value in this Stream

singleOrElse

default T singleOrElse(T alt)

 

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

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

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

Specified by:

singleOrElse in interface Folds<T>

Parameters:

alt -

Returns:

a single value or an UnsupportedOperationException if 0/1 values in this Stream

single

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

Specified by:

single in interface Folds<T>

single

default Maybe<T> single()

 

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

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

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

Specified by:

single in interface Folds<T>

Returns:

An Maybe with single value if this Stream has exactly one element, otherwise Maybe.none

headOption

default Option<T> headOption()

Specified by:

headOption in interface Folds<T>

elementAt

default Maybe<T> elementAt(long index)

Return the elementAt index or Optional.empty

 
 	assertThat(ReactiveSeq.of(1,2,3,4,5).elementAt(2).getValue(),equalTo(3));
 
 

Specified by:

elementAt in interface Folds<T>

Parameters:

index - to extract element from

Returns:

elementAt index

elementAtAndStream

default Tuple2<T,ReactiveSeq<T>> elementAtAndStream(long index)

Gets the element at index, and returns a Tuple containing the element (it must be present) and a maybe copy of the Sequence for further processing.

 
 ReactiveSeq.of(1,2,3,4,5).getValue(2)._1
 //3
 
 

Parameters:

index - to extract element from

Returns:

Element and Sequence

elapsed

default ReactiveSeq<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<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

empty

static <T> ReactiveSeq<T> empty()

Specified by:

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

ofNullable

static <T> ReactiveSeq<T> ofNullable(T nullable)

of

@SafeVarargs
static <T> ReactiveSeq<T> of(T... elements)

Create an efficiently reversable Sequence from the provided elements

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 skip and take

Parameters:

start - Number of range to skip from

end - Number for range to take at

Returns:

Range ReactiveSeq

range

static ReactiveSeq<java.lang.Integer> range(int start,
                                            int step,
                                            int end)

rangeLong

static ReactiveSeq<java.lang.Long> rangeLong(long start,
                                             long step,
                                             long end)

rangeLong

static ReactiveSeq<java.lang.Long> rangeLong(long start,
                                             long end)

Create an efficiently reversable Sequence that produces the integers between skip and take

Parameters:

start - Number of range to skip from

end - Number for range to take at

Returns:

Range ReactiveSeq

isReplayable

default boolean isReplayable()

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:

oneShotStream

static <T> ReactiveSeq<T> oneShotStream(java.util.stream.Stream<T> stream)

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:

list - to construct Sequence from

Returns:

ReactiveSeq

oneShotList

static <T> ReactiveSeq<T> oneShotList(java.util.List<T> list)

fromPublisher

static <T> ReactiveSeq<T> fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)

Construct a ReactiveSeq from an Publisher

Parameters:

publisher - to construct ReactiveSeq from

Returns:

ReactiveSeq

generate

static <T> ReactiveSeq<T> generate(Generator<T> gen)

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

reactiveSeq

static <T> ReactiveSeq<T> reactiveSeq(java.lang.Iterable<T> iterable)

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 java.util.stream.Stream<T>

See Also:

Stream.iterate(Object, UnaryOperator)

iterate

static <T> ReactiveSeq<T> iterate(T seed,
                                  java.util.function.Predicate<? super T> pred,
                                  java.util.function.UnaryOperator<T> f)

defer

static <T> ReactiveSeq<T> defer(java.util.function.Supplier<? extends java.lang.Iterable<? extends T>> lazy)

deferFromPublisher

static <T> ReactiveSeq<T> deferFromPublisher(java.util.function.Supplier<? extends org.reactivestreams.Publisher<? extends T>> lazy)

deferFromStream

static <T> ReactiveSeq<T> deferFromStream(java.util.function.Supplier<? extends java.util.stream.Stream<? extends T>> lazy)

unfold

static <U,T> ReactiveSeq<T> unfold(U seed,
                                   java.util.function.Function<? super U,Option<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)

 

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 java.util.stream.Stream<T>

See Also:

Stream.generate(Supplier)

unzip

static <T,U> Tuple2<ReactiveSeq<T>,ReactiveSeq<U>> unzip(ReactiveSeq<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> Tuple3<ReactiveSeq<T1>,ReactiveSeq<T2>,ReactiveSeq<T3>> unzip3(ReactiveSeq<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> Tuple4<ReactiveSeq<T1>,ReactiveSeq<T2>,ReactiveSeq<T3>,ReactiveSeq<T4>> unzip4(ReactiveSeq<Tuple4<T1,T2,T3,T4>> sequence)

Unzip a zipped Stream into 4

 
 unzip4(ReactiveSeq.of(new Tuple4(1, "a", 2l,'reactiveSeq'), 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[reactiveSeq,y,x]
 

onEmptySwitch

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

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

Specified by:

onEmptySwitch in interface OnEmptySwitch<T,java.util.stream.Stream<T>>

Parameters:

switchTo - Supplier that will generate the alternative Stream

Returns:

ReactiveSeq that will switch to an alternative Stream if empty

onEmpty

default ReactiveSeq<T> onEmpty(T value)

Description copied from interface: OnEmpty

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

Specified by:

onEmpty in interface IterableX<T>

Specified by:

onEmpty in interface OnEmpty<T>

Specified by:

onEmpty in interface Traversable<T>

Returns:

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

onEmptyGet

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

Specified by:

onEmptyGet in interface IterableX<T>

Specified by:

onEmptyGet in interface OnEmpty<T>

Specified by:

onEmptyGet in interface Traversable<T>

Parameters:

supplier - to determine new value for container

Returns:

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

onEmptyError

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

distinct

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

xPer

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

emit x elements per time period

 
 	code
 	SimpleTimer timer = new SimpleTimer();
 	ReactiveSeq.of(1, 2, 3, 4, 5, 6)
             .xPer(6, 100000000, TimeUnit.NANOSECONDS)
             .collect(CyclopsCollectors.toList())
             .size();
 //6

 
 

Specified by:

xPer in interface Traversable<T>

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

Specified by:

onePer in interface Traversable<T>

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 - Time to applyHKT debouncing over

t - Time unit for debounce period

Returns:

ReactiveSeq with debouncing applied

fixedDelay

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

emit elements after a fixed delay

 
 	SimpleTimer timer = new SimpleTimer();
 	ReactiveSeq.of(1, 2, 3, 4, 5, 6)
             .fixedDelay(10000, TimeUnit.NANOSECONDS)
             .collect(CyclopsCollectors.toList())
             .size();
  //6
 	assertThat(timer.getElapsedNanoseconds(), greaterThan(60000l));
 
 

Specified by:

fixedDelay in interface Traversable<T>

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();
        ReactiveSeq.of(1, 2, 3, 4, 5, 6)
             .jitter(10000)
             .collect(CyclopsCollectors.toList());

        assertThat(timer.getElapsedNanoseconds(), greaterThan(20000l));
 }
 

Parameters:

maxJitterPeriodInNanos - - random number less than this is used for each jitter

Returns:

ReactiveSeq with a random jitter between element emission

onComplete

ReactiveSeq<T> onComplete(java.lang.Runnable fn)

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

ReactiveSeq<T> recover(java.util.function.Function<? super 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"));
 
 

Specified by:

recover in interface RecoverableTraversable<T>

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

 
 

Specified by:

recover in interface RecoverableTraversable<T>

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

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.

 



 		String result = ReactiveSeq.of( 1,  2, 3)
 				.retry(this::makeIOCall, 7, 2, TimeUnit.SECONDS)
 				.firstValue();

 		//result = [service call result]
 
 

Specified by:

retry in interface ReactiveTransformable<T>

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.

 



 		String result = ReactiveSeq.of( 1,  2, 3)
 				.retry(this::makeIOCall, 7, 2, TimeUnit.SECONDS)
 				.firstValue();

 		//result = [service call result]
 
 

Specified by:

retry in interface ReactiveTransformable<T>

Parameters:

fn - Function to retry if fails

retries - Number of retries

delay - Delay in TimeUnits

timeUnit - TimeUnit to use for delay

removeValue

default ReactiveSeq<T> removeValue(T t)

Remove all occurances of the specified element from the ReactiveSeq

 
 	ReactiveSeq.of(1,2,3,4,5,1,2,3).removeValue(1)

  //Streamable[2,3,4,5,2,3]
 
 

Specified by:

removeValue in interface IterableX<T>

Parameters:

t - element to removeValue

Returns:

Filtered Stream / ReactiveSeq

removeAt

default ReactiveSeq<T> removeAt(long index)

Specified by:

removeAt in interface IterableX<T>

Specified by:

removeAt in interface Traversable<T>

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 toX

Specified by:

permutations in interface IterableX<T>

Returns:

Permutations from this ReactiveSeq

subStream

default ReactiveSeq<T> subStream(int start,
                                 int end)

Return a Stream with elements before the provided skip index removed, and elements after the provided take 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 IterableX<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 IterableX<T>

Returns:

All combinations of the elements in this stream

schedule

default Connectable<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

 

  Connectable<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 Connectable of emitted from scheduled Stream

scheduleFixedDelay

default Connectable<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

 
  Connectable<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 Connectable of emitted from scheduled Stream

scheduleFixedRate

default Connectable<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

 
  Connectable<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 Connectable of emitted from scheduled Stream

size

default int size()

[equivalent to count]

Specified by:

size in interface IterableX<T>

Returns:

size

forEach4

default <R1,R2,R3,R> ReactiveSeq<R> forEach4(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1,
                                             java.util.function.BiFunction<? super T,? super R1,? extends java.util.stream.BaseStream<R2,?>> stream2,
                                             Function3<? super T,? super R1,? super R2,? extends java.util.stream.BaseStream<R3,?>> stream3,
                                             Function4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

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

 

   //ReactiveSeq [1,2]

   reactiveSeq.forEach4(a->Seq.range(10,13),
                        (a,b)->Seq.of(""+(a+b),"hello world"),
                        (a,b,c)->Seq.of(a,b,c)),
                        (a,b,c,d)->c+":"a+":"+b);


 
 

Parameters:

stream1 - Nested Stream to iterate over

stream2 - Nested Stream to iterate over

stream3 - 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 nest iteration

forEach4

default <R1,R2,R3,R> ReactiveSeq<R> forEach4(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1,
                                             java.util.function.BiFunction<? super T,? super R1,? extends java.util.stream.BaseStream<R2,?>> stream2,
                                             Function3<? super T,? super R1,? super R2,? extends java.util.stream.BaseStream<R3,?>> stream3,
                                             Function4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
                                             Function4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

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

 
  //ReactiveSeq [1,2,3]

 seq.forEach4(a->ReactiveSeq.range(10,13),
                     (a,b)->Stream.of(""+(a+b),"hello world"),
                     (a,b,c)->Stream.of(a,b,c),
                     (a,b,c,d)-> c!=3,
                      (a,b,c)->c+":"a+":"+b);



 
 

Parameters:

stream1 - Nested Stream to iterate over

stream2 - Nested Stream to iterate over

stream3 - Nested Stream to iterate over

filterFunction - Filter to applyHKT 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 nest iteration

forEach3

default <R1,R2,R> ReactiveSeq<R> forEach3(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1,
                                          java.util.function.BiFunction<? super T,? super R1,? extends java.util.stream.BaseStream<R2,?>> stream2,
                                          Function3<? super T,? super R1,? 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 nest iteration

forEach3

default <R1,R2,R> ReactiveSeq<R> forEach3(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1,
                                          java.util.function.BiFunction<? super T,? super R1,? extends java.util.stream.BaseStream<R2,?>> stream2,
                                          Function3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction,
                                          Function3<? super T,? super R1,? 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 applyHKT 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 nest iteration

forEach2

default <R1,R> ReactiveSeq<R> forEach2(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1,
                                       java.util.function.BiFunction<? super T,? 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 nest iteration

crossJoin

default <U> ReactiveSeq<Tuple2<T,U>> crossJoin(ReactiveSeq<? extends U> other)

crossJoin two Streams forming a cartesian zip over both

Parameters:

other - Stream to crossJoin

Returns:

Active Stream with each pair across both Streams in a Tuple

forEach2

default <R1,R> ReactiveSeq<R> forEach2(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1,
                                       java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction,
                                       java.util.function.BiFunction<? super T,? 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 applyHKT 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 nest iteration

max

default java.util.Optional<T> max(java.util.Comparator<? super T> comparator)

Specified by:

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

count

long count()

Returns the count of elements in this stream. This is a special case of a reduction and is equivalent to:

     return mapToLong(e -> 1L).sum();
 

This is a terminal operation.

Specified by:

count in interface Folds<T>

Specified by:

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

Returns:

the count of elements in this stream

min

default java.util.Optional<T> min(java.util.Comparator<? super T> comparator)

Specified by:

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

printErr

default void printErr()

Description copied from interface: Folds

Print each value in this Folds to the error console in turn (left-to-right)

Specified by:

printErr in interface Folds<T>

print

default void print(java.io.PrintWriter writer)

Description copied from interface: Folds

Write each element within this Folds in turn to the supplied PrintWriter

Specified by:

print in interface Folds<T>

Parameters:

writer - PrintWriter to tell to

print

default void print(java.io.PrintStream stream)

Description copied from interface: Folds

Write each element within this Folds in turn to the supplied PrintStream

Specified by:

print in interface Folds<T>

Parameters:

stream - PrintStream to tell to

appendStream

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

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

Parameters:

other - to append

Returns:

ReactiveSeq with Stream appended

appendAll

default ReactiveSeq<T> appendAll(java.lang.Iterable<? extends T> value)

Specified by:

appendAll in interface IterableX<T>

Specified by:

appendAll in interface Traversable<T>

prependAll

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

Specified by:

prependAll in interface IterableX<T>

Specified by:

prependAll in interface Traversable<T>

cycle

ReactiveSeq<T> cycle(long times)

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]

 
 

Specified by:

cycle in interface IterableX<T>

Specified by:

cycle in interface Traversable<T>

Parameters:

times - Times values should be repeated within a Stream

Returns:

Stream with values repeated

skipWhileClosed

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

limitWhileClosed

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

removeStream

default ReactiveSeq<T> removeStream(java.util.stream.Stream<? extends T> stream)

Description copied from interface: IterableFilterable

Remove all elements in the supplied Stream from this filterable

Specified by:

removeStream in interface IterableFilterable<T>

Specified by:

removeStream in interface IterableX<T>

Parameters:

stream - of elements to remove

Returns:

Filters with all supplied elements removed

removeAll

default ReactiveSeq<T> removeAll(java.lang.Iterable<? extends T> it)

Description copied from interface: IterableFilterable

Remove all elements in the supplied Iterable from this filterable

Specified by:

removeAll in interface IterableFilterable<T>

Specified by:

removeAll in interface IterableX<T>

Parameters:

it - an Iterable of elements to removeValue

Returns:

Filters with all supplied elements removed

removeAll

default ReactiveSeq<T> removeAll(T... values)

Description copied from interface: IterableFilterable

Remove all supplied elements from this filterable

Specified by:

removeAll in interface IterableFilterable<T>

Specified by:

removeAll in interface IterableX<T>

Parameters:

values - to removeValue

Returns:

Filters with all supplied values removed

retainAll

default ReactiveSeq<T> retainAll(java.lang.Iterable<? extends T> it)

Description copied from interface: IterableFilterable

Retain only the supplied elements in the returned Filters

Specified by:

retainAll in interface IterableFilterable<T>

Specified by:

retainAll in interface IterableX<T>

Parameters:

it - Iterable of elements to retain

Returns:

Filters with supplied values retained, and others removed

retainStream

default ReactiveSeq<T> retainStream(java.util.stream.Stream<? extends T> stream)

Description copied from interface: IterableFilterable

Retain only the supplied elements in the returned Filters

Specified by:

retainStream in interface IterableFilterable<T>

Specified by:

retainStream in interface IterableX<T>

Parameters:

stream - of elements to retain

Returns:

Filters with supplied values retained, and others removed

retainAll

default ReactiveSeq<T> retainAll(T... values)

Description copied from interface: IterableFilterable

Retain only the supplied elements in the returned Filters

Specified by:

retainAll in interface IterableFilterable<T>

Specified by:

retainAll in interface IterableX<T>

Parameters:

values - elements to retain

Returns:

Filters with supplied values retained, and others removed

filterNot

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

Description copied from interface: Filters

Remove any elements for which the predicate holds (inverse operation to filter) e.g.

 

     of(1,2,3).filter(i->i>2);

     //[1,2]

 
 

Specified by:

filterNot in interface Filters<T>

Specified by:

filterNot in interface IterableX<T>

Specified by:

filterNot in interface Traversable<T>

Parameters:

predicate - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

notNull

default ReactiveSeq<T> notNull()

Description copied from interface: Filters

Filter elements retaining only values which are not null

 

   of(1,2,null,4).nonNull();

   //[1,2,4]

 
 

Specified by:

notNull in interface Filters<T>

Specified by:

notNull in interface IterableX<T>

Returns:

Filters with nulls removed

isEmpty

default boolean isEmpty()

Specified by:

isEmpty in interface IterableX<T>

zipWithPublisher

default <U> ReactiveSeq<Tuple2<T,U>> zipWithPublisher(org.reactivestreams.Publisher<? extends U> other)

Specified by:

zipWithPublisher in interface IterableX<T>

Specified by:

zipWithPublisher in interface Traversable<T>

Specified by:

zipWithPublisher in interface Zippable<T>

zip3

default <S,U,R> ReactiveSeq<R> zip3(java.lang.Iterable<? extends S> second,
                                    java.lang.Iterable<? extends U> third,
                                    Function3<? super T,? super S,? super U,? extends R> fn3)

Specified by:

zip3 in interface IterableX<T>

Specified by:

zip3 in interface Traversable<T>

Specified by:

zip3 in interface Zippable<T>

zip4

default <T2,T3,T4,R> ReactiveSeq<R> zip4(java.lang.Iterable<? extends T2> second,
                                         java.lang.Iterable<? extends T3> third,
                                         java.lang.Iterable<? extends T4> fourth,
                                         Function4<? super T,? super T2,? super T3,? super T4,? extends R> fn)

Specified by:

zip4 in interface IterableX<T>

Specified by:

zip4 in interface Traversable<T>

Specified by:

zip4 in interface Zippable<T>

mergeP

default ReactiveSeq<T> mergeP(org.reactivestreams.Publisher<T>... publishers)

backpressureAware

default ReactiveSeq<T> backpressureAware()

mergeP

default 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. The QueueFactory parameter can be used by pull based Streams to control the maximum queued elements @see QueueFactories Push based reactive-streams signal demand via their subscription.

publishTo

default ReactiveSeq<T> publishTo(Adapter<T>... adapters)

publishTo

default ReactiveSeq<T> publishTo(Signal<T>... signals)

merge

default ReactiveSeq<T> merge(Adapter<T>... adapters)

fold

<R> R fold(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)

multicast

default Seq<ReactiveSeq<T>> multicast(int num)

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 duplicate() triplicate() 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

fanOutZipIn

default <R1,R2,R3> ReactiveSeq<R3> fanOutZipIn(java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R1>> path1,
                                               java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R2>> path2,
                                               java.util.function.BiFunction<? super R1,? super R2,? extends R3> zipFn)

parallelFanOutZipIn

default <R1,R2,R3> ReactiveSeq<R3> parallelFanOutZipIn(java.util.concurrent.ForkJoinPool fj,
                                                       java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R1>> path1,
                                                       java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R2>> path2,
                                                       java.util.function.BiFunction<? super R1,? super R2,? extends R3> zipFn)

fanOut

default <R> ReactiveSeq<R> fanOut(java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R>> path1,
                                  java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R>> path2)

parallelFanOut

default <R> ReactiveSeq<R> parallelFanOut(java.util.concurrent.ForkJoinPool fj,
                                          java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R>> path1,
                                          java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R>> path2)

fanOut

default <R> ReactiveSeq<R> fanOut(java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R>> path1,
                                  java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R>> path2,
                                  java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R>> path3)

parallelFanOut

default <R> ReactiveSeq<R> parallelFanOut(java.util.concurrent.ForkJoinPool fj,
                                          java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R>> path1,
                                          java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R>> path2,
                                          java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R>> path3)

parallelFanOutZipIn

default <R1,R2,R3,R4> ReactiveSeq<R4> parallelFanOutZipIn(java.util.concurrent.ForkJoinPool fj,
                                                          java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R1>> path1,
                                                          java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R2>> path2,
                                                          java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R3>> path3,
                                                          Function3<? super R1,? super R2,? super R3,? extends R4> zipFn)

fanOutZipIn

default <R1,R2,R3,R4> ReactiveSeq<R4> fanOutZipIn(java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R1>> path1,
                                                  java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R2>> path2,
                                                  java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R3>> path3,
                                                  Function3<? super R1,? super R2,? super R3,? extends R4> zipFn)

fanOut

default <R> ReactiveSeq<R> fanOut(java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R>> path1,
                                  java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R>> path2,
                                  java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R>> path3,
                                  java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R>> path4)

parallelFanOut

default <R> ReactiveSeq<R> parallelFanOut(java.util.concurrent.ForkJoinPool fj,
                                          java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R>> path1,
                                          java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R>> path2,
                                          java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R>> path3,
                                          java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R>> path4)

fanOutZipIn

default <R1,R2,R3,R4,R5> ReactiveSeq<R5> fanOutZipIn(java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R1>> path1,
                                                     java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R2>> path2,
                                                     java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R3>> path3,
                                                     java.util.function.Function<? super ReactiveSeq<T>,? extends ReactiveSeq<? extends R4>> path4,
                                                     Function4<? super R1,? super R2,? super R3,? super R4,? extends R5> zipFn)

parallelFanOutZipIn

default <R1,R2,R3,R4,R5> ReactiveSeq<R5> parallelFanOutZipIn(java.util.concurrent.ForkJoinPool fj,
                                                             java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R1>> path1,
                                                             java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R2>> path2,
                                                             java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R3>> path3,
                                                             java.util.function.Function<? super java.util.stream.Stream<T>,? extends java.util.stream.Stream<? extends R4>> path4,
                                                             Function4<? super R1,? super R2,? super R3,? super R4,? extends R5> zipFn)

changes

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

broadcast

default Topic<T> broadcast()

ambWith

default ReactiveSeq<T> ambWith(org.reactivestreams.Publisher<T> racer)

ambWith

default ReactiveSeq<T> ambWith(org.reactivestreams.Publisher<T>... racers)

concat

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

concat

static <T> ReactiveSeq<T> concat(java.util.Spliterator<? extends T>... array)

concat

static <T> ReactiveSeq<T> concat(java.util.stream.Stream<? extends T> left,
                                 java.util.stream.Stream<? extends T> right)

Specified by:

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

concat

static <T> ReactiveSeq<T> concat(java.util.Spliterator<? extends T> left,
                                 java.util.Spliterator<? extends T> right)

narrowK

static <T> ReactiveSeq<T> narrowK(Higher<DataWitness.reactiveSeq,T> future)

Convert the raw Higher Kinded Type for ReactiveSeq types into the ReactiveSeq type definition class

Parameters:

future - HKT encoded list into a ReactiveSeq

Returns:

ReactiveSeq

tailRec

static <T,R> ReactiveSeq<R> tailRec(T initial,
                                    java.util.function.Function<? super T,? extends ReactiveSeq<? extends Either<T,R>>> fn)

narrow

static <T> ReactiveSeq<T> narrow(ReactiveSeq<? extends T> broad)