Vector (cyclops 10.0.3 API)

java.lang.Object
- cyclops.data.Vector<T>

All Implemented Interfaces:

Convert<Higher<DataWitness.vector,T>>, Higher<DataWitness.vector,T>, Sealed2<ImmutableList.Some<T>,ImmutableList.None<T>>, Filters<T>, Contains<T>, Folds<T>, To<ImmutableList<T>>, FilterableTransformable<T>, Transformable<T>, PersistentCollection<T>, PersistentIndexed<T>, PersistentList<T>, ReactiveStreamsTerminalOperations<T>, OnEmpty<T>, OnEmptyError<T,ImmutableList<T>>, OnEmptySwitch<ImmutableList<T>,ImmutableList<T>>, IterableFilterable<T>, IterableX<T>, Traversable<T>, Zippable<T>, ImmutableList<T>, io.kindedj.Hk<DataWitness.vector,T>, java.io.Serializable, java.lang.Comparable<T>, java.lang.Iterable<T>, org.reactivestreams.Publisher<T>
```
public class Vector<T>
extends java.lang.Object
implements ImmutableList<T>, java.io.Serializable, Higher<DataWitness.vector,T>
```
See Also:

Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from interface cyclops.data.ImmutableList
 ImmutableList.None<T>, ImmutableList.Some<T>

Constructor Summary

Constructors
Constructor and Description

Vector(BAMT.NestedArray<T> root, BAMT.ActiveTail<T> tail, int size)

