StreamT (cyclops-reactor 9.0.0-FINAL API)

java.lang.Object
- cyclops.monads.transformers.StreamT<W,T>

Type Parameters:

T - Type of data stored inside the nest Streams

All Implemented Interfaces:

NestedCollectable<W,T>, NestedFoldable<W,T>, FoldableTransformerSeq<W,T>, TransformerSeq<W,T>, Filters<T>, To<StreamT<W,T>>, FilterableTransformable<T>, Transformable<T>, TransformerTraversable<T>, OnEmpty<T>, ConvertableToReactiveSeq<T>, ToStream<T>, IterableFilterable<T>, Sequential<T>, Traversable<T>, Unwrapable, Zippable<T>, java.lang.Iterable<T>, org.reactivestreams.Publisher<T>
```
public class StreamT<W extends WitnessType<W>,T>
extends java.lang.Object
implements To<StreamT<W,T>>, FoldableTransformerSeq<W,T>
```
Monad Transformer for Java Streams and related types such as ReactiveSeq StreamT allows the deeply wrapped Stream to be manipulating within it's nest /contained context

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`StreamT<W,T>`	`append(T... values)` Append values to the take of this ReactiveSeq
`StreamT<W,T>`	`append(T value)`
`<U> StreamT<W,U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a reactiveStream to a given type, possibly throwing a `ClassCastException`.
`StreamT<W,T>`	`combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)` Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation.
`StreamT<W,T>`	`combine(Monoid<T> op, java.util.function.BiPredicate<? super T,? super T> predicate)` Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation.
`StreamT<W,T>`	`cycle(long times)` Convert to a Stream with the values repeated specified times
`StreamT<W,T>`	`cycle(Monoid<T> m, long times)` Convert to a Stream with the result of a reduction operation repeated specified times
`StreamT<W,T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream until specified predicate holds
`StreamT<W,T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream while specified predicate holds
`StreamT<W,T>`	`deleteBetween(int start, int end)` Delete elements between given indexes in a Stream
`StreamT<W,T>`	`distinct()`
`StreamT<W,T>`	`drop(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7)));`
`StreamT<W,T>`	`dropRight(int num)` Generate a new Traversable that drops the specified number elements from the take of this Traversable
`StreamT<W,T>`	`dropUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that drops elements from this Traversable until the predicate holds
`StreamT<W,T>`	`dropWhile(java.util.function.Predicate<? super T> p)` Generate a new Traversable that drops elements from this Traversable as long as the predicate holds
`<R> StreamT<W,R>`	`empty()`
`static <W extends WitnessType<W>,T> StreamT<W,T>`	`emptyList(W witness)`
`boolean`	`equals(java.lang.Object o)`
`StreamT<W,T>`	`filter(java.util.function.Predicate<? super T> test)` Filter the wrapped List
`StreamT<W,T>`	`filterNot(java.util.function.Predicate<? super T> predicate)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<B> StreamT<W,B>`	`flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends B>> f)`
`<B> StreamT<W,B>`	`flatMapT(java.util.function.Function<? super T,StreamT<W,B>> f)` Flat Map the wrapped List
`<R1,R> StreamT<W,R>`	`forEach2M(java.util.function.Function<? super T,? extends StreamT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)`
`<R1,R> StreamT<W,R>`	`forEach2M(java.util.function.Function<? super T,? extends StreamT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)`
`<T2,R1,R2,R> StreamT<W,R>`	`forEach3M(java.util.function.Function<? super T,? extends StreamT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends StreamT<W,R2>> value2, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)`
`<T2,R1,R2,R> StreamT<W,R>`	`forEach3M(java.util.function.Function<? super T,? extends StreamT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends StreamT<W,R2>> value2, Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)`
`<T2,R1,R2,R3,R> StreamT<W,R>`	`forEach4M(java.util.function.Function<? super T,? extends StreamT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends StreamT<W,R2>> value2, Fn3<? super T,? super R1,? super R2,? extends StreamT<W,R3>> value3, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)`
`<T2,R1,R2,R3,R> StreamT<W,R>`	`forEach4M(java.util.function.Function<? super T,? extends StreamT<W,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends StreamT<W,R2>> value2, Fn3<? super T,? super R1,? super R2,? extends StreamT<W,R3>> value3, Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)`
`static <W extends WitnessType<W>,A> StreamT<W,A>`	`fromAnyM(AnyM<W,A> anyM)` Construct an ListT from an AnyM that contains a monad type that contains type other than List The values in the underlying monad will be mapped to List
`static <A> StreamT<Witness.list,A>`	`fromList(java.util.List<? extends java.util.stream.Stream<A>> nested)`
`static <A> StreamT<Witness.maybe,A>`	`fromMaybe(Maybe<? extends java.util.stream.Stream<A>> nested)`
`static <A> StreamT<Witness.optional,A>`	`fromOptional(java.util.Optional<? extends java.util.stream.Stream<A>> nested)`
`static <A> StreamT<Witness.reactiveSeq,A>`	`fromReactiveSeq(ReactiveSeq<? extends java.util.stream.Stream<A>> nested)`
`static <A> StreamT<Witness.set,A>`	`fromSet(java.util.Set<? extends java.util.stream.Stream<A>> nested)`
`static <A> StreamT<Witness.stream,A>`	`fromStream(java.util.stream.Stream<? extends java.util.stream.Stream<A>> nested)`
`<K> StreamT<W,org.jooq.lambda.tuple.Tuple2<K,ReactiveSeq<T>>>`	`grouped(java.util.function.Function<? super T,? extends K> classifier)` Group this Traversable by the provided classifying function and collected by the provided Collector
`<K,A,D> StreamT<W,org.jooq.lambda.tuple.Tuple2<K,D>>`	`grouped(java.util.function.Function<? super T,? extends K> classifier, java.util.stream.Collector<? super T,A,D> downstream)` Group this Traversable by the provided classifying function and collected by the provided Collector
`StreamT<W,ListX<T>>`	`grouped(int groupSize)` Group elements in a Stream
`<C extends java.util.Collection<? super T>> StreamT<W,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
`StreamT<W,ListX<T>>`	`groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)` Create Travesable of Lists where each List is populated while the supplied bipredicate holds.
`StreamT<W,ListX<T>>`	`groupedUntil(java.util.function.Predicate<? super T> predicate)` Create a Traversable batched by List, where each batch is populated until the predicate holds
`<C extends java.util.Collection<? super T>> StreamT<W,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
`StreamT<W,ListX<T>>`	`groupedWhile(java.util.function.Predicate<? super T> predicate)` Create a Traversable batched by List, where each batch is populated while the predicate holds
`<C extends java.util.Collection<? super T>> StreamT<W,C>`	`groupedWhile(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)` Create a SequenceM batched by a Collection, where each batch is populated while the predicate holds
`int`	`hashCode()`
`StreamT<W,T>`	`insertAt(int pos, T... values)` Insert data into a reactiveStream at given position
`StreamT<W,T>`	`insertAtS(int pos, java.util.stream.Stream<T> stream)` Insert a Stream into the middle of this reactiveStream at the specified position
`StreamT<W,T>`	`intersperse(T value)` Returns a reactiveStream with a given value interspersed between any two values of this reactiveStream.
`boolean`	`isSeqPresent()`
`java.util.Iterator<T>`	`iterator()`
`StreamT<W,T>`	`limit(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`StreamT<W,T>`	`limitLast(int num)` Limit results to the last x elements in a SequenceM
`StreamT<W,T>`	`limitUntil(java.util.function.Predicate<? super T> p)` Take elements from the Stream until the predicate returns true, after which all elements are excluded.
`StreamT<W,T>`	`limitWhile(java.util.function.Predicate<? super T> p)` Take elements from the Stream while the predicate holds, once the predicate returns false all subsequent elements are excluded
`<B> StreamT<W,B>`	`map(java.util.function.Function<? super T,? extends B> f)` Map the wrapped List
`AnyM<W,? extends CyclopsCollectable<T>>`	`nestedCollectables()`
`AnyM<W,? extends FoldableTraversable<T>>`	`nestedFoldables()`
`StreamT<W,T>`	`notNull()` Filter elements retaining only values which are not null
`static <W extends WitnessType<W>,A> StreamT<W,A>`	`of(AnyM<W,? extends java.util.stream.Stream<A>> monads)` Construct an ListT from an AnyM that wraps a monad containing Lists
`static <W extends WitnessType<W>,A> StreamT<W,A>`	`ofList(AnyM<W,? extends java.util.List<A>> monads)`
`<U> StreamT<W,U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a reactiveStream that are of a given type.
`StreamT<W,T>`	`onEmpty(T value)` If this Container instance is zero, create a new instance containing the provided value
`StreamT<W,T>`	`onEmptyGet(java.util.function.Supplier<? extends T> supplier)` If this Container instance is zero, create a new instance containing the value returned from the provided Supplier
`<X extends java.lang.Throwable> StreamT<W,T>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)` If this container instance is zero, throw the exception returned by the provided Supplier
`StreamT<W,T>`	`peek(java.util.function.Consumer<? super T> peek)` Peek at the current value of the List
`StreamT<W,T>`	`prepend(T... values)` Prepend given values to the skip of the Stream
`StreamT<W,T>`	`prepend(T value)`
`StreamT<W,T>`	`prependS(java.util.stream.Stream<? extends T> stream)` Prepend Stream to this ReactiveSeq
`<EX extends java.lang.Throwable> StreamT<W,T>`	`recover(java.lang.Class<EX> exceptionClass, java.util.function.Function<? super EX,? extends T> fn)` Recover from a particular exception type
`StreamT<W,T>`	`recover(java.util.function.Function<? super java.lang.Throwable,? extends T> fn)` Recover from an exception with an alternative value
`StreamT<W,T>`	`removeAll(T... values)` Remove all supplied elements from this filterable
`StreamT<W,T>`	`removeAllI(java.lang.Iterable<? extends T> it)` Remove all elements in the supplied Iterable from this filterable
`StreamT<W,T>`	`removeAllS(java.util.stream.Stream<? extends T> stream)` Remove all elements in the supplied Stream from this filterable
`StreamT<W,T>`	`retainAll(T... values)` Retain only the supplied elements in the returned Filters
`StreamT<W,T>`	`retainAllI(java.lang.Iterable<? extends T> it)` Retain only the supplied elements in the returned Filters
`StreamT<W,T>`	`retainAllS(java.util.stream.Stream<? extends T> stream)` Retain only the supplied elements in the returned Filters
`<R> StreamT<W,R>`	`retry(java.util.function.Function<? super T,? extends R> fn)` Retry a transformation if it fails.
`<R> StreamT<W,R>`	`retry(java.util.function.Function<? super T,? extends R> fn, int retries, long delay, java.util.concurrent.TimeUnit timeUnit)` Retry a transformation if it fails.
`StreamT<W,T>`	`reverse()` Potentially efficient Stream reversal.
`StreamT<W,T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`<U> StreamT<W,U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)` Scan left
`StreamT<W,T>`	`scanRight(Monoid<T> monoid)` Scan right
`<U> StreamT<W,U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)` Scan right
`StreamT<W,T>`	`shuffle()`
`StreamT<W,T>`	`shuffle(java.util.Random random)`
`StreamT<W,T>`	`skip(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`StreamT<W,T>`	`skipLast(int num)` assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(1,2,3)));
`StreamT<W,T>`	`skipUntil(java.util.function.Predicate<? super T> p)` Drop elements from the Stream until the predicate returns true, after which all elements are included
`StreamT<W,T>`	`skipWhile(java.util.function.Predicate<? super T> p)` SkipWhile drops elements from the Stream while the predicate holds, once the predicte returns true all subsequent elements are included *
`StreamT<W,T>`	`slice(long from, long to)`
`StreamT<W,VectorX<T>>`	`sliding(int windowSize)` Create a sliding view over this Sequence
`StreamT<W,VectorX<T>>`	`sliding(int windowSize, int increment)` Create a sliding view over this Sequence
`StreamT<W,T>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`StreamT<W,T>`	`sorted(java.util.Comparator<? super T> c)` `assertThat(ReactiveSeq.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));`
`<U extends java.lang.Comparable<? super U>> StreamT<W,T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`ReactiveSeq<T>`	`stream()`
`StreamT<W,T>`	`take(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).take(2).toList(),equalTo(Arrays.asList(4,3));`
`StreamT<W,T>`	`takeRight(int num)` Generate a new Traversable that takes the specified number elements from the take of this Traversable
`StreamT<W,T>`	`takeUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that takes elements from this Traversable until the predicate holds
`StreamT<W,T>`	`takeWhile(java.util.function.Predicate<? super T> p)` Generate a new Traversable that takes elements from this Traversable as long as the predicate holds
`java.lang.String`	`toString()`
`AnyM<W,? extends FoldableTraversable<T>>`	`transformerStream()`
`<T> StreamT<W,T>`	`unit(T unit)`
`<T> StreamT<W,T>`	`unitAnyM(AnyM<W,Traversable<T>> traversable)`
`<R> StreamT<W,R>`	`unitIterator(java.util.Iterator<R> it)` Create an IterableFunctor instance of the same type from an Iterator
`AnyM<W,java.util.stream.Stream<T>>`	`unwrap()` Unwrap a wrapped value
`<R> R`	`unwrapTo(java.util.function.Function<? super AnyM<W,java.util.stream.Stream<T>>,? extends R> fn)`
`StreamT<W,T>`	`zip(java.util.function.BinaryOperator<Zippable<T>> combiner, Zippable<T> app)` Combine two applicatives together using the provided BinaryOperator (Semigroup, Monoid and Reducer all extend BinaryOperator - checkout SemigroupK and Monoids for a large number of canned combinations).
`<U> StreamT<W,org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.lang.Iterable<? extends U> other)` Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2
`<U,R> StreamT<W,R>`	`zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
`<S,U> StreamT<W,org.jooq.lambda.tuple.Tuple3<T,S,U>>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third)` zip 3 Streams into one
`<S,U,R> StreamT<W,R>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third, Fn3<? super T,? super S,? super U,? extends R> fn3)`
`<T2,T3,T4> StreamT<W,org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>`	`zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth)` zip 4 Streams into 1
`<T2,T3,T4,R> StreamT<W,R>`	`zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth, Fn4<? super T,? super T2,? super T3,? super T4,? extends R> fn)`
`<T2,R> StreamT<W,R>`	`zipP(org.reactivestreams.Publisher<? extends T2> publisher, java.util.function.BiFunction<? super T,? super T2,? extends R> fn)` Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
`<U> StreamT<W,org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipP(org.reactivestreams.Publisher<? extends U> other)`
`<U> StreamT<W,org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipS(java.util.stream.Stream<? extends U> other)` Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2
`<U,R> StreamT<W,R>`	`zipS(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
`<R> StreamT<W,R>`	`zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn)`
`StreamT<W,org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>`	`zipWithIndex()` Add an index to the current Stream
`<R> StreamT<W,R>`	`zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn)`
`<R> StreamT<W,R>`	`zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn)`

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

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

Methods inherited from interface com.aol.cyclops2.types.anyM.transformers.FoldableTransformerSeq
headAndTail, visit

Methods inherited from interface com.aol.cyclops2.types.anyM.transformers.TransformerSeq
subscribe, to, trampoline

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

Methods inherited from interface com.aol.cyclops2.types.traversable.Traversable
mapToDouble, mapToInt, mapToLong, traversable

Methods inherited from interface java.lang.Iterable
forEach, spliterator

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

Methods inherited from interface com.aol.cyclops2.types.traversable.Sequential
fixedDelay, onePer, xPer

Methods inherited from interface com.aol.cyclops2.types.anyM.NestedFoldable
endsWith, endsWithIterable, findFirst, firstValue, foldRight, foldRight, foldRight, foldRightMapToType, forEach, forEach, get, groupBy, join, join, join, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleUnsafe, startsWith, startsWithIterable, toNested

Methods inherited from interface com.aol.cyclops2.types.stream.ToStream
futureStream, getStreamable, isEmpty, jdkStream, reactiveSeq, reveresedJDKStream, reveresedStream

Methods inherited from interface com.aol.cyclops2.types.anyM.NestedCollectable
allMatch, anyMatch, collect, collect, futureT, listT, noneMatch, toListOfLists, toNestedListX, toNestedSetX, toSetOfSets

- Method Detail
 - unwrap
```
public AnyM<W,java.util.stream.Stream<T>> unwrap()
```
 Description copied from interface: Unwrapable
 
 Unwrap a wrapped value
 
 Specified by:
 
 unwrap in interface Unwrapable
 
 Returns:
 
 The wrapped AnyM
 - unwrapTo
```
public <R> R unwrapTo(java.util.function.Function<? super AnyM<W,java.util.stream.Stream<T>>,? extends R> fn)
```
 - peek
```
public StreamT<W,T> peek(java.util.function.Consumer<? super T> peek)
```
 Peek at the current value of the List
```
 
 ListT.of(AnyM.fromStream(Arrays.asList(10))
 .peek(System.out::println);
 
 //prints 10 
 
 
```
 Specified by:
 
 peek in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 peek in interface Transformable<T>
 
 Parameters:
 
 peek - Consumer to accept current value of List
 
 Returns:
 
 ListT with peek call
 - filter
```
public StreamT<W,T> filter(java.util.function.Predicate<? super T> test)
```
 Filter the wrapped List
```
 
 ListT.of(AnyM.fromStream(Arrays.asList(10,11))
 .filter(t->t!=10);
 
 //ListT<AnyM<Stream<List[11]>>>
 
 
```
 Specified by:
 
 filter in interface Filters<T>
 
 Specified by:
 
 filter in interface FilterableTransformable<T>
 
 Parameters:
 
 test - Predicate to filter the wrapped List
 
 Returns:
 
 ListT that applies the provided filter
 - map
```
public  StreamT<W,B> map(java.util.function.Function<? super T,? extends B> f)
```
 Map the wrapped List
```
 
 ListT.of(AnyM.fromStream(Arrays.asList(10))
 .map(t->t=t+1);
 
 
 //ListT<AnyM<Stream<List[11]>>>
 
 
```
 Specified by:
 
 map in interface FilterableTransformable<T>
 
 Specified by:
 
 map in interface Transformable<T>
 
 Parameters:
 
 f - Mapping function for the wrapped List
 
 Returns:
 
 ListT that applies the map function to the wrapped List
 - flatMap
```
public  StreamT<W,B> flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends B>> f)
```
 Specified by:
 
 flatMap in interface FoldableTransformerSeq<W extends WitnessType<W>,T>
 - flatMapT
```
public  StreamT<W,B> flatMapT(java.util.function.Function<? super T,StreamT<W,B>> f)
```
 Flat Map the wrapped List
```
 
 ListT.of(AnyM.fromStream(Arrays.asList(10))
 .flatMap(t->List.zero();
 
 
 //ListT<AnyM<Stream<List.zero>>>
 
 
```
 Parameters:
 
 f - FlatMap function
 
 Returns:
 
 ListT that applies the flatMap function to the wrapped List
 - fromAnyM
```
public static <W extends WitnessType<W>,A> StreamT<W,A> fromAnyM(AnyM<W,A> anyM)
```
 Construct an ListT from an AnyM that contains a monad type that contains type other than List The values in the underlying monad will be mapped to List
 
 Parameters:
 
 anyM - AnyM that doesn't contain a monad wrapping an List
 
 Returns:
 
 ListT
 - of
```
public static <W extends WitnessType<W>,A> StreamT<W,A> of(AnyM<W,? extends java.util.stream.Stream<A>> monads)
```
 Construct an ListT from an AnyM that wraps a monad containing Lists
 
 Parameters:
 
 monads - AnyM that contains a monad wrapping an List
 
 Returns:
 
 ListT
 - ofList
```
public static <W extends WitnessType<W>,A> StreamT<W,A> ofList(AnyM<W,? extends java.util.List<A>> monads)
```
 - fromStream
```
public static <A> StreamT<Witness.stream,A> fromStream(java.util.stream.Stream<? extends java.util.stream.Stream<A>> nested)
```
 - fromReactiveSeq
```
public static <A> StreamT<Witness.reactiveSeq,A> fromReactiveSeq(ReactiveSeq<? extends java.util.stream.Stream<A>> nested)
```
 - fromOptional
```
public static <A> StreamT<Witness.optional,A> fromOptional(java.util.Optional<? extends java.util.stream.Stream<A>> nested)
```
 - fromMaybe
```
public static <A> StreamT<Witness.maybe,A> fromMaybe(Maybe<? extends java.util.stream.Stream<A>> nested)
```
 - fromList
```
public static <A> StreamT<Witness.list,A> fromList(java.util.List<? extends java.util.stream.Stream<A>> nested)
```
 - fromSet
```
public static <A> StreamT<Witness.set,A> fromSet(java.util.Set<? extends java.util.stream.Stream<A>> nested)
```
 - toString
```
public java.lang.String toString()
```
 Overrides:
 
 toString in class java.lang.Object
 - unit
```
public <T> StreamT<W,T> unit(T unit)
```
 - stream
```
public ReactiveSeq<T> stream()
```
 Specified by:
 
 stream in interface FoldableTransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 stream in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 stream in interface TransformerTraversable<T>
 
 Specified by:
 
 stream in interface ToStream<T>
 
 Specified by:
 
 stream in interface Sequential<T>
 
 Specified by:
 
 stream in interface Traversable<T>
 
 Returns:
 
 This Traversable converted to a Stream
 - iterator
```
public java.util.Iterator<T> iterator()
```
 Specified by:
 
 iterator in interface java.lang.Iterable<T>
 - unitIterator
```
public <R> StreamT<W,R> unitIterator(java.util.Iterator<R> it)
```
 Description copied from interface: Traversable
 Create an IterableFunctor instance of the same type from an Iterator
```
 
 ReactiveSeq<Integer> newSeq = seq.unitIterable(myIterator);

 
 
```
 Specified by:
 
 unitIterator in interface FoldableTransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 unitIterator in interface Traversable<T>
 
 Parameters:
 
 it - Iterator to create new IterableFunctor from
 
 Returns:
 
 New IterableFunctor instance
 - empty
```
public <R> StreamT<W,R> empty()
```
 Specified by:
 
 empty in interface FoldableTransformerSeq<W extends WitnessType<W>,T>
 - nestedFoldables
```
public AnyM<W,? extends FoldableTraversable<T>> nestedFoldables()
```
 Specified by:
 
 nestedFoldables in interface NestedFoldable<W extends WitnessType<W>,T>
 - nestedCollectables
```
public AnyM<W,? extends CyclopsCollectable<T>> nestedCollectables()
```
 Specified by:
 
 nestedCollectables in interface NestedCollectable<W extends WitnessType<W>,T>
 - unitAnyM
```
public <T> StreamT<W,T> unitAnyM(AnyM<W,Traversable<T>> traversable)
```
 Specified by:
 
 unitAnyM in interface TransformerSeq<W extends WitnessType<W>,T>
 - transformerStream
```
public AnyM<W,? extends FoldableTraversable<T>> transformerStream()
```
 Specified by:
 
 transformerStream in interface TransformerSeq<W extends WitnessType<W>,T>
 - emptyList
```
public static <W extends WitnessType<W>,T> StreamT<W,T> emptyList(W witness)
```
 - isSeqPresent
```
public boolean isSeqPresent()
```
 Specified by:
 
 isSeqPresent in interface TransformerSeq<W extends WitnessType<W>,T>
 - combine
```
public StreamT<W,T> combine(java.util.function.BiPredicate<? super T,? super T> predicate,
 java.util.function.BinaryOperator<T> op)
```
 Description copied from interface: Traversable
 Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation. The emitted of a combination may in turn be combined with it's neighbour
```
 
 ReactiveSeq.of(1,1,2,3)
 .combine((a, b)->a.equals(b),SemigroupK.intSum)
 .listX()
 
 //ListX(3,4) 
 
```
 Specified by:
 
 combine in interface TransformerSeq<W extends WitnessType<W>,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
```
public StreamT<W,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()

 //ListX(1)
 
```
 Simalar to @see Traversable.combine(BiPredicate, BinaryOperator) but differs in that the first comparison is always to the Monoid zero This allows us to terminate with just a single value
 Specified by:
 
 combine in interface TransformerSeq<W extends WitnessType<W>,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
 - cycle
```
public StreamT<W,T> cycle(long times)
```
 Description copied from interface: Traversable
 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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 cycle in interface Traversable<T>
 
 Parameters:
 
 times - Times values should be repeated within a Stream
 
 Returns:
 
 Stream with values repeated
 - cycle
```
public StreamT<W,T> cycle(Monoid<T> m,
 long times)
```
 Description copied from interface: Traversable
 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 TransformerSeq<W extends WitnessType<W>,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
```
public StreamT<W,T> cycleWhile(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 cycleWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - cycleUntil
```
public StreamT<W,T> cycleUntil(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Repeat in a Stream until specified predicate holds
```
 
 	MutableInt count =MutableInt.of(0);
 		ReactiveSeq.of(1,2,2)
 		 		.cycleUntil(next -> count.get()>6)
 		 		.peek(i-> count.mutate(i->i+1))
 		 		.collect(CyclopsCollectors.toList());
 
 		//List[1,2,2,1,2,2,1]	
 
 
```
 Specified by:
 
 cycleUntil in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 cycleUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - zip
```
public <U,R> StreamT<W,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 TransformerSeq<W extends WitnessType<W>,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
 - zipS
```
public <U,R> StreamT<W,R> zipS(java.util.stream.Stream<? extends U> other,
 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
 
 Specified by:
 
 zipS in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 zipS in interface Traversable<T>
 
 Specified by:
 
 zipS in interface Zippable<T>
 
 Parameters:
 
 other - Stream to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - zipS
```
public  StreamT<W,org.jooq.lambda.tuple.Tuple2<T,U>> zipS(java.util.stream.Stream<? extends U> other)
```
 Description copied from interface: Traversable
 
 Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2
 
 Specified by:
 
 zipS in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 zipS in interface Traversable<T>
 
 Specified by:
 
 zipS in interface Zippable<T>
 
 Parameters:
 
 other - Stream to combine with
 
 Returns:
 
 Combined Zippable
 - zip
```
public  StreamT<W,org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2
 
 Specified by:
 
 zip in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Iterable to combine with
 
 Returns:
 - zip3
```
public <S,U> StreamT<W,org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.lang.Iterable<? extends S> second,
 java.lang.Iterable<? extends U> third)
```
 Description copied from interface: Traversable
 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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 zip3 in interface Traversable<T>
 
 Specified by:
 
 zip3 in interface Zippable<T>
 - zip4
```
public <T2,T3,T4> StreamT<W,org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.lang.Iterable<? extends T2> second,
 java.lang.Iterable<? extends T3> third,
 java.lang.Iterable<? extends T4> fourth)
```
 Description copied from interface: Traversable
 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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 zip4 in interface Traversable<T>
 
 Specified by:
 
 zip4 in interface Zippable<T>
 - zipWithIndex
```
public StreamT<W,org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()
```
 Description copied from interface: Traversable
 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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 zipWithIndex in interface Traversable<T>
 - sliding
```
public StreamT<W,VectorX<T>> sliding(int windowSize)
```
 Description copied from interface: Traversable
 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.get(0), hasItems(1, 2));
 assertThat(list.get(1), hasItems(2, 3));
 
 
 
 
```
 Specified by:
 
 sliding in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Parameters:
 
 windowSize - Size of sliding window
 
 Returns:
 
 SequenceM with sliding view
 - sliding
```
public StreamT<W,VectorX<T>> sliding(int windowSize,
 int increment)
```
 Description copied from interface: Traversable
 Create a sliding view over this Sequence
```
 
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(3, 2).collect(CyclopsCollectors.toList());
 
 assertThat(list.get(0), hasItems(1, 2, 3));
 assertThat(list.get(1), hasItems(3, 4, 5)); 
 
 
 
 
 
```
 Specified by:
 
 sliding in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Parameters:
 
 windowSize - number of elements in each batch
 
 increment - for each window
 
 Returns:
 
 SequenceM with sliding view
 - grouped
```
public <C extends java.util.Collection<? super T>> StreamT<W,C> grouped(int size,
 java.util.function.Supplier<C> supplier)
```
 Description copied from interface: Traversable
 Batch elements in a Stream by size into a toX created by the supplied factory
```
 
 assertThat(ReactiveSeq.of(1,1,1,1,1,1)
 .batchBySize(3,()->new TreeSet<>())
 .toList()
 .get(0)
 .size(),is(1));
 
 
```
 Specified by:
 
 grouped in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 size - batch size
 
 supplier - Collection factory
 
 Returns:
 
 SequenceM batched into toX types by size
 - groupedUntil
```
public StreamT<W,ListX<T>> groupedUntil(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Create a Traversable batched by List, where each batch is populated until the predicate holds
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .groupedUntil(i->i%3==0)
 .toList()
 .size(),equalTo(2));
 
 
```
 Specified by:
 
 groupedUntil in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, applyHKT open next batch
 
 Returns:
 
 SequenceM batched into lists determined by the predicate supplied
 - groupedStatefullyUntil
```
public StreamT<W,ListX<T>> groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
```
 Description copied from interface: Traversable
 Create Travesable of Lists where each List is populated while the supplied bipredicate holds. The bipredicate recieves the List from the last window as well as the current value and can choose to aggregate the current value or create a new window
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .groupedStatefullyUntil((s,i)->s.contains(4) ? true : false)
 .toList().size(),equalTo(5));
 
 
```
 Specified by:
 
 groupedStatefullyUntil in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 groupedStatefullyUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Window while true
 
 Returns:
 
 Traversable windowed while predicate holds
 - groupedWhile
```
public StreamT<W,ListX<T>> groupedWhile(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Create a Traversable batched by List, where each batch is populated while the predicate holds
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .groupedWhile(i->i%3!=0)
 .toList().size(),equalTo(2));
 
 
 
```
 Specified by:
 
 groupedWhile in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, applyHKT open next batch
 
 Returns:
 
 SequenceM batched into lists determined by the predicate supplied
 - groupedWhile
```
public <C extends java.util.Collection<? super T>> StreamT<W,C> groupedWhile(java.util.function.Predicate<? super T> predicate,
 java.util.function.Supplier<C> factory)
```
 Description copied from interface: Traversable
 Create a SequenceM 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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, applyHKT open next batch
 
 factory - Collection factory
 
 Returns:
 
 SequenceM batched into collections determined by the predicate supplied
 - groupedUntil
```
public <C extends java.util.Collection<? super T>> StreamT<W,C> groupedUntil(java.util.function.Predicate<? super T> predicate,
 java.util.function.Supplier<C> factory)
```
 Description copied from interface: Traversable
 Create a ReactiveSeq batched by a Collection, where each batch is populated until the predicate holds
```
 
 ReactiveSeq.of(1,2,3,4,5,6)
 .groupedUntil(i->i%3!=0)
 .toList()
 
 //2
 
 
```
 Specified by:
 
 groupedUntil in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, applyHKT open next batch
 
 factory - Collection factory
 
 Returns:
 
 SequenceM batched into collections determined by the predicate supplied
 - grouped
```
public StreamT<W,ListX<T>> grouped(int groupSize)
```
 Description copied from interface: Traversable
 Group elements in a Stream
```
 
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).grouped(3).collect(CyclopsCollectors.toList());
 
 assertThat(list.get(0), hasItems(1, 2, 3));
 assertThat(list.get(1), hasItems(4, 5, 6));
 
 
 
```
 Specified by:
 
 grouped in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 groupSize - Size of each Group
 
 Returns:
 
 Stream with elements grouped by size
 - grouped
```
public <K,A,D> StreamT<W,org.jooq.lambda.tuple.Tuple2<K,D>> grouped(java.util.function.Function<? super T,? extends K> classifier,
 java.util.stream.Collector<? super T,A,D> downstream)
```
 Description copied from interface: Traversable
 
 Group this Traversable by the provided classifying function and collected by the provided Collector
 
 Specified by:
 
 grouped in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 classifier - Grouping function
 
 downstream - Collector to create the grouping toX
 
 Returns:
 
 Traversable of grouped data
 - grouped
```
public <K> StreamT<W,org.jooq.lambda.tuple.Tuple2<K,ReactiveSeq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)
```
 Description copied from interface: Traversable
 
 Group this Traversable by the provided classifying function and collected by the provided Collector
 
 Specified by:
 
 grouped in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 classifier - Grouping function
 
 Returns:
 
 Traversable of grouped data
 - distinct
```
public StreamT<W,T> distinct()
```
 Specified by:
 
 distinct in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 distinct in interface Traversable<T>
 - scanLeft
```
public StreamT<W,T> scanLeft(Monoid<T> monoid)
```
 Description copied from interface: Traversable
 Scan left using supplied Monoid
```
 
 
 	assertEquals(asList("", "a", "ab", "abc"),ReactiveSeq.of("a", "b", "c")
 													.scanLeft(Reducers.toString("")).toList());
 
 
 
```
 Specified by:
 
 scanLeft in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 
 Returns:
 - scanLeft
```
public  StreamT<W,U> scanLeft(U seed,
 java.util.function.BiFunction<? super U,? super T,? extends U> function)
```
 Description copied from interface: Traversable
 Scan left
```
 
 assertThat(of("a", "b", "c").scanLeft("", String::concat).toList().size(),
 		is(4));
 
 
```
 Specified by:
 
 scanLeft in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 - scanRight
```
public StreamT<W,T> scanRight(Monoid<T> monoid)
```
 Description copied from interface: Traversable
 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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 - scanRight
```
public  StreamT<W,U> scanRight(U identity,
 java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
```
 Description copied from interface: Traversable
 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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 - sorted
```
public StreamT<W,T> sorted()
```
 Description copied from interface: Traversable
```
 assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); 
 
```
 Specified by:
 
 sorted in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 - sorted
```
public StreamT<W,T> sorted(java.util.Comparator<? super T> c)
```
 Description copied from interface: Traversable
```
 
 	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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 
 Parameters:
 
 c - Compartor to sort with
 
 Returns:
 
 Sorted Stream
 - takeWhile
```
public StreamT<W,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
```
 
 ListX.of(1,2,3).takeWhile(i<3);
 //[1,2]
 
 
```
 Specified by:
 
 takeWhile in interface TransformerSeq<W extends WitnessType<W>,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
 - dropWhile
```
public StreamT<W,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
```
 
 ListX.of(1,2,3).dropWhile(i<3);
 //[3]
 
 
```
 Specified by:
 
 dropWhile in interface TransformerSeq<W extends WitnessType<W>,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
```
public StreamT<W,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
```
 
 ListX.of(1,2,3).takeUntil(i<2);
 //[1,2]
 
 
```
 Specified by:
 
 takeUntil in interface TransformerSeq<W extends WitnessType<W>,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
```
public StreamT<W,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
```
 
 ListX.of(1,2,3).dropUntil(i>2);
 //[3]
 
 
```
 Specified by:
 
 dropUntil in interface TransformerSeq<W extends WitnessType<W>,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
```
public StreamT<W,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
```
 
 ListX.of(1,2,3).dropRight(2);
 //[1]
 
 
```
 Specified by:
 
 dropRight in interface TransformerSeq<W extends WitnessType<W>,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
```
public StreamT<W,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
```
 
 ListX.of(1,2,3).takeRight(2);
 //[2,3]
 
 
```
 Specified by:
 
 takeRight in interface TransformerSeq<W extends WitnessType<W>,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
```
public StreamT<W,T> skip(long num)
```
 Description copied from interface: Traversable
```
 assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); 
 
```
 Specified by:
 
 skip in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 skip in interface Traversable<T>
 
 Parameters:
 
 num - Number of elemenets to skip
 
 Returns:
 
 Stream with specified number of elements skipped
 - skipWhile
```
public StreamT<W,T> skipWhile(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 skipWhile in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to skip while true
 
 Returns:
 
 Stream with elements skipped while predicate holds
 - skipUntil
```
public StreamT<W,T> skipUntil(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 skipUntil in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to skip until true
 
 Returns:
 
 Stream with elements skipped until predicate holds
 - limit
```
public StreamT<W,T> limit(long num)
```
 Description copied from interface: Traversable
```
 assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
 
```
 Specified by:
 
 limit in interface TransformerSeq<W extends WitnessType<W>,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
```
public StreamT<W,T> limitWhile(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 limitWhile in interface Traversable<T>
 
 Parameters:
 
 p - Limit while predicate is true
 
 Returns:
 
 Stream with limited elements
 - limitUntil
```
public StreamT<W,T> limitUntil(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 limitUntil in interface Traversable<T>
 
 Parameters:
 
 p - Limit until predicate is true
 
 Returns:
 
 Stream with limited elements
 - intersperse
```
public StreamT<W,T> intersperse(T value)
```
 Description copied from interface: Traversable
 
 Returns a reactiveStream with a given value interspersed between any two values of this reactiveStream. // (1, 0, 2, 0, 3, 0, 4) ReactiveSeq.of(1, 2, 3, 4).intersperse(0)
 
 Specified by:
 
 intersperse in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 intersperse in interface Traversable<T>
 - reverse
```
public StreamT<W,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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 reverse in interface Traversable<T>
 - shuffle
```
public StreamT<W,T> shuffle()
```
 Specified by:
 
 shuffle in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 - skipLast
```
public StreamT<W,T> skipLast(int num)
```
 Description copied from interface: Traversable
 
 assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(1,2,3)));
 
 Specified by:
 
 skipLast in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 skipLast in interface Traversable<T>
 
 Returns:
 - limitLast
```
public StreamT<W,T> limitLast(int num)
```
 Description copied from interface: Traversable
 Limit results to the last x elements in a SequenceM
```
 
 	assertThat(ReactiveSeq.of(1,2,3,4,5)
 							.limitLast(2)
 							.collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(4,5)));
 
 
 
```
 Specified by:
 
 limitLast in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 limitLast in interface Traversable<T>
 
 Parameters:
 
 num - of elements to return (last elements)
 
 Returns:
 
 SequenceM limited to last num elements
 - onEmpty
```
public StreamT<W,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 TransformerSeq<W extends WitnessType<W>,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
```
public StreamT<W,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 TransformerSeq<W extends WitnessType<W>,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
 - onEmptyThrow
```
public <X extends java.lang.Throwable> StreamT<W,T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
```
 Description copied from interface: OnEmpty
 
 If this container instance is zero, throw the exception returned by the provided Supplier
 
 Specified by:
 
 onEmptyThrow in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 onEmptyThrow in interface OnEmpty<T>
 
 Specified by:
 
 onEmptyThrow in interface Traversable<T>
 
 Parameters:
 
 supplier - to create exception from
 
 Returns:
 
 Throw exception if zero, otherwise this container
 - shuffle
```
public StreamT<W,T> shuffle(java.util.Random random)
```
 Specified by:
 
 shuffle in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 - slice
```
public StreamT<W,T> slice(long from,
 long to)
```
 Specified by:
 
 slice in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 slice in interface Traversable<T>
 - sorted
```
public > StreamT<W,T> sorted(java.util.function.Function<? super T,? extends U> function)
```
 Specified by:
 
 sorted in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 - hashCode
```
public int hashCode()
```
 Overrides:
 
 hashCode in class java.lang.Object
 - equals
```
public boolean equals(java.lang.Object o)
```
 Overrides:
 
 equals in class java.lang.Object
 - forEach4M
```
public <T2,R1,R2,R3,R> StreamT<W,R> forEach4M(java.util.function.Function<? super T,? extends StreamT<W,R1>> value1,
 java.util.function.BiFunction<? super T,? super R1,? extends StreamT<W,R2>> value2,
 Fn3<? super T,? super R1,? super R2,? extends StreamT<W,R3>> value3,
 Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
```
 - forEach4M
```
public <T2,R1,R2,R3,R> StreamT<W,R> forEach4M(java.util.function.Function<? super T,? extends StreamT<W,R1>> value1,
 java.util.function.BiFunction<? super T,? super R1,? extends StreamT<W,R2>> value2,
 Fn3<? super T,? super R1,? super R2,? extends StreamT<W,R3>> value3,
 Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
 Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
```
 - forEach3M
```
public <T2,R1,R2,R> StreamT<W,R> forEach3M(java.util.function.Function<? super T,? extends StreamT<W,R1>> value1,
 java.util.function.BiFunction<? super T,? super R1,? extends StreamT<W,R2>> value2,
 Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
```
 - forEach3M
```
public <T2,R1,R2,R> StreamT<W,R> forEach3M(java.util.function.Function<? super T,? extends StreamT<W,R1>> value1,
 java.util.function.BiFunction<? super T,? super R1,? extends StreamT<W,R2>> value2,
 Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction,
 Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
```
 - forEach2M
```
public <R1,R> StreamT<W,R> forEach2M(java.util.function.Function<? super T,? extends StreamT<W,R1>> value1,
 java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
```
 - forEach2M
```
public <R1,R> StreamT<W,R> forEach2M(java.util.function.Function<? super T,? extends StreamT<W,R1>> value1,
 java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction,
 java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
```
 - prependS
```
public StreamT<W,T> prependS(java.util.stream.Stream<? extends T> stream)
```
 Description copied from interface: Traversable
 Prepend Stream to this ReactiveSeq
```
 
 List<String> result = ReactiveSeq.of(1, 2, 3)
 .prependS(of(100, 200, 300))
 .map(it -> it + "!!")
 .collect(CyclopsCollectors.toList());

 assertThat(result, equalTo(Arrays.asList("100!!", "200!!", "300!!", "1!!", "2!!", "3!!")));
 
 
```
 Specified by:
 
 prependS in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 prependS in interface Traversable<T>
 
 Parameters:
 
 stream - to Prepend
 
 Returns:
 
 ReactiveSeq with Stream prepended
 - append
```
public StreamT<W,T> append(T... values)
```
 Description copied from interface: Traversable
 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:
 
 append in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 append in interface Traversable<T>
 
 Parameters:
 
 values - to append
 
 Returns:
 
 ReactiveSeq with appended values
 - append
```
public StreamT<W,T> append(T value)
```
 Specified by:
 
 append in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 append in interface Traversable<T>
 - prepend
```
public StreamT<W,T> prepend(T value)
```
 Specified by:
 
 prepend in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 prepend in interface Traversable<T>
 - prepend
```
public StreamT<W,T> prepend(T... values)
```
 Description copied from interface: Traversable
 Prepend given values to the skip of the Stream
```
 
 List<String> result = 	ReactiveSeq.of(1,2,3)
 									 .prepend(100,200,300)
 										 .map(it ->it+"!!")
 										 .collect(CyclopsCollectors.toList());

 			assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
 
```
 Specified by:
 
 prepend in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 prepend in interface Traversable<T>
 
 Parameters:
 
 values - to prepend
 
 Returns:
 
 ReactiveSeq with values prepended
 - insertAt
```
public StreamT<W,T> insertAt(int pos,
 T... values)
```
 Description copied from interface: Traversable
 Insert data into a reactiveStream at 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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 insertAt in interface Traversable<T>
 
 Parameters:
 
 pos - to insert data at
 
 values - to insert
 
 Returns:
 
 Stream with new data inserted
 - deleteBetween
```
public StreamT<W,T> deleteBetween(int start,
 int end)
```
 Description copied from interface: Traversable
 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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 deleteBetween in interface Traversable<T>
 
 Parameters:
 
 start - index
 
 end - index
 
 Returns:
 
 Stream with elements removed
 - insertAtS
```
public StreamT<W,T> insertAtS(int pos,
 java.util.stream.Stream<T> stream)
```
 Description copied from interface: Traversable
 Insert a Stream into the middle of this reactiveStream at the specified position
```
 
 List<String> result = ReactiveSeq.of(1, 2, 3).insertAtS(1, of(100, 200, 300)).map(it -> it + "!!").collect(CyclopsCollectors.toList());

 assertThat(result, equalTo(Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!")));
 
 
```
 Specified by:
 
 insertAtS in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 insertAtS in interface Traversable<T>
 
 Parameters:
 
 pos - to insert Stream at
 
 stream - to insert
 
 Returns:
 
 newly conjoined Traversable
 - zip
```
public StreamT<W,T> zip(java.util.function.BinaryOperator<Zippable<T>> combiner,
 Zippable<T> app)
```
 Description copied from interface: Zippable
 
 Combine two applicatives together using the provided BinaryOperator (Semigroup, Monoid and Reducer all extend BinaryOperator - checkout SemigroupK and Monoids for a large number of canned combinations). If this Applicative is a scalar value the provided value is combined with that value, otherwise the value is combined pair wise with all value in a non-scalar datastructure
 Specified by:
 
 zip in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Returns:
 
 See Also:
 Semigroup, Semigroups, Monoid, To lift any Semigroup (or monoid) up to handling Applicatives use the combineApplicatives operator in SemigroupK {@see com.aol.cyclops2.SemigroupK#combineApplicatives(BiFunction) } or Monoids { {@see com.aol.cyclops2.Monoids#combineApplicatives(java.util.function.Function, com.aol.cyclops2.function.Monoid) } {@code BinaryOperator> sumMaybes = SemigroupK.combineScalarFunctors(SemigroupK.intSum); Maybe.just(1).zip(sumMaybes, Maybe.just(5)) //Maybe.just(6)); }
 - zipWith
```
public <R> StreamT<W,R> zipWith(java.lang.Iterable<java.util.function.Function<? super T,? extends R>> fn)
```
 Specified by:
 
 zipWith in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 zipWith in interface Traversable<T>
 
 Specified by:
 
 zipWith in interface Zippable<T>
 - zipWithS
```
public <R> StreamT<W,R> zipWithS(java.util.stream.Stream<java.util.function.Function<? super T,? extends R>> fn)
```
 Specified by:
 
 zipWithS in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 zipWithS in interface Traversable<T>
 
 Specified by:
 
 zipWithS in interface Zippable<T>
 - zipWithP
```
public <R> StreamT<W,R> zipWithP(org.reactivestreams.Publisher<java.util.function.Function<? super T,? extends R>> fn)
```
 Specified by:
 
 zipWithP in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 zipWithP in interface Traversable<T>
 
 Specified by:
 
 zipWithP in interface Zippable<T>
 - zipP
```
public <T2,R> StreamT<W,R> zipP(org.reactivestreams.Publisher<? extends T2> publisher,
 java.util.function.BiFunction<? super T,? super T2,? extends R> fn)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
 
 Specified by:
 
 zipP in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 zipP in interface Traversable<T>
 
 Specified by:
 
 zipP in interface Zippable<T>
 
 Parameters:
 
 publisher - to combine with
 
 fn - Zip / combining function
 
 Returns:
 
 Combined zippable
 - zipP
```
public  StreamT<W,org.jooq.lambda.tuple.Tuple2<T,U>> zipP(org.reactivestreams.Publisher<? extends U> other)
```
 Specified by:
 
 zipP in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 zipP in interface Traversable<T>
 
 Specified by:
 
 zipP in interface Zippable<T>
 - zip3
```
public <S,U,R> StreamT<W,R> zip3(java.lang.Iterable<? extends S> second,
 java.lang.Iterable<? extends U> third,
 Fn3<? super T,? super S,? super U,? extends R> fn3)
```
 Specified by:
 
 zip3 in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 zip3 in interface Traversable<T>
 
 Specified by:
 
 zip3 in interface Zippable<T>
 - zip4
```
public <T2,T3,T4,R> StreamT<W,R> zip4(java.lang.Iterable<? extends T2> second,
 java.lang.Iterable<? extends T3> third,
 java.lang.Iterable<? extends T4> fourth,
 Fn4<? super T,? super T2,? super T3,? super T4,? extends R> fn)
```
 Specified by:
 
 zip4 in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 zip4 in interface Traversable<T>
 
 Specified by:
 
 zip4 in interface Zippable<T>
 - removeAllS
```
public StreamT<W,T> removeAllS(java.util.stream.Stream<? extends T> stream)
```
 Description copied from interface: IterableFilterable
 
 Remove all elements in the supplied Stream from this filterable
 
 Specified by:
 
 removeAllS in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 removeAllS in interface IterableFilterable<T>
 
 Parameters:
 
 stream - of elements to remove
 
 Returns:
 
 Filters with all supplied elements removed
 - cast
```
public  StreamT<W,U> cast(java.lang.Class<? extends U> type)
```
 Description copied from interface: Transformable
 
 Cast all elements in a reactiveStream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)
 
 Specified by:
 
 cast in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 cast in interface Transformable<T>
 - ofType
```
public  StreamT<W,U> ofType(java.lang.Class<? extends U> type)
```
 Description copied from interface: Filters
 Keep only those elements in a reactiveStream that are of a given type.
```
 
 
 // (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)
 
 
 
```
 Specified by:
 
 ofType in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 ofType in interface Filters<T>
 - removeAllI
```
public StreamT<W,T> removeAllI(java.lang.Iterable<? extends T> it)
```
 Description copied from interface: IterableFilterable
 
 Remove all elements in the supplied Iterable from this filterable
 
 Specified by:
 
 removeAllI in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 removeAllI in interface IterableFilterable<T>
 
 Parameters:
 
 it - an Iterable of elements to remove
 
 Returns:
 
 Filters with all supplied elements removed
 - removeAll
```
public StreamT<W,T> removeAll(T... values)
```
 Description copied from interface: IterableFilterable
 
 Remove all supplied elements from this filterable
 
 Specified by:
 
 removeAll in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Parameters:
 
 values - to remove
 
 Returns:
 
 Filters with all supplied values removed
 - filterNot
```
public StreamT<W,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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 filterNot in interface Filters<T>
 
 Parameters:
 
 predicate - to filter elements by, retaining matches
 
 Returns:
 
 Filters with elements removed where the predicate does not hold
 - retainAllI
```
public StreamT<W,T> retainAllI(java.lang.Iterable<? extends T> it)
```
 Description copied from interface: IterableFilterable
 
 Retain only the supplied elements in the returned Filters
 
 Specified by:
 
 retainAllI in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 retainAllI in interface IterableFilterable<T>
 
 Parameters:
 
 it - Iterable of elements to retain
 
 Returns:
 
 Filters with supplied values retained, and others removed
 - notNull
```
public StreamT<W,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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 notNull in interface Filters<T>
 
 Returns:
 
 Filters with nulls removed
 - retainAllS
```
public StreamT<W,T> retainAllS(java.util.stream.Stream<? extends T> stream)
```
 Description copied from interface: IterableFilterable
 
 Retain only the supplied elements in the returned Filters
 
 Specified by:
 
 retainAllS in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 retainAllS in interface IterableFilterable<T>
 
 Parameters:
 
 stream - of elements to retain
 
 Returns:
 
 Filters with supplied values retained, and others removed
 - retainAll
```
public StreamT<W,T> retainAll(T... values)
```
 Description copied from interface: IterableFilterable
 
 Retain only the supplied elements in the returned Filters
 
 Specified by:
 
 retainAll in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Parameters:
 
 values - elements to retain
 
 Returns:
 
 Filters with supplied values retained, and others removed
 - retry
```
public <R> StreamT<W,R> retry(java.util.function.Function<? super T,? extends R> fn)
```
 Description copied from interface: Transformable
 Retry a transformation if it fails. Default settings are to retry up to 7 times, with an doubling backoff period starting @ 2 seconds delay before retry.
```
 
 given(serviceMock.applyHKT(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");


 		String result = ReactiveSeq.of( 1, 2, 3)
 				.retry(serviceMock)
 				.firstValue();

 		//result = 42
 
 
```
 Specified by:
 
 retry in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 retry in interface Transformable<T>
 
 Parameters:
 
 fn - Function to retry if fails
 - retry
```
public <R> StreamT<W,R> retry(java.util.function.Function<? super T,? extends R> fn,
 int retries,
 long delay,
 java.util.concurrent.TimeUnit timeUnit)
```
 Description copied from interface: Transformable
 Retry a transformation if it fails. Retries up to retries times, with an doubling backoff period starting @ delay TimeUnits delay before retry.
```
 
 given(serviceMock.applyHKT(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");


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

 		//result = 42
 
 
```
 Specified by:
 
 retry in interface TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 retry in interface Transformable<T>
 
 Parameters:
 
 fn - Function to retry if fails
 
 retries - Number of retries
 
 delay - Delay in TimeUnits
 
 timeUnit - TimeUnit to use for delay
 - drop
```
public StreamT<W,T> drop(long num)
```
 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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 drop in interface Traversable<T>
 
 Parameters:
 
 num - Number of elemenets to drop
 
 Returns:
 
 Traversable with specified number of elements skipped
 - take
```
public StreamT<W,T> take(long num)
```
 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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 take in interface Traversable<T>
 
 Parameters:
 
 num - Limit element size to num
 
 Returns:
 
 Monad converted to Stream with elements up to num
 - recover
```
public StreamT<W,T> recover(java.util.function.Function<? super java.lang.Throwable,? extends T> fn)
```
 Description copied from interface: Traversable
 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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 recover in interface Traversable<T>
 
 Parameters:
 
 fn - Function that accepts a Throwable and returns an alternative value
 
 Returns:
 
 ReactiveSeq that can recover from an Exception
 - recover
```
public <EX extends java.lang.Throwable> StreamT<W,T> recover(java.lang.Class<EX> exceptionClass,
 java.util.function.Function<? super EX,? extends T> fn)
```
 Description copied from interface: Traversable
 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 TransformerSeq<W extends WitnessType<W>,T>
 
 Specified by:
 
 recover in interface Traversable<T>
 
 Parameters:
 
 exceptionClass - Type to recover from
 
 fn - That accepts an error and returns an alternative value
 
 Returns:
 
 Traversable that can recover from a particular exception

Class StreamT<W extends WitnessType<W>,T>

Method Summary

Methods inherited from class java.lang.Object

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

Methods inherited from interface com.aol.cyclops2.types.anyM.transformers.FoldableTransformerSeq

Methods inherited from interface com.aol.cyclops2.types.anyM.transformers.TransformerSeq

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

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

Methods inherited from interface java.lang.Iterable

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

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

Methods inherited from interface com.aol.cyclops2.types.anyM.NestedFoldable

Methods inherited from interface com.aol.cyclops2.types.stream.ToStream

Methods inherited from interface com.aol.cyclops2.types.anyM.NestedCollectable

Method Detail

unwrap

unwrapTo

peek

filter

map

flatMap

flatMapT

fromAnyM

of

ofList

fromStream

fromReactiveSeq

fromOptional

fromMaybe

fromList

fromSet

toString

unit

stream

iterator

unitIterator

empty

nestedFoldables

nestedCollectables

unitAnyM

transformerStream

emptyList

isSeqPresent

combine

combine

cycle

cycle

cycleWhile

cycleUntil

zip

zipS

zipS

zip

zip3

zip4

zipWithIndex

sliding

sliding

grouped

groupedUntil

groupedStatefullyUntil

groupedWhile

groupedWhile

groupedUntil

grouped

grouped

grouped

distinct

scanLeft

scanLeft

scanRight

scanRight

sorted

sorted

takeWhile

dropWhile

takeUntil

dropUntil

dropRight

takeRight