Constructors
Constructor and Description
`Vector(BAMT.NestedArray<T> root, BAMT.ActiveTail<T> tail, int size)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Vector<T>`	`append(T value)`
`Vector<T>`	`appendAll(java.lang.Iterable<? extends T> value)`
`Vector<T>`	`appendAll(T... values)`
`Vector<ReactiveSeq<T>>`	`combinations()`
`Vector<ReactiveSeq<T>>`	`combinations(int size)`
`Vector<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.
`Vector<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.
`<R> Vector<R>`	`concatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)` Perform a flatMap operation on this IterableX.
`boolean`	`containsValue(T value)`
`Vector<T>`	`cycle(long times)`
`Vector<T>`	`cycle(Monoid<T> m, long times)`
`Vector<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)`
`Vector<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)`
`Either<java.lang.Integer,Vector<T>>`	`delete(int pos)`
`Vector<T>`	`deleteBetween(int start, int end)` Delete elements between given indexes
`Vector<T>`	`distinct()`
`Vector<T>`	`drop(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7)));`
`Vector<T>`	`dropRight(int num)` Generate a new Traversable that drops the specified number elements from the take of this Traversable
`Vector<T>`	`dropUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that drops elements from this Traversable until the predicate holds
`Vector<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
`static <T> Vector<T>`	`empty()`
`Vector<T>`	`emptyUnit()`
`boolean`	`equals(java.lang.Object o)`
`static <T> Vector<T>`	`fill(T t, int max)`
`Vector<T>`	`filter(java.util.function.Predicate<? super T> pred)` Keep only elements for which the supplied predicates hold e.g.
`Vector<T>`	`filterNot(java.util.function.Predicate<? super T> predicate)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<R> Vector<R>`	`flatMap(java.util.function.Function<? super T,? extends ImmutableList<? extends R>> fn)`
`<R> R`	`fold(java.util.function.Function<? super ImmutableList.Some<T>,? extends R> fn1, java.util.function.Function<? super ImmutableList.None<T>,? extends R> fn2)`
`<R1,R> Vector<R>`	`forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)`
`<R1,R> Vector<R>`	`forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)`
`<R1,R2,R> Vector<R>`	`forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2, Function3<? super T,? super R1,? super R2,? extends R> yieldingFunction)`
`<R1,R2,R> Vector<R>`	`forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2, Function3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction, Function3<? super T,? super R1,? super R2,? extends R> yieldingFunction)`
`<R1,R2,R3,R> Vector<R>`	`forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2, Function3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> iterable3, Function4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)`
`<R1,R2,R3,R> Vector<R>`	`forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2, Function3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> iterable3, 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)`
`static <T> Vector<T>`	`fromIterable(java.lang.Iterable<T> it)`
`static <T> Vector<T>`	`fromIterator(java.util.Iterator<T> it)`
`static <T> Vector<T>`	`fromStream(java.util.stream.Stream<T> it)`
`static <T> Vector<T>`	`generate(Generator<T> s)`
`static <T> Vector<T>`	`generate(java.util.function.Supplier<T> s, int max)`
`Option<T>`	`get(int pos)`
`T`	`getOrElse(int pos, T alt)`
`T`	`getOrElseGet(int pos, java.util.function.Supplier<? extends T> alt)`
`Vector<Vector<T>>`	`grouped(int groupSize)` Group elements in a Stream
`<C extends PersistentCollection<? super T>> Vector<C>`	`grouped(int size, java.util.function.Supplier<C> supplier)` Group the elements of this traversable
`Vector<Vector<T>>`	`groupedUntil(java.util.function.BiPredicate<Vector<? super T>,? super T> predicate)` Create Travesable of Lists where each List is populated while the supplied bipredicate holds.
`Vector<Vector<T>>`	`groupedUntil(java.util.function.Predicate<? super T> predicate)` `ReactiveSeq.of(1,2,3,4,5,6) .groupedUntil(i->i%3==0) .toList() .size(); //2`
`<C extends PersistentCollection<? super T>> Vector<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
`Vector<Vector<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 PersistentCollection<? super T>> Vector<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()`
`Vector<T>`	`insertAt(int pos, java.lang.Iterable<? extends T> values)`
`Vector<T>`	`insertAt(int pos, ReactiveSeq<? extends T> values)`
`Vector<T>`	`insertAt(int pos, T... values)` Insert data into a traversable at given position
`Vector<T>`	`insertAt(int i, T e)`
`Vector<T>`	`insertStreamAt(int pos, java.util.stream.Stream<T> stream)` Insert a Stream into the middle of this traversable at the specified position
`Vector<T>`	`intersperse(T value)` Returns a Traversable with a given value interspersed between any two values.
`boolean`	`isEmpty()`
`static <T> Vector<T>`	`iterate(T seed, java.util.function.Predicate<? super T> pred, java.util.function.UnaryOperator<T> f)`
`static <T> Vector<T>`	`iterate(T seed, java.util.function.UnaryOperator<T> f, int max)`
`java.util.Iterator<T>`	`iterator()`
`<R> Vector<R>`	`map(java.util.function.Function<? super T,? extends R> fn)` Transform this functor using the supplied transformation function
`<R> Vector<R>`	`mergeMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)`
`<R> Vector<R>`	`mergeMap(int maxConcurecy, java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)`
`static <T> Vector<T>`	`narrowK(Higher<DataWitness.vector,T> list)`
`Vector<T>`	`notNull()` Filter elements retaining only values which are not null
`static <T> Vector<T>`	`of(T... value)`
`<U> Vector<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`Vector<T>`	`onEmpty(T value)` If this Container instance is zero, create a new instance containing the provided value
`Vector<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
`ImmutableList<T>`	`onEmptySwitch(java.util.function.Supplier<? extends ImmutableList<T>> supplier)` Switch to container created by provided Supplier, if current Container zero
`Vector<T>`	`peek(java.util.function.Consumer<? super T> c)` Peek at the current value of this Transformable, without transforming it
`Vector<ReactiveSeq<T>>`	`permutations()`
`Vector<T>`	`plus(T t)`
`Vector<T>`	`plusAll(int i, java.lang.Iterable<? extends T> values)`
`Vector<T>`	`plusAll(java.lang.Iterable<? extends T> list)`
`Vector<T>`	`prepend(T value)`
`Vector<T>`	`prependAll(java.lang.Iterable<? extends T> value)`
`Vector<T>`	`prependAll(T... values)` `List<String> result = ReactiveSeq.of(1,2,3) .prependAll(100,200,300) .map(it ->it+"!!") .collect(CyclopsCollectors.toList()); //asList("100!!","200!!","300!!","1!!","2!!","3!!")));`
`Vector<T>`	`prependStream(java.util.stream.Stream<? extends T> stream)`
`static Vector<java.lang.Integer>`	`range(int start, int end)`
`static Vector<java.lang.Integer>`	`range(int start, int step, int end)`
`static Vector<java.lang.Long>`	`rangeLong(long start, long end)`
`static Vector<java.lang.Long>`	`rangeLong(long start, long step, long end)`
`Vector<T>`	`removeAll(java.lang.Iterable<? extends T> list)` Remove all elements in the supplied Iterable from this filterable
`Vector<T>`	`removeAt(int i)`
`Vector<T>`	`removeAt(long pos)`
`Vector<T>`	`removeFirst(java.util.function.Predicate<? super T> pred)`
`Vector<T>`	`removeStream(java.util.stream.Stream<? extends T> stream)` Remove all elements in the supplied Stream from this filterable
`Vector<T>`	`removeValue(T e)`
`Vector<T>`	`replaceFirst(T currentElement, T newElement)`
`Vector<T>`	`retainAll(java.lang.Iterable<? extends T> it)` Retain only the supplied elements in the returned Filters
`Vector<T>`	`retainAll(T... values)` Retain only the supplied elements in the returned Filters
`Vector<T>`	`retainStream(java.util.stream.Stream<? extends T> stream)` Retain only the supplied elements in the returned Filters
`ImmutableList<T>`	`reverse()`
`Vector<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`<U> Vector<U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)` Scan left
`Vector<T>`	`scanRight(Monoid<T> monoid)` Scan right
`<U> Vector<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)` Scan right
`Either<java.lang.Integer,Vector<T>>`	`set(int pos, T value)`
`Vector<T>`	`shuffle()`
`Vector<T>`	`shuffle(java.util.Random random)`
`int`	`size()`
`Vector<T>`	`slice(long from, long to)`
`Vector<Seq<T>>`	`sliding(int windowSize)` Create a sliding view
`Vector<Seq<T>>`	`sliding(int windowSize, int increment)` Create a sliding view
`Vector<T>`	`sorted()` {@code ReactiveSeq.of(4,3,6,7)) .sorted() .toList() //Arrays.asList(3,4,6,7)
`Vector<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>> Vector<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`ReactiveSeq<T>`	`stream()`
`Vector<T>`	`subList(int start, int end)`
`static <T,R> Vector<R>`	`tailRec(T initial, java.util.function.Function<? super T,? extends Vector<? extends Either<T,R>>> fn)`
`Vector<T>`	`take(long num)` {@code ReactiveSeq.of(4,3,6,7) .take(2) .toList() asList(4,3)
`Vector<T>`	`takeRight(int num)` Generate a new Traversable that takes the specified number elements from the take of this Traversable
`Vector<T>`	`takeUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that takes elements from this Traversable until the predicate holds
`Vector<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()`
`static <U,T> Vector<T>`	`unfold(U seed, java.util.function.Function<? super U,Option<Tuple2<T,U>>> unfolder)`
`<R> Vector<R>`	`unitIterable(java.lang.Iterable<R> it)`
`<R> Vector<R>`	`unitStream(java.util.stream.Stream<R> stream)`
`static <T,U> Tuple2<Vector<T>,Vector<U>>`	`unzip(Vector<Tuple2<T,U>> sequence)`
`Vector<T>`	`updateAt(int pos, T value)`
`static <T> Higher<DataWitness.vector,T>`	`widen(Vector<T> narrow)`
`static <C2,T> Higher<C2,Higher<DataWitness.vector,T>>`	`widen2(Higher<C2,Vector<T>> list)`
`<T2,R> Vector<R>`	`zip(java.util.function.BiFunction<? super T,? super T2,? extends R> fn, org.reactivestreams.Publisher<? extends T2> publisher)` Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
`<U> Vector<Tuple2<T,U>>`	`zip(java.lang.Iterable<? extends U> other)`
`<U,R> Vector<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> Vector<Tuple3<T,S,U>>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third)`
`<S,U,R> Vector<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> Vector<Tuple4<T,T2,T3,T4>>`	`zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth)`
`<T2,T3,T4,R> Vector<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)`
`Vector<Tuple2<T,java.lang.Long>>`	`zipWithIndex()`
`<U> Vector<Tuple2<T,U>>`	`zipWithPublisher(org.reactivestreams.Publisher<? extends U> other)`
`<U> Vector<Tuple2<T,U>>`	`zipWithStream(java.util.stream.Stream<? extends U> other)`
`<U,R> Vector<R>`	`zipWithStream(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`

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

Methods inherited from interface cyclops.data.ImmutableList
compareTo, equalToDirectAccess, focusAt, focusAt, fold, last, lazySeq, nonEmptyList, onEmptyTry, partition, removeAll, seq, span, splitAt, splitBy, tailOrElse, traversable

Methods inherited from interface com.oath.cyclops.types.traversable.IterableX
asFunction, equalToIteration, foldFuture, foldLazy, foldTry, forEach, forEach, forEach, forEach, forEach, forEachSubscribe, forEachSubscribe, forEachSubscribe, runFuture, runLazy, to, toHashSet

Methods inherited from interface com.oath.cyclops.types.traversable.Traversable
fixedDelay, onePer, subscribe, xPer

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

Methods inherited from interface com.oath.cyclops.types.foldable.Folds
allMatch, anyMatch, atPercentile, bankersQueue, collect, collect, collect, collect, count, countDistinct, doubleStats, elementAt, endsWith, firstValue, foldLeft, foldLeft, foldLeft, foldLeft, foldLeft, foldLeft, foldMap, foldMap, foldMapRight, foldRight, foldRight, foldRight, groupBy, hashSet, headOption, indexOf, indexOfSlice, intStats, iterableTo, join, join, join, lastIndexOf, lastIndexOfSlice, longStats, maxBy, maxBy, maximum, mean, median, minBy, minBy, minimum, mode, noneMatch, nonEmptyList, occurances, populationVariance, print, print, printErr, printOut, scheduleStream, single, single, singleOrElse, startsWith, stdDeviation, sumDouble, sumInt, sumLong, takeOne, toArray, toArray, toCollection, toHashMap, toHashMap, toList, toMap, toMap, toSet, treeSet, variance, vector, withPercentiles, xMatch

Methods inherited from interface com.oath.cyclops.types.persistent.PersistentList
listView

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

Methods inherited from interface com.oath.cyclops.hkt.Higher
applyHKT_, applyHKT, applyHKT

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

- Constructor Detail
 - Vector
```
public Vector(BAMT.NestedArray<T> root,
 BAMT.ActiveTail<T> tail,
 int size)
```
- Method Detail
 - plusAll
```
public Vector<T> plusAll(java.lang.Iterable<? extends T> list)
```
 Specified by:
 
 plusAll in interface PersistentCollection<T>
 
 Specified by:
 
 plusAll in interface PersistentList<T>
 
 Specified by:
 
 plusAll in interface IterableX<T>
 
 Specified by:
 
 plusAll in interface ImmutableList<T>
 - containsValue
```
public boolean containsValue(T value)
```
 Specified by:
 
 containsValue in interface PersistentCollection<T>
 
 Specified by:
 
 containsValue in interface IterableX<T>
 
 Specified by:
 
 containsValue in interface ImmutableList<T>
 - unitIterable
```
public <R> Vector<R> unitIterable(java.lang.Iterable<R> it)
```
 Specified by:
 
 unitIterable in interface IterableX<T>
 
 Specified by:
 
 unitIterable in interface Traversable<T>
 
 Specified by:
 
 unitIterable in interface ImmutableList<T>
 - narrowK
```
public static <T> Vector<T> narrowK(Higher<DataWitness.vector,T> list)
```
 - widen2
```
public static <C2,T> Higher<C2,Higher<DataWitness.vector,T>> widen2(Higher<C2,Vector<T>> list)
```
 - forEach4
```
public <R1,R2,R3,R> Vector<R> forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
 java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2,
 Function3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> iterable3,
 Function4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
```
 Specified by:
 
 forEach4 in interface ImmutableList<T>
 - forEach4
```
public <R1,R2,R3,R> Vector<R> forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
 java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2,
 Function3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> iterable3,
 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)
```
 Specified by:
 
 forEach4 in interface ImmutableList<T>
 - forEach3
```
public <R1,R2,R> Vector<R> forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
 java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2,
 Function3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
```
 Specified by:
 
 forEach3 in interface ImmutableList<T>
 - forEach3
```
public <R1,R2,R> Vector<R> forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
 java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2,
 Function3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction,
 Function3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
```
 Specified by:
 
 forEach3 in interface ImmutableList<T>
 - forEach2
```
public <R1,R> Vector<R> forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
 java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
```
 Specified by:
 
 forEach2 in interface ImmutableList<T>
 - forEach2
```
public <R1,R> Vector<R> forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
 java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction,
 java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
```
 Specified by:
 
 forEach2 in interface ImmutableList<T>
 - iterator
```
public java.util.Iterator<T> iterator()
```
 Specified by:
 
 iterator in interface ImmutableList<T>
 
 Specified by:
 
 iterator in interface java.lang.Iterable<T>
 - removeValue
```
public Vector<T> removeValue(T e)
```
 Specified by:
 
 removeValue in interface PersistentCollection<T>
 
 Specified by:
 
 removeValue in interface PersistentList<T>
 
 Specified by:
 
 removeValue in interface IterableX<T>
 
 Specified by:
 
 removeValue in interface ImmutableList<T>
 - removeAll
```
public Vector<T> removeAll(java.lang.Iterable<? extends T> list)
```
 Description copied from interface: IterableFilterable
 
 Remove all elements in the supplied Iterable from this filterable
 
 Specified by:
 
 removeAll in interface PersistentCollection<T>
 
 Specified by:
 
 removeAll in interface PersistentList<T>
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Specified by:
 
 removeAll in interface IterableX<T>
 
 Specified by:
 
 removeAll in interface ImmutableList<T>
 
 Parameters:
 
 list - an Iterable of elements to removeValue
 
 Returns:
 
 Filters with all supplied elements removed
 - removeAt
```
public Vector<T> removeAt(int i)
```
 Specified by:
 
 removeAt in interface PersistentList<T>
 
 Specified by:
 
 removeAt in interface IterableX<T>
 
 Specified by:
 
 removeAt in interface Traversable<T>
 
 Specified by:
 
 removeAt in interface ImmutableList<T>
 - removeAt
```
public Vector<T> removeAt(long pos)
```
 Specified by:
 
 removeAt in interface IterableX<T>
 
 Specified by:
 
 removeAt in interface Traversable<T>
 
 Specified by:
 
 removeAt in interface ImmutableList<T>
 - insertAt
```
public Vector<T> insertAt(int pos,
 T... values)
```
 Description copied from interface: Traversable
 Insert data into a traversable at given position
```
 
 List<String> result = ReactiveSeq.of(1, 2, 3)
 .insertAt(1, 100, 200, 300)
 .map(it -> it + "!!")
 .collect(CyclopsCollectors.toList());

 //Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!")))
 
 
```
 Specified by:
 
 insertAt in interface IterableX<T>
 
 Specified by:
 
 insertAt in interface Traversable<T>
 
 Specified by:
 
 insertAt in interface ImmutableList<T>
 
 Parameters:
 
 pos - to insert data at
 
 values - to insert
 
 Returns:
 
 Traversable with new data inserted
 - insertAt
```
public Vector<T> insertAt(int i,
 T e)
```
 Specified by:
 
 insertAt in interface PersistentList<T>
 
 Specified by:
 
 insertAt in interface IterableX<T>
 
 Specified by:
 
 insertAt in interface ImmutableList<T>
 - insertAt
```
public Vector<T> insertAt(int pos,
 java.lang.Iterable<? extends T> values)
```
 Specified by:
 
 insertAt in interface PersistentList<T>
 
 Specified by:
 
 insertAt in interface IterableX<T>
 
 Specified by:
 
 insertAt in interface Traversable<T>
 
 Specified by:
 
 insertAt in interface ImmutableList<T>
 - insertAt
```
public Vector<T> insertAt(int pos,
 ReactiveSeq<? extends T> values)
```
 Specified by:
 
 insertAt in interface Traversable<T>
 - plusAll
```
public Vector<T> plusAll(int i,
 java.lang.Iterable<? extends T> values)
```
 - empty
```
public static <T> Vector<T> empty()
```
 - fill
```
public static <T> Vector<T> fill(T t,
 int max)
```
 - unfold
```
public static <U,T> Vector<T> unfold(U seed,
 java.util.function.Function<? super U,Option<Tuple2<T,U>>> unfolder)
```
 - iterate
```
public static <T> Vector<T> iterate(T seed,
 java.util.function.Predicate<? super T> pred,
 java.util.function.UnaryOperator<T> f)
```
 - iterate
```
public static <T> Vector<T> iterate(T seed,
 java.util.function.UnaryOperator<T> f,
 int max)
```
 - unzip
```
public static <T,U> Tuple2<Vector<T>,Vector> unzip(Vector<Tuple2<T,U>> sequence)
```
 - generate
```
public static <T> Vector<T> generate(java.util.function.Supplier<T> s,
 int max)
```
 - generate
```
public static <T> Vector<T> generate(Generator<T> s)
```
 - range
```
public static Vector<java.lang.Integer> range(int start,
 int end)
```
 - range
```
public static Vector<java.lang.Integer> range(int start,
 int step,
 int end)
```
 - rangeLong
```
public static Vector<java.lang.Long> rangeLong(long start,
 long step,
 long end)
```
 - rangeLong
```
public static Vector<java.lang.Long> rangeLong(long start,
 long end)
```
 - fromStream
```
public static <T> Vector<T> fromStream(java.util.stream.Stream<T> it)
```
 - fromIterator
```
public static <T> Vector<T> fromIterator(java.util.Iterator<T> it)
```
 - fromIterable
```
public static <T> Vector<T> fromIterable(java.lang.Iterable<T> it)
```
 - of
```
public static <T> Vector<T> of(T... value)
```
 - removeFirst
```
public Vector<T> removeFirst(java.util.function.Predicate<? super T> pred)
```
 Specified by:
 
 removeFirst in interface IterableX<T>
 
 Specified by:
 
 removeFirst in interface Traversable<T>
 
 Specified by:
 
 removeFirst in interface ImmutableList<T>
 - stream
```
public ReactiveSeq<T> stream()
```
 Specified by:
 
 stream in interface Folds<T>
 
 Specified by:
 
 stream in interface PersistentCollection<T>
 
 Specified by:
 
 stream in interface IterableX<T>
 
 Specified by:
 
 stream in interface Traversable<T>
 
 Specified by:
 
 stream in interface ImmutableList<T>
 
 Returns:
 
 This Traversable converted to a Stream
 - filter
```
public Vector<T> filter(java.util.function.Predicate<? super T> pred)
```
 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 Filters<T>
 
 Specified by:
 
 filter in interface FilterableTransformable<T>
 
 Specified by:
 
 filter in interface IterableX<T>
 
 Specified by:
 
 filter in interface ImmutableList<T>
 
 Parameters:
 
 pred - to filter elements by, retaining matches
 
 Returns:
 
 Filters with elements removed where the predicate does not hold
 - map
```
public <R> Vector<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 Transformable<T>
 
 Specified by:
 
 map in interface IterableX<T>
 
 Specified by:
 
 map in interface Traversable<T>
 
 Specified by:
 
 map in interface ImmutableList<T>
 
 Parameters:
 
 fn - Transformation function
 
 Returns:
 
 Transformed Transformable
 - fold
```
public <R> R fold(java.util.function.Function<? super ImmutableList.Some<T>,? extends R> fn1,
 java.util.function.Function<? super ImmutableList.None<T>,? extends R> fn2)
```
 Specified by:
 
 fold in interface Sealed2<ImmutableList.Some<T>,ImmutableList.None<T>>
 
 Specified by:
 
 fold in interface ImmutableList<T>
 - onEmpty
```
public Vector<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 OnEmpty<T>
 
 Specified by:
 
 onEmpty in interface IterableX<T>
 
 Specified by:
 
 onEmpty in interface Traversable<T>
 
 Specified by:
 
 onEmpty in interface ImmutableList<T>
 
 Returns:
 
 New instance containing value if container is zero, otherwise returns this container
 - onEmptyGet
```
public Vector<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 OnEmpty<T>
 
 Specified by:
 
 onEmptyGet in interface IterableX<T>
 
 Specified by:
 
 onEmptyGet in interface Traversable<T>
 
 Specified by:
 
 onEmptyGet in interface ImmutableList<T>
 
 Parameters:
 
 supplier - to determine new value for container
 
 Returns:
 
 New Container with value if this is zero, otherwise this container
 - replaceFirst
```
public Vector<T> replaceFirst(T currentElement,
 T newElement)
```
 Specified by:
 
 replaceFirst in interface ImmutableList<T>
 - ofType
```
public  Vector ofType(java.lang.Class<? extends U> type)
```
 Description copied from interface: Filters
 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>
 
 Specified by:
 
 ofType in interface ImmutableList<T>
 - filterNot
```
public Vector<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>
 
 Specified by:
 
 filterNot in interface ImmutableList<T>
 
 Parameters:
 
 predicate - to filter elements by, retaining matches
 
 Returns:
 
 Filters with elements removed where the predicate does not hold
 - notNull
```
public Vector<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>
 
 Specified by:
 
 notNull in interface ImmutableList<T>
 
 Returns:
 
 Filters with nulls removed
 - peek
```
public Vector<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 Transformable<T>
 
 Specified by:
 
 peek in interface IterableX<T>
 
 Specified by:
 
 peek in interface ImmutableList<T>
 
 Parameters:
 
 c - Consumer that recieves each element from this Transformable
 
 Returns:
 
 Transformable that will peek at each value
 - removeStream
```
public Vector<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>
 
 Specified by:
 
 removeStream in interface ImmutableList<T>
 
 Parameters:
 
 stream - of elements to remove
 
 Returns:
 
 Filters with all supplied elements removed
 - retainAll
```
public Vector<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>
 
 Specified by:
 
 retainAll in interface ImmutableList<T>
 
 Parameters:
 
 it - Iterable of elements to retain
 
 Returns:
 
 Filters with supplied values retained, and others removed
 - retainStream
```
public Vector<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>
 
 Specified by:
 
 retainStream in interface ImmutableList<T>
 
 Parameters:
 
 stream - of elements to retain
 
 Returns:
 
 Filters with supplied values retained, and others removed
 - retainAll
```
public Vector<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>
 
 Specified by:
 
 retainAll in interface ImmutableList<T>
 
 Parameters:
 
 values - elements to retain
 
 Returns:
 
 Filters with supplied values retained, and others removed
 - permutations
```
public Vector<ReactiveSeq<T>> permutations()
```
 Specified by:
 
 permutations in interface IterableX<T>
 
 Specified by:
 
 permutations in interface ImmutableList<T>
 - combinations
```
public Vector<ReactiveSeq<T>> combinations(int size)
```
 Specified by:
 
 combinations in interface IterableX<T>
 
 Specified by:
 
 combinations in interface ImmutableList<T>
 - combinations
```
public Vector<ReactiveSeq<T>> combinations()
```
 Specified by:
 
 combinations in interface IterableX<T>
 
 Specified by:
 
 combinations in interface ImmutableList<T>
 - zip
```
public <T2,R> Vector<R> zip(java.util.function.BiFunction<? super T,? super T2,? extends R> fn,
 org.reactivestreams.Publisher<? extends T2> publisher)
```
 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>
 
 Specified by:
 
 zip in interface ImmutableList<T>
 
 Parameters:
 
 fn - Zip / combining function
 
 publisher - to combine with
 
 Returns:
 
 Combined zippable
 - zipWithStream
```
public <U,R> Vector<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>
 
 Specified by:
 
 zipWithStream in interface ImmutableList<T>
 - zipWithPublisher
```
public  Vector<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>
 
 Specified by:
 
 zipWithPublisher in interface ImmutableList<T>
 - zip
```
public  Vector<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>
 
 Specified by:
 
 zip in interface ImmutableList<T>
 - zip3
```
public <S,U,R> Vector<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>
 
 Specified by:
 
 zip3 in interface ImmutableList<T>
 - zip4
```
public <T2,T3,T4,R> Vector<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>
 
 Specified by:
 
 zip4 in interface ImmutableList<T>
 - combine
```
public Vector<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)
 
```
 Can be used to implement terminating lazy folds on lazy data types
```
 
 ReactiveSeq.generate(this::process)
 .map(data->data.isSuccess())
 .combine((a,b)-> a ? false : true, (a,b) -> a|b)
 .findFirst(); //terminating reduction on infinite data structure
 


 
```
 Specified by:
 
 combine in interface IterableX<T>
 
 Specified by:
 
 combine in interface Traversable<T>
 
 Specified by:
 
 combine in interface ImmutableList<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 Vector<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>
 
 Specified by:
 
 combine in interface ImmutableList<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 Vector<T> cycle(long times)
```
 Specified by:
 
 cycle in interface IterableX<T>
 
 Specified by:
 
 cycle in interface Traversable<T>
 
 Specified by:
 
 cycle in interface ImmutableList<T>
 - cycle
```
public Vector<T> cycle(Monoid<T> m,
 long times)
```
 Specified by:
 
 cycle in interface IterableX<T>
 
 Specified by:
 
 cycle in interface Traversable<T>
 
 Specified by:
 
 cycle in interface ImmutableList<T>
 - cycleWhile
```
public Vector<T> cycleWhile(java.util.function.Predicate<? super T> predicate)
```
 Specified by:
 
 cycleWhile in interface IterableX<T>
 
 Specified by:
 
 cycleWhile in interface Traversable<T>
 
 Specified by:
 
 cycleWhile in interface ImmutableList<T>
 - cycleUntil
```
public Vector<T> cycleUntil(java.util.function.Predicate<? super T> predicate)
```
 Specified by:
 
 cycleUntil in interface IterableX<T>
 
 Specified by:
 
 cycleUntil in interface Traversable<T>
 
 Specified by:
 
 cycleUntil in interface ImmutableList<T>
 - zip
```
public <U,R> Vector<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>
 
 Specified by:
 
 zip in interface ImmutableList<T>
 
 Parameters:
 
 other - to zip with
 
 zipper - Zip function
 
 Returns:
 
 Combined zippable
 - zip3
```
public <S,U> Vector<Tuple3<T,S,U>> zip3(java.lang.Iterable<? extends S> second,
 java.lang.Iterable<? extends U> third)
```
 Specified by:
 
 zip3 in interface IterableX<T>
 
 Specified by:
 
 zip3 in interface Traversable<T>
 
 Specified by:
 
 zip3 in interface Zippable<T>
 
 Specified by:
 
 zip3 in interface ImmutableList<T>
 - zip4
```
public <T2,T3,T4> Vector<Tuple4<T,T2,T3,T4>> zip4(java.lang.Iterable<? extends T2> second,
 java.lang.Iterable<? extends T3> third,
 java.lang.Iterable<? extends T4> fourth)
```
 Specified by:
 
 zip4 in interface IterableX<T>
 
 Specified by:
 
 zip4 in interface Traversable<T>
 
 Specified by:
 
 zip4 in interface Zippable<T>
 
 Specified by:
 
 zip4 in interface ImmutableList<T>
 - zipWithIndex
```
public Vector<Tuple2<T,java.lang.Long>> zipWithIndex()
```
 Specified by:
 
 zipWithIndex in interface IterableX<T>
 
 Specified by:
 
 zipWithIndex in interface Traversable<T>
 
 Specified by:
 
 zipWithIndex in interface ImmutableList<T>
 - sliding
```
public Vector<Seq<T>> sliding(int windowSize)
```
 Description copied from interface: Traversable
 
 Create a sliding view
 
 Specified by:
 
 sliding in interface IterableX<T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Specified by:
 
 sliding in interface ImmutableList<T>
 - sliding
```
public Vector<Seq<T>> sliding(int windowSize,
 int increment)
```
 Description copied from interface: Traversable
 
 Create a sliding view
 
 Specified by:
 
 sliding in interface IterableX<T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Specified by:
 
 sliding in interface ImmutableList<T>
 - grouped
```
public <C extends PersistentCollection<? super T>> Vector<C> grouped(int size,
 java.util.function.Supplier<C> supplier)
```
 Description copied from interface: Traversable
 Group the elements of this traversable
```
 
 ReactiveSeq.of(1,1,1,1,1,1)
 .grouped(3,()->new TreeSet<>())
 .toList()
 .getValue(0)
 .size();
 //1

 ReactiveSeq.of(1,2,3,4,5,6)
 .grouped(3,()->new TreeSet<>())
 .toList()
 .getValue(0)
 .size();
 //3

 
 
```
 Specified by:
 
 grouped in interface IterableX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Specified by:
 
 grouped in interface ImmutableList<T>
 
 Parameters:
 
 size - batch size
 
 supplier - Collection factory
 
 Returns:
 
 Traversable grouped by size
 - groupedUntil
```
public Vector<Vector<T>> groupedUntil(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
```
 
 ReactiveSeq.of(1,2,3,4,5,6)
 .groupedUntil(i->i%3==0)
 .toList()
 .size();
 //2
 
 
```
 Specified by:
 
 groupedUntil in interface IterableX<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Specified by:
 
 groupedUntil in interface ImmutableList<T>
 
 Parameters:
 
 predicate - group until predicate holds
 
 Returns:
 
 Traversable batched into Vectors determined by the predicate supplied
 - groupedUntil
```
public Vector<Vector<T>> groupedUntil(java.util.function.BiPredicate<Vector<? 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)
 .groupedUntil((s,i)->s.contains(4) ? true : false)
 .toList().size(),equalTo(5));
 
 
```
 Specified by:
 
 groupedUntil in interface IterableX<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Specified by:
 
 groupedUntil in interface ImmutableList<T>
 
 Parameters:
 
 predicate - Window while true
 
 Returns:
 
 Traversable windowed while predicate holds
 - zipWithStream
```
public  Vector<Tuple2<T,U>> zipWithStream(java.util.stream.Stream<? extends U> other)
```
 Specified by:
 
 zipWithStream in interface IterableX<T>
 
 Specified by:
 
 zipWithStream in interface Traversable<T>
 
 Specified by:
 
 zipWithStream in interface ImmutableList<T>
 - groupedWhile
```
public Vector<Vector<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 IterableX<T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Specified by:
 
 groupedWhile in interface ImmutableList<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 PersistentCollection<? super T>> Vector<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)
 .groupedWhile(i->i%3!=0)
 .toList()
 .size(),equalTo(2));
 
 
```
 Specified by:
 
 groupedWhile in interface IterableX<T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Specified by:
 
 groupedWhile in interface ImmutableList<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 PersistentCollection<? super T>> Vector<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 IterableX<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Specified by:
 
 groupedUntil in interface ImmutableList<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 Vector<Vector<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.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>
 
 Specified by:
 
 grouped in interface ImmutableList<T>
 
 Parameters:
 
 groupSize - Size of each Group
 
 Returns:
 
 Stream with elements grouped by size
 - distinct
```
public Vector<T> distinct()
```
 Specified by:
 
 distinct in interface IterableX<T>
 
 Specified by:
 
 distinct in interface Traversable<T>
 
 Specified by:
 
 distinct in interface ImmutableList<T>
 - scanLeft
```
public Vector<T> scanLeft(Monoid<T> monoid)
```
 Description copied from interface: Traversable
 Scan left using supplied Monoid
```
 {@code

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

 
```
 Specified by:
 
 scanLeft in interface IterableX<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 
 Specified by:
 
 scanLeft in interface ImmutableList<T>
 
 Returns:
 - scanLeft
```
public  Vector scanLeft(U seed,
 java.util.function.BiFunction<? super U,? super T,? extends U> function)
```
 Description copied from interface: Traversable
 Scan left
```
 
 ReactiveSeq.of("a", "b", "c")
 .scanLeft("", String::concat)
 .toList();
 //[, a, ab, abc]
 
 
```
 Specified by:
 
 scanLeft in interface IterableX<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 
 Specified by:
 
 scanLeft in interface ImmutableList<T>
 - scanRight
```
public Vector<T> scanRight(Monoid<T> monoid)
```
 Description copied from interface: Traversable
 Scan right
```
 
 ReactiveSeq.of("a", "b", "c")
 .scanRight(Monoid.of("", String::concat))
 .toList()

 //asList("", "c", "bc", "abc")
 
 
```
 Specified by:
 
 scanRight in interface IterableX<T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 
 Specified by:
 
 scanRight in interface ImmutableList<T>
 - scanRight
```
public  Vector scanRight(U identity,
 java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
```
 Description copied from interface: Traversable
 Scan right
```
 
 ReactiveSeq.of("a", "ab", "abc")
 .map(str->str.length())
 .scanRight(0, (t, u) -> u + t)
 .toList();
 //asList(0, 3, 5, 6);

 
 
```
 Specified by:
 
 scanRight in interface IterableX<T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 
 Specified by:
 
 scanRight in interface ImmutableList<T>
 - sorted
```
public Vector<T> sorted()
```
 Description copied from interface: Traversable
```
 {@code ReactiveSeq.of(4,3,6,7))
 .sorted()
 .toList()

 //Arrays.asList(3,4,6,7)
 
```
 Specified by:
 
 sorted in interface IterableX<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 
 Specified by:
 
 sorted in interface ImmutableList<T>
 - sorted
```
public Vector<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 IterableX<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 
 Specified by:
 
 sorted in interface ImmutableList<T>
 
 Parameters:
 
 c - Compartor to sort with
 
 Returns:
 
 Sorted Stream
 - takeWhile
```
public Vector<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>
 
 Specified by:
 
 takeWhile in interface ImmutableList<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 Vector<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>
 
 Specified by:
 
 dropWhile in interface ImmutableList<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 Vector<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>
 
 Specified by:
 
 takeUntil in interface ImmutableList<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 Vector<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>
 
 Specified by:
 
 dropUntil in interface ImmutableList<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
 - intersperse
```
public Vector<T> intersperse(T value)
```
 Description copied from interface: Traversable
 Returns a Traversable with a given value interspersed between any two values.
```
 
 ReactiveSeq.of(1, 2, 3, 4).intersperse(0)
 // (1, 0, 2, 0, 3, 0, 4)
 
```
 Specified by:
 
 intersperse in interface IterableX<T>
 
 Specified by:
 
 intersperse in interface Traversable<T>
 
 Specified by:
 
 intersperse in interface ImmutableList<T>
 - shuffle
```
public Vector<T> shuffle()
```
 Specified by:
 
 shuffle in interface IterableX<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 
 Specified by:
 
 shuffle in interface ImmutableList<T>
 - shuffle
```
public Vector<T> shuffle(java.util.Random random)
```
 Specified by:
 
 shuffle in interface IterableX<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 
 Specified by:
 
 shuffle in interface ImmutableList<T>
 - slice
```
public Vector<T> slice(long from,
 long to)
```
 Specified by:
 
 slice in interface IterableX<T>
 
 Specified by:
 
 slice in interface Traversable<T>
 
 Specified by:
 
 slice in interface ImmutableList<T>
 - prependStream
```
public Vector<T> prependStream(java.util.stream.Stream<? extends T> stream)
```
 Specified by:
 
 prependStream in interface IterableX<T>
 
 Specified by:
 
 prependStream in interface Traversable<T>
 
 Specified by:
 
 prependStream in interface ImmutableList<T>
 - appendAll
```
public Vector<T> appendAll(T... values)
```
 Specified by:
 
 appendAll in interface IterableX<T>
 
 Specified by:
 
 appendAll in interface Traversable<T>
 
 Specified by:
 
 appendAll in interface ImmutableList<T>
 - prependAll
```
public Vector<T> prependAll(T... values)
```
 Description copied from interface: Traversable
```
 
 List<String> result = 	ReactiveSeq.of(1,2,3)
 									 .prependAll(100,200,300)
 									 .map(it ->it+"!!")
 									 .collect(CyclopsCollectors.toList());


 //asList("100!!","200!!","300!!","1!!","2!!","3!!")));
 
```
 Specified by:
 
 prependAll in interface IterableX<T>
 
 Specified by:
 
 prependAll in interface Traversable<T>
 
 Specified by:
 
 prependAll in interface ImmutableList<T>
 
 Parameters:
 
 values - to prependAll
 
 Returns:
 
 ReactiveSeq with values prepended
 - deleteBetween
```
public Vector<T> deleteBetween(int start,
 int end)
```
 Description copied from interface: Traversable
 Delete elements between given indexes
```
 {@code
 List result = ReactiveSeq.of(1, 2, 3, 4, 5, 6)
 .deleteBetween(2, 4).map(it -> it + "!!")
 .collect(CyclopsCollectors.toList());

 //Arrays.asList("1!!", "2!!", "5!!", "6!!")));
 
```
 Specified by:
 
 deleteBetween in interface IterableX<T>
 
 Specified by:
 
 deleteBetween in interface Traversable<T>
 
 Specified by:
 
 deleteBetween in interface ImmutableList<T>
 
 Parameters:
 
 start - index
 
 end - index
 
 Returns:
 
 Stream with elements removed
 - insertStreamAt
```
public Vector<T> insertStreamAt(int pos,
 java.util.stream.Stream<T> stream)
```
 Description copied from interface: Traversable
 Insert a Stream into the middle of this traversable at the specified position
```
 
 List<String> result = ReactiveSeq.of(1, 2, 3)
 .insertAt(1, of(100, 200, 300))
 .map(it -> it + "!!")
 .collect(CyclopsCollectors.toList());

 //Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!")));
 
 
```
 Specified by:
 
 insertStreamAt in interface IterableX<T>
 
 Specified by:
 
 insertStreamAt in interface Traversable<T>
 
 Specified by:
 
 insertStreamAt in interface ImmutableList<T>
 
 Parameters:
 
 pos - to insert Stream at
 
 stream - to insert
 
 Returns:
 
 newly conjoined Traversable
 - sorted
```
public > Vector<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>
 
 Specified by:
 
 sorted in interface ImmutableList<T>
 - updateAt
```
public Vector<T> updateAt(int pos,
 T value)
```
 Specified by:
 
 updateAt in interface PersistentList<T>
 
 Specified by:
 
 updateAt in interface IterableX<T>
 
 Specified by:
 
 updateAt in interface Traversable<T>
 
 Specified by:
 
 updateAt in interface ImmutableList<T>
 - onEmptySwitch
```
public ImmutableList<T> onEmptySwitch(java.util.function.Supplier<? extends ImmutableList<T>> supplier)
```
 Description copied from interface: OnEmptySwitch
 Switch to container created by provided Supplier, if current Container zero
```
 
 Seq.zero().onEmptySwitch(()->Seq.of(1));
 
 
```
 Specified by:
 
 onEmptySwitch in interface OnEmptySwitch<ImmutableList<T>,ImmutableList<T>>
 
 Specified by:
 
 onEmptySwitch in interface ImmutableList<T>
 
 Parameters:
 
 supplier - to create replacement container
 
 Returns:
 
 Either this container or if zero, an alternative returned by the provided supplier
 - flatMap
```
public <R> Vector<R> flatMap(java.util.function.Function<? super T,? extends ImmutableList<? extends R>> fn)
```
 Specified by:
 
 flatMap in interface ImmutableList<T>
 - mergeMap
```
public <R> Vector<R> mergeMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
```
 Specified by:
 
 mergeMap in interface IterableX<T>
 
 Specified by:
 
 mergeMap in interface ImmutableList<T>
 - mergeMap
```
public <R> Vector<R> mergeMap(int maxConcurecy,
 java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
```
 Specified by:
 
 mergeMap in interface IterableX<T>
 
 Specified by:
 
 mergeMap in interface ImmutableList<T>
 - concatMap
```
public <R> Vector<R> concatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)
```
 Description copied from interface: IterableX
 
 Perform a flatMap operation on this IterableX. Results from the returned Iterables (from the provided transformation function) are flattened into the resulting toX.
 
 Specified by:
 
 concatMap in interface IterableX<T>
 
 Specified by:
 
 concatMap in interface ImmutableList<T>
 
 Parameters:
 
 fn - Transformation function to be applied (and flattened)
 
 Returns:
 
 An IterableX containing the flattened results of the transformation function
 - set
```
public Either<java.lang.Integer,Vector<T>> set(int pos,
 T value)
```
 - delete
```
public Either<java.lang.Integer,Vector<T>> delete(int pos)
```
 - size
```
public int size()
```
 Specified by:
 
 size in interface PersistentCollection<T>
 
 Specified by:
 
 size in interface IterableX<T>
 
 Specified by:
 
 size in interface ImmutableList<T>
 - isEmpty
```
public boolean isEmpty()
```
 Specified by:
 
 isEmpty in interface PersistentCollection<T>
 
 Specified by:
 
 isEmpty in interface IterableX<T>
 
 Specified by:
 
 isEmpty in interface ImmutableList<T>
 - plus
```
public Vector<T> plus(T t)
```
 Specified by:
 
 plus in interface PersistentCollection<T>
 
 Specified by:
 
 plus in interface PersistentList<T>
 
 Specified by:
 
 plus in interface IterableX<T>
 
 Specified by:
 
 plus in interface ImmutableList<T>
 - unitStream
```
public <R> Vector<R> unitStream(java.util.stream.Stream<R> stream)
```
 Specified by:
 
 unitStream in interface ImmutableList<T>
 - emptyUnit
```
public Vector<T> emptyUnit()
```
 Specified by:
 
 emptyUnit in interface ImmutableList<T>
 - takeRight
```
public Vector<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>
 
 Specified by:
 
 takeRight in interface ImmutableList<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
 - dropRight
```
public Vector<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>
 
 Specified by:
 
 dropRight in interface ImmutableList<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
 - drop
```
public Vector<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 IterableX<T>
 
 Specified by:
 
 drop in interface Traversable<T>
 
 Specified by:
 
 drop in interface ImmutableList<T>
 
 Parameters:
 
 num - Number of elemenets to drop
 
 Returns:
 
 Traversable with specified number of elements skipped
 - take
```
public Vector<T> take(long num)
```
 Description copied from interface: Traversable
```
 {@code
 ReactiveSeq.of(4,3,6,7)
 .take(2)
 .toList()
 asList(4,3)
 
```
 Specified by:
 
 take in interface IterableX<T>
 
 Specified by:
 
 take in interface Traversable<T>
 
 Specified by:
 
 take in interface ImmutableList<T>
 
 Parameters:
 
 num - Elements to take
 
 Returns:
 
 Traversable with specified number of elements
 - prepend
```
public Vector<T> prepend(T value)
```
 Specified by:
 
 prepend in interface IterableX<T>
 
 Specified by:
 
 prepend in interface Traversable<T>
 
 Specified by:
 
 prepend in interface ImmutableList<T>
 - prependAll
```
public Vector<T> prependAll(java.lang.Iterable<? extends T> value)
```
 Specified by:
 
 prependAll in interface IterableX<T>
 
 Specified by:
 
 prependAll in interface Traversable<T>
 
 Specified by:
 
 prependAll in interface ImmutableList<T>
 - append
```
public Vector<T> append(T value)
```
 Specified by:
 
 append in interface IterableX<T>
 
 Specified by:
 
 append in interface Traversable<T>
 
 Specified by:
 
 append in interface ImmutableList<T>
 - appendAll
```
public Vector<T> appendAll(java.lang.Iterable<? extends T> value)
```
 Specified by:
 
 appendAll in interface IterableX<T>
 
 Specified by:
 
 appendAll in interface Traversable<T>
 
 Specified by:
 
 appendAll in interface ImmutableList<T>
 - subList
```
public Vector<T> subList(int start,
 int end)
```
 Specified by:
 
 subList in interface ImmutableList<T>
 - reverse
```
public ImmutableList<T> reverse()
```
 Specified by:
 
 reverse in interface IterableX<T>
 
 Specified by:
 
 reverse in interface Traversable<T>
 
 Specified by:
 
 reverse in interface ImmutableList<T>
 - get
```
public Option<T> get(int pos)
```
 Specified by:
 
 get in interface PersistentIndexed<T>
 
 Specified by:
 
 get in interface ImmutableList<T>
 - getOrElse
```
public T getOrElse(int pos,
 T alt)
```
 Specified by:
 
 getOrElse in interface PersistentIndexed<T>
 
 Specified by:
 
 getOrElse in interface ImmutableList<T>
 - getOrElseGet
```
public T getOrElseGet(int pos,
 java.util.function.Supplier<? extends T> alt)
```
 Specified by:
 
 getOrElseGet in interface PersistentIndexed<T>
 
 Specified by:
 
 getOrElseGet in interface ImmutableList<T>
 - toString
```
public java.lang.String toString()
```
 Overrides:
 
 toString in class java.lang.Object
 - equals
```
public boolean equals(java.lang.Object o)
```
 Overrides:
 
 equals in class java.lang.Object
 - hashCode
```
public int hashCode()
```
 Overrides:
 
 hashCode in class java.lang.Object
 - tailRec
```
public static <T,R> Vector<R> tailRec(T initial,
 java.util.function.Function<? super T,? extends Vector<? extends Either<T,R>>> fn)
```
 - widen
```
public static <T> Higher<DataWitness.vector,T> widen(Vector<T> narrow)
```

Class Vector<T>

Nested Class Summary

Nested classes/interfaces inherited from interface cyclops.data.ImmutableList

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface cyclops.data.ImmutableList

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

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

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

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

Methods inherited from interface com.oath.cyclops.types.persistent.PersistentList

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

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

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

Constructor Detail

Vector

Method Detail

plusAll

containsValue

unitIterable

narrowK

widen2

forEach4

forEach4

forEach3

forEach3

forEach2

forEach2

iterator

removeValue

removeAll

removeAt

removeAt

insertAt

insertAt

insertAt

insertAt

plusAll

empty

fill

unfold

iterate

iterate

unzip

generate

generate

range

range

rangeLong

rangeLong

fromStream

fromIterator

fromIterable

of

removeFirst

stream

filter

map

fold

onEmpty

onEmptyGet

replaceFirst

ofType

filterNot

notNull

peek

removeStream

retainAll

retainStream

retainAll

permutations

combinations

combinations

zip

zipWithStream

zipWithPublisher

zip

zip3

zip4