LazySeq (cyclops 10.0.0-RC1 API)

All Superinterfaces:

java.lang.Comparable<T>, Contains<T>, Convert<Higher<DataWitness.lazySeq,T>>, FilterableTransformable<T>, Filters<T>, Folds<T>, Higher<DataWitness.lazySeq,T>, io.kindedj.Hk<DataWitness.lazySeq,T>, ImmutableList<T>, java.lang.Iterable<T>, IterableFilterable<T>, IterableX<T>, OnEmpty<T>, OnEmptyError<T,ImmutableList<T>>, OnEmptySwitch<ImmutableList<T>,ImmutableList<T>>, PersistentCollection<T>, PersistentIndexed<T>, PersistentList<T>, org.reactivestreams.Publisher<T>, ReactiveStreamsTerminalOperations<T>, Sealed2<ImmutableList.Some<T>,ImmutableList.None<T>>, java.io.Serializable, To<ImmutableList<T>>, Transformable<T>, Traversable<T>, Zippable<T>

All Known Implementing Classes:

LazySeq.Cons, LazySeq.Nil
```
public interface LazySeq<T>
extends ImmutableList<T>, Folds<T>, Filters<T>, Transformable<T>, java.io.Serializable, Higher<DataWitness.lazySeq,T>
```

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class LazySeq.Cons<T>

static class LazySeq.Nil<T>
- Nested classes/interfaces inherited from interface cyclops.data.ImmutableList
 ImmutableList.None<T>, ImmutableList.Some<T>

Nested Classes
Modifier and Type	Interface and Description
`static class`	`LazySeq.Cons<T>`
`static class`	`LazySeq.Nil<T>`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`LazySeq<T>`	`append(java.util.function.Supplier<LazySeq<T>> list)`
`default LazySeq<T>`	`append(T append)`
`default LazySeq<T>`	`appendAll(java.lang.Iterable<? extends T> it)`
`default LazySeq<T>`	`appendAll(T... values)` Append values to the take of this ReactiveSeq
`static <T> java.util.stream.Collector<T,java.util.List<T>,LazySeq<T>>`	`collector()`
`default LazySeq<ReactiveSeq<T>>`	`combinations()`
`default LazySeq<ReactiveSeq<T>>`	`combinations(int size)`
`default LazySeq<T>`	`combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)` Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation.
`default LazySeq<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> LazySeq<R>`	`concatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)` Perform a flatMap operation on this IterableX.
`static <T> LazySeq<T>`	`cons(T head, java.util.function.Supplier<LazySeq<T>> tail)`
`default boolean`	`containsValue(T value)`
`LazySeq<T>`	`cycle()`
`default LazySeq<T>`	`cycle(long times)` Convert to a Stream with the values repeated specified times
`default LazySeq<T>`	`cycle(Monoid<T> m, long times)` Convert to a Stream with the result of a reduction operation repeated specified times
`default LazySeq<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream until specified predicate holds
`default LazySeq<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream while specified predicate holds
`static <T> LazySeq<T>`	`deferred(java.util.function.Supplier<? extends java.lang.Iterable<? extends T>> lazy)`
`default LazySeq<T>`	`deleteBetween(int start, int end)` Delete elements between given indexes in a Stream
`default LazySeq<T>`	`distinct()`
`default LazySeq<T>`	`drop(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7)));`
`default LazySeq<T>`	`dropRight(int num)` Generate a new Traversable that drops the specified number elements from the take of this Traversable
`default LazySeq<T>`	`dropUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that drops elements from this Traversable until the predicate holds
`default LazySeq<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
`default Tuple2<LazySeq<T>,LazySeq<T>>`	`duplicate()`
`static <T> LazySeq<T>`	`empty()`
`default ImmutableList<T>`	`emptyUnit()`
`static <E extends java.lang.Enum<E>> LazySeq<E>`	`enums(java.lang.Class<E> c)` Stream over the values of an enum
`static <E extends java.lang.Enum<E>> LazySeq<E>`	`enums(java.lang.Class<E> c, E start)` Stream over the values of an enum
`static <E extends java.lang.Enum<E>> LazySeq<E>`	`enums(java.lang.Class<E> c, E start, E step, E end)` Stream over the values of an enum
`static <E extends java.lang.Enum<E>> LazySeq<E>`	`enumsFromTo(java.lang.Class<E> c, E start, E end)` Stream over the values of an enum
`static <T> LazySeq<T>`	`fill(long limit, T t)`
`static <T> LazySeq<T>`	`fill(T t)`
`LazySeq<T>`	`filter(java.util.function.Predicate<? super T> pred)` Keep only elements for which the supplied predicates hold e.g.
`default LazySeq<T>`	`filterNot(java.util.function.Predicate<? super T> predicate)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<R> LazySeq<R>`	`flatMap(java.util.function.Function<? super T,? extends ImmutableList<? extends R>> fn)`
`<R> R`	`foldLazySeq(java.util.function.Function<? super LazySeq.Cons<T>,? extends R> fn1, java.util.function.Function<? super LazySeq.Nil,? extends R> fn2)`
`default <R> R`	`foldLeft(R zero, java.util.function.BiFunction<R,? super T,R> f)`
`default T`	`foldRight(Monoid<T> reducer)` `ReactiveSeq.of("a","b","c").foldRight(Reducers.toString("")); // "cab"`
`default <R> R`	`foldRight(R zero, java.util.function.BiFunction<? super T,? super R,? extends R> f)` Immutable reduction from right to left
`default T`	`foldRight(T identity, java.util.function.BinaryOperator<T> accumulator)` Immutable reduction from right to left
`default <R1,R> LazySeq<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)`
`default <R1,R> LazySeq<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)`
`default <R1,R2,R> LazySeq<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)`
`default <R1,R2,R> LazySeq<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)`
`default <R1,R2,R3,R> LazySeq<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)`
`default <R1,R2,R3,R> LazySeq<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> LazySeq<T>`	`fromIterable(java.lang.Iterable<T> it)`
`static <T> LazySeq<T>`	`fromIterator(java.util.Iterator<T> it)`
`static <T> LazySeq<T>`	`fromStream(java.util.stream.Stream<T> stream)`
`static <T> LazySeq<T>`	`generate(Generator<T> s)`
`static <T> LazySeq<T>`	`generate(java.util.function.Supplier<T> s)`
`static <T> LazySeq<T>`	`generate(java.util.function.Supplier<T> s, long times)`
`default Option<T>`	`get(int pos)`
`default T`	`getOrElse(int pos, T alt)`
`default T`	`getOrElseGet(int pos, java.util.function.Supplier<? extends T> alt)`
`default LazySeq<Vector<T>>`	`grouped(int groupSize)` Group elements in a Stream
`default <C extends PersistentCollection<? super T>> LazySeq<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
`default LazySeq<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.
`default LazySeq<Vector<T>>`	`groupedUntil(java.util.function.Predicate<? super T> predicate)` Create a Traversable batched by List, where each batch is populated until the predicate holds
`default <C extends PersistentCollection<? super T>> LazySeq<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
`default LazySeq<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
`default <C extends PersistentCollection<? super T>> LazySeq<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
`default T`	`headOrElse(T head)`
`default T`	`headOrElseGet(java.util.function.Supplier<? extends T> head)`
`default LazySeq<T>`	`insertAt(int pos, java.lang.Iterable<? extends T> list)`
`default LazySeq<T>`	`insertAt(int pos, T... values)` Insert data into a stream at given position
`default LazySeq<T>`	`insertAt(int i, T e)`
`default LazySeq<T>`	`insertStreamAt(int pos, java.util.stream.Stream<T> stream)` Insert a Stream into the middle of this stream at the specified position
`default LazySeq<T>`	`intersperse(T value)` Returns a stream with a given value interspersed between any two values of this stream.
`boolean`	`isEmpty()`
`static <T> LazySeq<T>`	`iterate(T seed, java.util.function.Predicate<? super T> pred, java.util.function.UnaryOperator<T> f)`
`static <T> LazySeq<T>`	`iterate(T seed, java.util.function.UnaryOperator<T> f)`
`static <T> LazySeq<T>`	`iterate(T seed, java.util.function.UnaryOperator<T> f, long times)`
`default java.util.Iterator<T>`	`iterator()`
`static <T> LazySeq<T>`	`lazy(T head, java.util.function.Supplier<ImmutableList<T>> tail)`
`<R> R`	`lazyFoldRight(R zero, java.util.function.BiFunction<? super T,java.util.function.Supplier<R>,? extends R> f)`
`default LazySeq<T>`	`limit(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`default LazySeq<T>`	`limitLast(int num)` Limit results to the last x elements in a SequenceM
`default LazySeq<T>`	`limitUntil(java.util.function.Predicate<? super T> p)` Take elements from the Stream until the predicate returns true, after which all elements are excluded.
`default LazySeq<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
`default LazySeq<T>`	`linkedSeq()`
`<R> LazySeq<R>`	`map(java.util.function.Function<? super T,? extends R> fn)` Transform this functor using the supplied transformation function
`<R> LazySeq<R>`	`mergeMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)`
`<R> LazySeq<R>`	`mergeMap(int maxConcurecy, java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)`
`default java.lang.String`	`mkString()`
`static <R> LazySeq<R>`	`narrow(LazySeq<? extends R> rs)`
`static <T> LazySeq<T>`	`narrowK(Higher<DataWitness.lazySeq,T> list)`
`default LazySeq<T>`	`notNull()` Filter elements retaining only values which are not null
`static <T> LazySeq<T>`	`of(T... value)`
`default <U> LazySeq<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`LazySeq<T>`	`onEmpty(T value)` If this Container instance is zero, create a new instance containing the provided value
`LazySeq<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
`default LazySeq<T>`	`peek(java.util.function.Consumer<? super T> c)` Peek at the current value of this Transformable, without transforming it
`default LazySeq<ReactiveSeq<T>>`	`permutations()`
`default LazySeq<T>`	`plus(T value)`
`default LazySeq<T>`	`plusAll(java.lang.Iterable<? extends T> t)`
`default LazySeq<T>`	`prepend(T value)`
`default LazySeq<T>`	`prependAll(java.lang.Iterable<? extends T> it)`
`default LazySeq<T>`	`prependAll(T... values)` Prepend given values to the skip of the Stream
`default LazySeq<T>`	`prependStream(java.util.stream.Stream<? extends T> stream)` Prepend Stream to this ReactiveSeq
`static LazySeq<java.lang.Integer>`	`range(int start, int end)`
`static LazySeq<java.lang.Integer>`	`range(int start, int step, int end)`
`static LazySeq<java.lang.Long>`	`rangeLong(long start, long end)`
`static LazySeq<java.lang.Long>`	`rangeLong(long start, long step, long end)`
`default LazySeq<T>`	`removeAll(java.lang.Iterable<? extends T> list)` Remove all elements in the supplied Iterable from this filterable
`default LazySeq<T>`	`removeAll(T... values)` Remove all supplied elements from this filterable
`LazySeq<T>`	`removeAt(int i)`
`default LazySeq<T>`	`removeAt(long pos)`
`default LazySeq<T>`	`removeFirst(java.util.function.Predicate<? super T> pred)`
`default LazySeq<T>`	`removeStream(java.util.stream.Stream<? extends T> stream)` Remove all elements in the supplied Stream from this filterable
`default LazySeq<T>`	`removeValue(T value)`
`default LazySeq<T>`	`replaceFirst(T currentElement, T newElement)`
`default LazySeq<T>`	`retainAll(java.lang.Iterable<? extends T> it)` Retain only the supplied elements in the returned Filters
`default LazySeq<T>`	`retainAll(T... values)` Retain only the supplied elements in the returned Filters
`default LazySeq<T>`	`retainStream(java.util.stream.Stream<? extends T> stream)` Retain only the supplied elements in the returned Filters
`default LazySeq<T>`	`reverse()` Potentially efficient Stream reversal.
`default LazySeq<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`default <U> LazySeq<U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)` Scan left
`default LazySeq<T>`	`scanRight(Monoid<T> monoid)` Scan right
`default <U> LazySeq<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)` Scan right
`default LazySeq<T>`	`shuffle()`
`default LazySeq<T>`	`shuffle(java.util.Random random)`
`int`	`size()`
`default LazySeq<T>`	`skip(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`default LazySeq<T>`	`skipLast(int num)` assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(1,2,3)));
`default LazySeq<T>`	`skipUntil(java.util.function.Predicate<? super T> p)` Drop elements from the Stream until the predicate returns true, after which all elements are included
`default LazySeq<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 *
`default LazySeq<T>`	`slice(long from, long to)`
`default LazySeq<Seq<T>>`	`sliding(int windowSize)` Create a sliding view over this Sequence
`default LazySeq<Seq<T>>`	`sliding(int windowSize, int increment)` Create a sliding view over this Sequence
`default LazySeq<T>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`default LazySeq<T>`	`sorted(java.util.Comparator<? super T> c)` `assertThat(ReactiveSeq.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));`
`default <U extends java.lang.Comparable<? super U>> LazySeq<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`default Tuple2<ImmutableList<T>,ImmutableList<T>>`	`span(java.util.function.Predicate<? super T> pred)`
`default LazySeq<LazySeq<T>>`	`split(java.util.function.Predicate<? super T> test)`
`default Tuple2<ImmutableList<T>,ImmutableList<T>>`	`splitBy(java.util.function.Predicate<? super T> test)`
`default ReactiveSeq<T>`	`stream()`
`default LazySeq<T>`	`subList(int start, int end)`
`default LazySeq<T>`	`tailOrElse(LazySeq<T> tail)`
`default LazySeq<T>`	`tailOrElseGet(java.util.function.Supplier<? extends LazySeq<T>> tail)`
`static <T,R> LazySeq<R>`	`tailRec(T initial, java.util.function.Function<? super T,? extends LazySeq<? extends Either<T,R>>> fn)`
`default LazySeq<T>`	`take(long n)` `assertThat(ReactiveSeq.of(4,3,6,7).take(2).toList(),equalTo(Arrays.asList(4,3));`
`default LazySeq<T>`	`takeRight(int num)` Generate a new Traversable that takes the specified number elements from the take of this Traversable
`default LazySeq<T>`	`takeUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that takes elements from this Traversable until the predicate holds
`default LazySeq<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
`static <U,T> LazySeq<T>`	`unfold(U seed, java.util.function.Function<? super U,Option<Tuple2<T,U>>> unfolder)`
`default <R> LazySeq<R>`	`unitIterable(java.lang.Iterable<R> it)` Create an IterableFunctor instance of the same type from an Iterator
`default <R> LazySeq<R>`	`unitStream(java.util.stream.Stream<R> stream)`
`default <R1,R2> Tuple2<LazySeq<R1>,LazySeq<R2>>`	`unzip(java.util.function.Function<? super T,Tuple2<? extends R1,? extends R2>> fn)`
`static <T,U> Tuple2<LazySeq<T>,LazySeq<U>>`	`unzip(LazySeq<Tuple2<T,U>> sequence)`
`LazySeq<T>`	`updateAt(int i, T value)`
`static <T> Higher<DataWitness.lazySeq,T>`	`widen(LazySeq<T> narrow)`
`static <C2,T> Higher<C2,Higher<DataWitness.lazySeq,T>>`	`widen2(Higher<C2,LazySeq<T>> list)`
`default <T2,R> LazySeq<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
`default <U> LazySeq<Tuple2<T,U>>`	`zip(java.lang.Iterable<? extends U> other)`
`default <U,R> LazySeq<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
`default <S,U> LazySeq<Tuple3<T,S,U>>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third)` zip 3 Streams into one
`default <S,U,R> LazySeq<R>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third, Function3<? super T,? super S,? super U,? extends R> fn3)`
`default <T2,T3,T4> LazySeq<Tuple4<T,T2,T3,T4>>`	`zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth)` zip 4 Streams into 1
`default <T2,T3,T4,R> LazySeq<R>`	`zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth, Function4<? super T,? super T2,? super T3,? super T4,? extends R> fn)`
`default LazySeq<Tuple2<T,java.lang.Long>>`	`zipWithIndex()` Add an index to the current Stream
`default <U> LazySeq<Tuple2<T,U>>`	`zipWithPublisher(org.reactivestreams.Publisher<? extends U> other)`
`default <U> LazySeq<Tuple2<T,U>>`	`zipWithStream(java.util.stream.Stream<? extends U> other)`
`default <U,R> LazySeq<R>`	`zipWithStream(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`

Methods inherited from interface cyclops.data.ImmutableList
compareTo, equalToDirectAccess, focusAt, focusAt, fold, fold, last, lazySeq, nonEmptyList, onEmptyTry, partition, seq, splitAt, 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, toSeq

Methods inherited from interface com.oath.cyclops.types.traversable.Traversable
fixedDelay, insertAt, 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, foldMap, foldMap, foldMapRight, 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

- Method Detail
 - collector
```
static <T> java.util.stream.Collector<T,java.util.List<T>,LazySeq<T>> collector()
```
 - unitIterable
```
default <R> LazySeq<R> unitIterable(java.lang.Iterable<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:
 
 unitIterable in interface ImmutableList<T>
 
 Specified by:
 
 unitIterable in interface IterableX<T>
 
 Specified by:
 
 unitIterable in interface Traversable<T>
 
 Parameters:
 
 it - Iterator to create new IterableFunctor from
 
 Returns:
 
 New IterableFunctor instance
 - headOrElse
```
default T headOrElse(T head)
```
 - headOrElseGet
```
default T headOrElseGet(java.util.function.Supplier<? extends T> head)
```
 - tailOrElse
```
default LazySeq<T> tailOrElse(LazySeq<T> tail)
```
 - tailOrElseGet
```
default LazySeq<T> tailOrElseGet(java.util.function.Supplier<? extends LazySeq<T>> tail)
```
 - containsValue
```
default boolean containsValue(T value)
```
 Specified by:
 
 containsValue in interface ImmutableList<T>
 
 Specified by:
 
 containsValue in interface IterableX<T>
 
 Specified by:
 
 containsValue in interface PersistentCollection<T>
 - narrow
```
static <R> LazySeq<R> narrow(LazySeq<? extends R> rs)
```
 - tailRec
```
static <T,R> LazySeq<R> tailRec(T initial,
 java.util.function.Function<? super T,? extends LazySeq<? extends Either<T,R>>> fn)
```
 - fill
```
static <T> LazySeq<T> fill(T t)
```
 - fill
```
static <T> LazySeq<T> fill(long limit,
 T t)
```
 - unfold
```
static <U,T> LazySeq<T> unfold(U seed,
 java.util.function.Function<? super U,Option<Tuple2<T,U>>> unfolder)
```
 - iterate
```
static <T> LazySeq<T> iterate(T seed,
 java.util.function.UnaryOperator<T> f)
```
 - iterate
```
static <T> LazySeq<T> iterate(T seed,
 java.util.function.Predicate<? super T> pred,
 java.util.function.UnaryOperator<T> f)
```
 - iterate
```
static <T> LazySeq<T> iterate(T seed,
 java.util.function.UnaryOperator<T> f,
 long times)
```
 - deferred
```
static <T> LazySeq<T> deferred(java.util.function.Supplier<? extends java.lang.Iterable<? extends T>> lazy)
```
 - unzip
```
static <T,U> Tuple2<LazySeq<T>,LazySeq> unzip(LazySeq<Tuple2<T,U>> sequence)
```
 - generate
```
static <T> LazySeq<T> generate(java.util.function.Supplier<T> s)
```
 - generate
```
static <T> LazySeq<T> generate(java.util.function.Supplier<T> s,
 long times)
```
 - generate
```
static <T> LazySeq<T> generate(Generator<T> s)
```
 - range
```
static LazySeq<java.lang.Integer> range(int start,
 int end)
```
 - range
```
static LazySeq<java.lang.Integer> range(int start,
 int step,
 int end)
```
 - rangeLong
```
static LazySeq<java.lang.Long> rangeLong(long start,
 long step,
 long end)
```
 - rangeLong
```
static LazySeq<java.lang.Long> rangeLong(long start,
 long end)
```
 - removeAll
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Specified by:
 
 removeAll in interface IterableX<T>
 
 Specified by:
 
 removeAll in interface PersistentCollection<T>
 
 Specified by:
 
 removeAll in interface PersistentList<T>
 
 Parameters:
 
 list - an Iterable of elements to removeValue
 
 Returns:
 
 Filters with all supplied elements removed
 - unitStream
```
default <R> LazySeq<R> unitStream(java.util.stream.Stream<R> stream)
```
 Specified by:
 
 unitStream in interface ImmutableList<T>
 - stream
```
default ReactiveSeq<T> stream()
```
 Specified by:
 
 stream in interface Folds<T>
 
 Specified by:
 
 stream in interface ImmutableList<T>
 
 Specified by:
 
 stream in interface IterableX<T>
 
 Specified by:
 
 stream in interface PersistentCollection<T>
 
 Specified by:
 
 stream in interface Traversable<T>
 
 Returns:
 
 This Traversable converted to a Stream
 - linkedSeq
```
default LazySeq<T> linkedSeq()
```
 - append
```
LazySeq<T> append(java.util.function.Supplier<LazySeq<T>> list)
```
 - removeAll
```
default LazySeq<T> removeAll(T... values)
```
 Description copied from interface: IterableFilterable
 
 Remove all supplied elements from this filterable
 
 Specified by:
 
 removeAll in interface ImmutableList<T>
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Specified by:
 
 removeAll in interface IterableX<T>
 
 Parameters:
 
 values - to removeValue
 
 Returns:
 
 Filters with all supplied values removed
 - plusAll
```
default LazySeq<T> plusAll(java.lang.Iterable<? extends T> t)
```
 Specified by:
 
 plusAll in interface ImmutableList<T>
 
 Specified by:
 
 plusAll in interface IterableX<T>
 
 Specified by:
 
 plusAll in interface PersistentCollection<T>
 
 Specified by:
 
 plusAll in interface PersistentList<T>
 - insertAt
```
default LazySeq<T> insertAt(int pos,
 java.lang.Iterable<? extends T> list)
```
 Specified by:
 
 insertAt in interface ImmutableList<T>
 
 Specified by:
 
 insertAt in interface IterableX<T>
 
 Specified by:
 
 insertAt in interface PersistentList<T>
 
 Specified by:
 
 insertAt in interface Traversable<T>
 - updateAt
```
LazySeq<T> updateAt(int i,
 T value)
```
 Specified by:
 
 updateAt in interface ImmutableList<T>
 
 Specified by:
 
 updateAt in interface IterableX<T>
 
 Specified by:
 
 updateAt in interface PersistentList<T>
 
 Specified by:
 
 updateAt in interface Traversable<T>
 - removeAt
```
LazySeq<T> removeAt(int i)
```
 Specified by:
 
 removeAt in interface ImmutableList<T>
 
 Specified by:
 
 removeAt in interface IterableX<T>
 
 Specified by:
 
 removeAt in interface PersistentList<T>
 
 Specified by:
 
 removeAt in interface Traversable<T>
 - insertAt
```
default LazySeq<T> insertAt(int i,
 T e)
```
 Specified by:
 
 insertAt in interface ImmutableList<T>
 
 Specified by:
 
 insertAt in interface IterableX<T>
 
 Specified by:
 
 insertAt in interface PersistentList<T>
 - removeValue
```
default LazySeq<T> removeValue(T value)
```
 Specified by:
 
 removeValue in interface ImmutableList<T>
 
 Specified by:
 
 removeValue in interface IterableX<T>
 
 Specified by:
 
 removeValue in interface PersistentCollection<T>
 
 Specified by:
 
 removeValue in interface PersistentList<T>
 - enums
```
static <E extends java.lang.Enum<E>> LazySeq<E> enums(java.lang.Class<E> c)
```
 Stream over the values of an enum
```
 
 LazyList.enums(Days.class)
 .printOut();
 

 Monday
 Tuesday
 Wednesday
 Thursday
 Friday
 Saturday
 Sunday
 
```
 Type Parameters:
 
 E - Enum type
 
 Parameters:
 
 c - Enum to process
 
 Returns:
 
 Stream over enum
 - enums
```
static <E extends java.lang.Enum<E>> LazySeq<E> enums(java.lang.Class<E> c,
 E start)
```
 Stream over the values of an enum
```
 
 LazyList.enums(Days.class,Days.Wednesday)
 .printOut();
 

 Wednesday
 Thursday
 Friday
 Saturday
 Sunday
 
```
 Type Parameters:
 
 E - Enum type
 
 Parameters:
 
 c - Enum to process
 
 start - Start value
 
 Returns:
 
 Stream over enum
 - enumsFromTo
```
static <E extends java.lang.Enum<E>> LazySeq<E> enumsFromTo(java.lang.Class<E> c,
 E start,
 E end)
```
 Stream over the values of an enum
```
 
 LazyList.enums(Days.class,Days.Wednesday,Days.Friday)
 .printOut();
 

 Wednesday
 Thursday
 Friday
 
```
 Type Parameters:
 
 E - Enum type
 
 Parameters:
 
 c - Enum to process
 
 start - Start value
 
 end - End value
 
 Returns:
 
 Stream over enum
 - enums
```
static <E extends java.lang.Enum<E>> LazySeq<E> enums(java.lang.Class<E> c,
 E start,
 E step,
 E end)
```
 Stream over the values of an enum
```
 
 LazyList.enums(Days.class,Days.Monday,Days.Wednesday,Days.Friday)
 .printOut();
 
 Monday
 Wednesday
 Friday
 
```
 Type Parameters:
 
 E - Enum type
 
 Parameters:
 
 c - Enum to process
 
 start - Start value
 
 step - Values for which the Distance from start in terms of the enum ordinal determines the stepping function
 
 end - End value
 
 Returns:
 
 Stream over enum
 - fromIterable
```
static <T> LazySeq<T> fromIterable(java.lang.Iterable<T> it)
```
 - fromIterator
```
static <T> LazySeq<T> fromIterator(java.util.Iterator<T> it)
```
 - fromStream
```
static <T> LazySeq<T> fromStream(java.util.stream.Stream<T> stream)
```
 - of
```
@SafeVarargs
static <T> LazySeq<T> of(T... value)
```
 - empty
```
static <T> LazySeq<T> empty()
```
 - span
```
default Tuple2<ImmutableList<T>,ImmutableList<T>> span(java.util.function.Predicate<? super T> pred)
```
 Specified by:
 
 span in interface ImmutableList<T>
 - splitBy
```
default Tuple2<ImmutableList<T>,ImmutableList<T>> splitBy(java.util.function.Predicate<? super T> test)
```
 Specified by:
 
 splitBy in interface ImmutableList<T>
 - split
```
default LazySeq<LazySeq<T>> split(java.util.function.Predicate<? super T> test)
```
 - take
```
default LazySeq<T> take(long n)
```
 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 ImmutableList<T>
 
 Specified by:
 
 take in interface IterableX<T>
 
 Specified by:
 
 take in interface Traversable<T>
 
 Parameters:
 
 n - Limit element size to num
 
 Returns:
 
 Monad converted to Stream with elements up to num
 - takeWhile
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 takeWhile in interface IterableX<T>
 
 Specified by:
 
 takeWhile in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to determine when values should be taken
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - dropWhile
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 dropWhile in interface IterableX<T>
 
 Specified by:
 
 dropWhile in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to determine when values should be dropped
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - drop
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 drop in interface IterableX<T>
 
 Specified by:
 
 drop in interface Traversable<T>
 
 Parameters:
 
 num - Number of elemenets to drop
 
 Returns:
 
 Traversable with specified number of elements skipped
 - reverse
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 reverse in interface IterableX<T>
 
 Specified by:
 
 reverse in interface Traversable<T>
 - duplicate
```
default Tuple2<LazySeq<T>,LazySeq<T>> duplicate()
```
 - unzip
```
default <R1,R2> Tuple2<LazySeq<R1>,LazySeq<R2>> unzip(java.util.function.Function<? super T,Tuple2<? extends R1,? extends R2>> fn)
```
 - emptyUnit
```
default ImmutableList<T> emptyUnit()
```
 Specified by:
 
 emptyUnit in interface ImmutableList<T>
 - replaceFirst
```
default LazySeq<T> replaceFirst(T currentElement,
 T newElement)
```
 Specified by:
 
 replaceFirst in interface ImmutableList<T>
 - get
```
default Option<T> get(int pos)
```
 Specified by:
 
 get in interface ImmutableList<T>
 
 Specified by:
 
 get in interface PersistentIndexed<T>
 - getOrElse
```
default T getOrElse(int pos,
 T alt)
```
 Specified by:
 
 getOrElse in interface ImmutableList<T>
 
 Specified by:
 
 getOrElse in interface PersistentIndexed<T>
 - getOrElseGet
```
default T getOrElseGet(int pos,
 java.util.function.Supplier<? extends T> alt)
```
 Specified by:
 
 getOrElseGet in interface ImmutableList<T>
 
 Specified by:
 
 getOrElseGet in interface PersistentIndexed<T>
 - removeFirst
```
default LazySeq<T> removeFirst(java.util.function.Predicate<? super T> pred)
```
 Specified by:
 
 removeFirst in interface ImmutableList<T>
 
 Specified by:
 
 removeFirst in interface IterableX<T>
 
 Specified by:
 
 removeFirst in interface Traversable<T>
 - plus
```
default LazySeq<T> plus(T value)
```
 Specified by:
 
 plus in interface ImmutableList<T>
 
 Specified by:
 
 plus in interface IterableX<T>
 
 Specified by:
 
 plus in interface PersistentCollection<T>
 
 Specified by:
 
 plus in interface PersistentList<T>
 - prependAll
```
default LazySeq<T> prependAll(java.lang.Iterable<? extends T> it)
```
 Specified by:
 
 prependAll in interface ImmutableList<T>
 
 Specified by:
 
 prependAll in interface IterableX<T>
 
 Specified by:
 
 prependAll in interface Traversable<T>
 - append
```
default LazySeq<T> append(T append)
```
 Specified by:
 
 append in interface ImmutableList<T>
 
 Specified by:
 
 append in interface IterableX<T>
 
 Specified by:
 
 append in interface Traversable<T>
 - iterator
```
default java.util.Iterator<T> iterator()
```
 Specified by:
 
 iterator in interface ImmutableList<T>
 
 Specified by:
 
 iterator in interface java.lang.Iterable<T>
 - map
```
<R> LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 map in interface IterableX<T>
 
 Specified by:
 
 map in interface Transformable<T>
 
 Specified by:
 
 map in interface Traversable<T>
 
 Parameters:
 
 fn - Transformation function
 
 Returns:
 
 Transformed Transformable
 - flatMap
```
<R> LazySeq<R> flatMap(java.util.function.Function<? super T,? extends ImmutableList<? extends R>> fn)
```
 Specified by:
 
 flatMap in interface ImmutableList<T>
 - concatMap
```
<R> LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 concatMap in interface IterableX<T>
 
 Parameters:
 
 fn - Transformation function to be applied (and flattened)
 
 Returns:
 
 An IterableX containing the flattened results of the transformation function
 - mergeMap
```
<R> LazySeq<R> mergeMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
```
 Specified by:
 
 mergeMap in interface ImmutableList<T>
 
 Specified by:
 
 mergeMap in interface IterableX<T>
 - mergeMap
```
<R> LazySeq<R> mergeMap(int maxConcurecy,
 java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
```
 Specified by:
 
 mergeMap in interface ImmutableList<T>
 
 Specified by:
 
 mergeMap in interface IterableX<T>
 - appendAll
```
default LazySeq<T> appendAll(java.lang.Iterable<? extends T> it)
```
 Specified by:
 
 appendAll in interface ImmutableList<T>
 
 Specified by:
 
 appendAll in interface IterableX<T>
 
 Specified by:
 
 appendAll in interface Traversable<T>
 - foldLeft
```
default <R> R foldLeft(R zero,
 java.util.function.BiFunction<R,? super T,R> f)
```
 Specified by:
 
 foldLeft in interface Folds<T>
 - subList
```
default LazySeq<T> subList(int start,
 int end)
```
 Specified by:
 
 subList in interface ImmutableList<T>
 - ofType
```
default  LazySeq 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 ImmutableList<T>
 
 Specified by:
 
 ofType in interface IterableX<T>
 - filterNot
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 filterNot in interface IterableX<T>
 
 Specified by:
 
 filterNot in interface Traversable<T>
 
 Parameters:
 
 predicate - to filter elements by, retaining matches
 
 Returns:
 
 Filters with elements removed where the predicate does not hold
 - notNull
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 notNull in interface IterableX<T>
 
 Returns:
 
 Filters with nulls removed
 - peek
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 peek in interface IterableX<T>
 
 Specified by:
 
 peek in interface Transformable<T>
 
 Parameters:
 
 c - Consumer that recieves each element from this Transformable
 
 Returns:
 
 Transformable that will peek at each value
 - removeStream
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 removeStream in interface IterableFilterable<T>
 
 Specified by:
 
 removeStream in interface IterableX<T>
 
 Parameters:
 
 stream - of elements to remove
 
 Returns:
 
 Filters with all supplied elements removed
 - retainAll
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Specified by:
 
 retainAll in interface IterableX<T>
 
 Parameters:
 
 it - Iterable of elements to retain
 
 Returns:
 
 Filters with supplied values retained, and others removed
 - retainStream
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 retainStream in interface IterableFilterable<T>
 
 Specified by:
 
 retainStream in interface IterableX<T>
 
 Parameters:
 
 stream - of elements to retain
 
 Returns:
 
 Filters with supplied values retained, and others removed
 - retainAll
```
default LazySeq<T> retainAll(T... values)
```
 Description copied from interface: IterableFilterable
 
 Retain only the supplied elements in the returned Filters
 
 Specified by:
 
 retainAll in interface ImmutableList<T>
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Specified by:
 
 retainAll in interface IterableX<T>
 
 Parameters:
 
 values - elements to retain
 
 Returns:
 
 Filters with supplied values retained, and others removed
 - permutations
```
default LazySeq<ReactiveSeq<T>> permutations()
```
 Specified by:
 
 permutations in interface ImmutableList<T>
 
 Specified by:
 
 permutations in interface IterableX<T>
 - combinations
```
default LazySeq<ReactiveSeq<T>> combinations(int size)
```
 Specified by:
 
 combinations in interface ImmutableList<T>
 
 Specified by:
 
 combinations in interface IterableX<T>
 - combinations
```
default LazySeq<ReactiveSeq<T>> combinations()
```
 Specified by:
 
 combinations in interface ImmutableList<T>
 
 Specified by:
 
 combinations in interface IterableX<T>
 - zip
```
default <T2,R> LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 zip in interface IterableX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 fn - Zip / combining function
 
 publisher - to combine with
 
 Returns:
 
 Combined zippable
 - zipWithStream
```
default <U,R> LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 zipWithStream in interface IterableX<T>
 
 Specified by:
 
 zipWithStream in interface Traversable<T>
 - zipWithPublisher
```
default  LazySeq<Tuple2<T,U>> zipWithPublisher(org.reactivestreams.Publisher<? extends U> other)
```
 Specified by:
 
 zipWithPublisher in interface ImmutableList<T>
 
 Specified by:
 
 zipWithPublisher in interface IterableX<T>
 
 Specified by:
 
 zipWithPublisher in interface Traversable<T>
 
 Specified by:
 
 zipWithPublisher in interface Zippable<T>
 - zip
```
default  LazySeq<Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
```
 Specified by:
 
 zip in interface ImmutableList<T>
 
 Specified by:
 
 zip in interface IterableX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 - zip3
```
default <S,U,R> LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 zip3 in interface IterableX<T>
 
 Specified by:
 
 zip3 in interface Traversable<T>
 
 Specified by:
 
 zip3 in interface Zippable<T>
 - zip4
```
default <T2,T3,T4,R> LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 zip4 in interface IterableX<T>
 
 Specified by:
 
 zip4 in interface Traversable<T>
 
 Specified by:
 
 zip4 in interface Zippable<T>
 - combine
```
default LazySeq<T> combine(java.util.function.BiPredicate<? super T,? super T> predicate,
 java.util.function.BinaryOperator<T> op)
```
 Description copied from interface: Traversable
 Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation. The emitted of a combination may in turn be combined with it's neighbour
```
 
 ReactiveSeq.of(1,1,2,3)
 .combine((a, b)->a.equals(b),SemigroupK.intSum)
 .listX()

 //Seq(3,4)
 
```
 Specified by:
 
 combine in interface ImmutableList<T>
 
 Specified by:
 
 combine in interface IterableX<T>
 
 Specified by:
 
 combine in interface Traversable<T>
 
 Parameters:
 
 predicate - Test to see if two neighbours should be joined. The first parameter to the bi-predicate is the currently accumulated result and the second is the next element
 
 op - BinaryOperator to combine neighbours
 
 Returns:
 
 Combined / Partially Reduced Traversable
 - combine
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 combine in interface IterableX<T>
 
 Specified by:
 
 combine in interface Traversable<T>
 
 Parameters:
 
 op - Monoid to combine neighbours
 
 predicate - Test to see if two neighbours should be joined. The first parameter to the bi-predicate is the currently accumulated result and the second is the next element
 
 Returns:
 
 Combined / Partially Reduced Traversable
 - cycle
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 cycle in interface IterableX<T>
 
 Specified by:
 
 cycle in interface Traversable<T>
 
 Parameters:
 
 times - Times values should be repeated within a Stream
 
 Returns:
 
 Stream with values repeated
 - cycle
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 cycle in interface IterableX<T>
 
 Specified by:
 
 cycle in interface Traversable<T>
 
 Parameters:
 
 m - Monoid to be used in reduction
 
 times - Number of times value should be repeated
 
 Returns:
 
 Stream with reduced values repeated
 - cycleWhile
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 cycleWhile in interface IterableX<T>
 
 Specified by:
 
 cycleWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - cycleUntil
```
default LazySeq<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.getValue()>6)
 		 		.peek(i-> count.mutate(i->i+1))
 		 		.collect(CyclopsCollectors.toList());

 		//List[1,2,2,1,2,2,1]
 
 
```
 Specified by:
 
 cycleUntil in interface ImmutableList<T>
 
 Specified by:
 
 cycleUntil in interface IterableX<T>
 
 Specified by:
 
 cycleUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - zip
```
default <U,R> LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 zip in interface IterableX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - to zip with
 
 zipper - Zip function
 
 Returns:
 
 Combined zippable
 - zip3
```
default <S,U> LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 zip3 in interface IterableX<T>
 
 Specified by:
 
 zip3 in interface Traversable<T>
 
 Specified by:
 
 zip3 in interface Zippable<T>
 - zip4
```
default <T2,T3,T4> LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 zip4 in interface IterableX<T>
 
 Specified by:
 
 zip4 in interface Traversable<T>
 
 Specified by:
 
 zip4 in interface Zippable<T>
 - zipWithIndex
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 zipWithIndex in interface IterableX<T>
 
 Specified by:
 
 zipWithIndex in interface Traversable<T>
 - sliding
```
default LazySeq<Seq<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.getValue(0), hasItems(1, 2));
 assertThat(list.getValue(1), hasItems(2, 3));

 

 
```
 Specified by:
 
 sliding in interface ImmutableList<T>
 
 Specified by:
 
 sliding in interface IterableX<T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Parameters:
 
 windowSize - Size of sliding window
 
 Returns:
 
 SequenceM with sliding view
 - sliding
```
default LazySeq<Seq<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.getValue(0), hasItems(1, 2, 3));
 assertThat(list.getValue(1), hasItems(3, 4, 5));


 

 
```
 Specified by:
 
 sliding in interface ImmutableList<T>
 
 Specified by:
 
 sliding in interface IterableX<T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Parameters:
 
 windowSize - number of elements in each batch
 
 increment - for each window
 
 Returns:
 
 SequenceM with sliding view
 - grouped
```
default <C extends PersistentCollection<? super T>> LazySeq<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()
 .getValue(0)
 .size(),is(1));
 
 
```
 Specified by:
 
 grouped in interface ImmutableList<T>
 
 Specified by:
 
 grouped in interface IterableX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 size - batch size
 
 supplier - Collection factory
 
 Returns:
 
 SequenceM batched into toX types by size
 - groupedUntil
```
default LazySeq<Vector<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 ImmutableList<T>
 
 Specified by:
 
 groupedUntil in interface IterableX<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, applyHKT open next batch
 
 Returns:
 
 SequenceM batched into lists determined by the predicate supplied
 - groupedUntil
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 groupedUntil in interface IterableX<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Window while true
 
 Returns:
 
 Traversable windowed while predicate holds
 - zipWithStream
```
default  LazySeq<Tuple2<T,U>> zipWithStream(java.util.stream.Stream<? extends U> other)
```
 Specified by:
 
 zipWithStream in interface ImmutableList<T>
 
 Specified by:
 
 zipWithStream in interface IterableX<T>
 
 Specified by:
 
 zipWithStream in interface Traversable<T>
 - groupedWhile
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 groupedWhile in interface IterableX<T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, applyHKT open next batch
 
 Returns:
 
 SequenceM batched into lists determined by the predicate supplied
 - groupedWhile
```
default <C extends PersistentCollection<? super T>> LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 groupedWhile in interface IterableX<T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, applyHKT open next batch
 
 factory - Collection factory
 
 Returns:
 
 SequenceM batched into collections determined by the predicate supplied
 - groupedUntil
```
default <C extends PersistentCollection<? super T>> LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 groupedUntil in interface IterableX<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, applyHKT open next batch
 
 factory - Collection factory
 
 Returns:
 
 SequenceM batched into collections determined by the predicate supplied
 - grouped
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 grouped in interface IterableX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 groupSize - Size of each Group
 
 Returns:
 
 Stream with elements grouped by size
 - distinct
```
default LazySeq<T> distinct()
```
 Specified by:
 
 distinct in interface ImmutableList<T>
 
 Specified by:
 
 distinct in interface IterableX<T>
 
 Specified by:
 
 distinct in interface Traversable<T>
 - scanLeft
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 scanLeft in interface IterableX<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 
 Returns:
 - scanLeft
```
default  LazySeq 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 ImmutableList<T>
 
 Specified by:
 
 scanLeft in interface IterableX<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 - scanRight
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 scanRight in interface IterableX<T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 - scanRight
```
default  LazySeq 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 ImmutableList<T>
 
 Specified by:
 
 scanRight in interface IterableX<T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 - sorted
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 sorted in interface IterableX<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 - sorted
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 sorted in interface IterableX<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 
 Parameters:
 
 c - Compartor to sort with
 
 Returns:
 
 Sorted Stream
 - takeUntil
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 takeUntil in interface IterableX<T>
 
 Specified by:
 
 takeUntil in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to determine when values should be taken until
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - dropUntil
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 dropUntil in interface IterableX<T>
 
 Specified by:
 
 dropUntil in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to determine when values should be dropped
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - removeAt
```
default LazySeq<T> removeAt(long pos)
```
 Specified by:
 
 removeAt in interface ImmutableList<T>
 
 Specified by:
 
 removeAt in interface IterableX<T>
 
 Specified by:
 
 removeAt in interface Traversable<T>
 - insertAt
```
default LazySeq<T> insertAt(int pos,
 T... values)
```
 Description copied from interface: Traversable
 Insert data into a stream 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 ImmutableList<T>
 
 Specified by:
 
 insertAt in interface IterableX<T>
 
 Specified by:
 
 insertAt in interface Traversable<T>
 
 Parameters:
 
 pos - to insert data at
 
 values - to insert
 
 Returns:
 
 Stream with new data inserted
 - dropRight
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 dropRight in interface IterableX<T>
 
 Specified by:
 
 dropRight in interface Traversable<T>
 
 Parameters:
 
 num - Drop this number of elements from the take of this Traversable
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - takeRight
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 takeRight in interface IterableX<T>
 
 Specified by:
 
 takeRight in interface Traversable<T>
 
 Parameters:
 
 num - Take this number of elements from the take of this Traversable
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - skip
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 skip in interface IterableX<T>
 
 Specified by:
 
 skip in interface Traversable<T>
 
 Parameters:
 
 num - Number of elemenets to skip
 
 Returns:
 
 Stream with specified number of elements skipped
 - skipWhile
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 skipWhile in interface IterableX<T>
 
 Specified by:
 
 skipWhile in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to skip while true
 
 Returns:
 
 Stream with elements skipped while predicate holds
 - skipUntil
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 skipUntil in interface IterableX<T>
 
 Specified by:
 
 skipUntil in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to skip until true
 
 Returns:
 
 Stream with elements skipped until predicate holds
 - limit
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 limit in interface IterableX<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
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 limitWhile in interface IterableX<T>
 
 Specified by:
 
 limitWhile in interface Traversable<T>
 
 Parameters:
 
 p - Limit while predicate is true
 
 Returns:
 
 Stream with limited elements
 - limitUntil
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 limitUntil in interface IterableX<T>
 
 Specified by:
 
 limitUntil in interface Traversable<T>
 
 Parameters:
 
 p - Limit until predicate is true
 
 Returns:
 
 Stream with limited elements
 - intersperse
```
default LazySeq<T> intersperse(T value)
```
 Description copied from interface: Traversable
 
 Returns a stream with a given value interspersed between any two values of this stream. // (1, 0, 2, 0, 3, 0, 4) ReactiveSeq.of(1, 2, 3, 4).intersperse(0)
 
 Specified by:
 
 intersperse in interface ImmutableList<T>
 
 Specified by:
 
 intersperse in interface IterableX<T>
 
 Specified by:
 
 intersperse in interface Traversable<T>
 - shuffle
```
default LazySeq<T> shuffle()
```
 Specified by:
 
 shuffle in interface ImmutableList<T>
 
 Specified by:
 
 shuffle in interface IterableX<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 - skipLast
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 skipLast in interface IterableX<T>
 
 Specified by:
 
 skipLast in interface Traversable<T>
 
 Returns:
 - limitLast
```
default LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 limitLast in interface IterableX<T>
 
 Specified by:
 
 limitLast in interface Traversable<T>
 
 Parameters:
 
 num - of elements to return (last elements)
 
 Returns:
 
 SequenceM limited to last num elements
 - shuffle
```
default LazySeq<T> shuffle(java.util.Random random)
```
 Specified by:
 
 shuffle in interface ImmutableList<T>
 
 Specified by:
 
 shuffle in interface IterableX<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 - slice
```
default LazySeq<T> slice(long from,
 long to)
```
 Specified by:
 
 slice in interface ImmutableList<T>
 
 Specified by:
 
 slice in interface IterableX<T>
 
 Specified by:
 
 slice in interface Traversable<T>
 - onEmpty
```
LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 onEmpty in interface IterableX<T>
 
 Specified by:
 
 onEmpty in interface OnEmpty<T>
 
 Specified by:
 
 onEmpty in interface Traversable<T>
 
 Returns:
 
 New instance containing value if container is zero, otherwise returns this container
 - onEmptyGet
```
LazySeq<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 ImmutableList<T>
 
 Specified by:
 
 onEmptyGet in interface IterableX<T>
 
 Specified by:
 
 onEmptyGet in interface OnEmpty<T>
 
 Specified by:
 
 onEmptyGet in interface Traversable<T>
 
 Parameters:
 
 supplier - to determine new value for container
 
 Returns:
 
 New Container with value if this is zero, otherwise this container
 - prependStream
```
default LazySeq<T> prependStream(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)
 .prependStream(of(100, 200, 300))
 .map(it -> it + "!!")
 .collect(CyclopsCollectors.toList());

 assertThat(result, equalTo(Arrays.asList("100!!", "200!!", "300!!", "1!!", "2!!", "3!!")));
 
 
```
 Specified by:
 
 prependStream in interface ImmutableList<T>
 
 Specified by:
 
 prependStream in interface IterableX<T>
 
 Specified by:
 
 prependStream in interface Traversable<T>
 
 Parameters:
 
 stream - to Prepend
 
 Returns:
 
 ReactiveSeq with Stream prepended
 - appendAll
```
default LazySeq<T> appendAll(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:
 
 appendAll in interface ImmutableList<T>
 
 Specified by:
 
 appendAll in interface IterableX<T>
 
 Specified by:
 
 appendAll in interface Traversable<T>
 
 Parameters:
 
 values - to append
 
 Returns:
 
 ReactiveSeq with appended values
 - prependAll
```
default LazySeq<T> prependAll(T... values)
```
 Description copied from interface: Traversable
 Prepend given values to the skip of the Stream
```
 
 List<String> result = 	ReactiveSeq.of(1,2,3)
 									 .prependAll(100,200,300)
 										 .map(it ->it+"!!")
 										 .collect(CyclopsCollectors.toList());

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

 assertThat(result, equalTo(Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!")));
 
 
```
 Specified by:
 
 insertStreamAt in interface ImmutableList<T>
 
 Specified by:
 
 insertStreamAt in interface IterableX<T>
 
 Specified by:
 
 insertStreamAt in interface Traversable<T>
 
 Parameters:
 
 pos - to insert Stream at
 
 stream - to insert
 
 Returns:
 
 newly conjoined Traversable
 - prepend
```
default LazySeq<T> prepend(T value)
```
 Specified by:
 
 prepend in interface ImmutableList<T>
 
 Specified by:
 
 prepend in interface IterableX<T>
 
 Specified by:
 
 prepend in interface Traversable<T>
 - sorted
```
default > LazySeq<T> sorted(java.util.function.Function<? super T,? extends U> function)
```
 Specified by:
 
 sorted in interface ImmutableList<T>
 
 Specified by:
 
 sorted in interface IterableX<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 - mkString
```
default java.lang.String mkString()
```
 - foldRight
```
default <R> R foldRight(R zero,
 java.util.function.BiFunction<? super T,? super R,? extends R> f)
```
 Description copied from interface: Folds
 
 Immutable reduction from right to left
 
 Specified by:
 
 foldRight in interface Folds<T>
 
 Parameters:
 
 zero - Identity value for the combiner function (leaves the input unchanged)
 
 f - Combining function
 
 Returns:
 
 Reduced value
 - foldRight
```
default T foldRight(T identity,
 java.util.function.BinaryOperator<T> accumulator)
```
 Description copied from interface: Folds
 Immutable reduction from right to left
```
 
 assertTrue(ReactiveSeq.of("a","b","c").foldRight("", String::concat).equals("cba"));
 
 
```
 Specified by:
 
 foldRight in interface Folds<T>
 
 Parameters:
 
 identity - Identity value for the combiner function (leaves the input unchanged)
 
 accumulator - Combining function
 
 Returns:
 
 Reduced value
 - foldRight
```
default T foldRight(Monoid<T> reducer)
```
 Description copied from interface: Folds
```
 
 		ReactiveSeq.of("a","b","c").foldRight(Reducers.toString(""));

 // "cab"
 
 
```
 Specified by:
 
 foldRight in interface Folds<T>
 
 Parameters:
 
 reducer - Use supplied Monoid to reduce values starting via foldRight
 
 Returns:
 
 Reduced result
 - filter
```
LazySeq<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 FilterableTransformable<T>
 
 Specified by:
 
 filter in interface Filters<T>
 
 Specified by:
 
 filter in interface ImmutableList<T>
 
 Specified by:
 
 filter in interface IterableX<T>
 
 Parameters:
 
 pred - to filter elements by, retaining matches
 
 Returns:
 
 Filters with elements removed where the predicate does not hold
 - foldLazySeq
```
<R> R foldLazySeq(java.util.function.Function<? super LazySeq.Cons<T>,? extends R> fn1,
 java.util.function.Function<? super LazySeq.Nil,? extends R> fn2)
```
 - cycle
```
LazySeq<T> cycle()
```
 - size
```
int size()
```
 Specified by:
 
 size in interface ImmutableList<T>
 
 Specified by:
 
 size in interface IterableX<T>
 
 Specified by:
 
 size in interface PersistentCollection<T>
 - isEmpty
```
boolean isEmpty()
```
 Specified by:
 
 isEmpty in interface ImmutableList<T>
 
 Specified by:
 
 isEmpty in interface IterableX<T>
 
 Specified by:
 
 isEmpty in interface PersistentCollection<T>
 - lazy
```
static <T> LazySeq<T> lazy(T head,
 java.util.function.Supplier<ImmutableList<T>> tail)
```
 - narrowK
```
static <T> LazySeq<T> narrowK(Higher<DataWitness.lazySeq,T> list)
```
 - widen2
```
static <C2,T> Higher<C2,Higher<DataWitness.lazySeq,T>> widen2(Higher<C2,LazySeq<T>> list)
```
 - onEmptySwitch
```
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 ImmutableList<T>
 
 Specified by:
 
 onEmptySwitch in interface OnEmptySwitch<ImmutableList<T>,ImmutableList<T>>
 
 Parameters:
 
 supplier - to create replacement container
 
 Returns:
 
 Either this container or if zero, an alternative returned by the provided supplier
 - forEach4
```
default <R1,R2,R3,R> LazySeq<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
```
default <R1,R2,R3,R> LazySeq<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
```
default <R1,R2,R> LazySeq<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
```
default <R1,R2,R> LazySeq<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
```
default <R1,R> LazySeq<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
```
default <R1,R> LazySeq<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>
 - cons
```
static <T> LazySeq<T> cons(T head,
 java.util.function.Supplier<LazySeq<T>> tail)
```
 - lazyFoldRight
```
<R> R lazyFoldRight(R zero,
 java.util.function.BiFunction<? super T,java.util.function.Supplier<R>,? extends R> f)
```
 - widen
```
static <T> Higher<DataWitness.lazySeq,T> widen(LazySeq<T> narrow)
```

Interface LazySeq<T>

Nested Class Summary

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

Method Summary

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

Method Detail

collector

unitIterable

headOrElse

headOrElseGet

tailOrElse

tailOrElseGet

containsValue

narrow

tailRec

fill

fill

unfold

iterate

iterate

iterate

deferred

unzip

generate

generate

generate

range

range

rangeLong

rangeLong

removeAll

unitStream

stream

linkedSeq

append

removeAll

plusAll

insertAt

updateAt

removeAt

insertAt

removeValue

enums

enums

enumsFromTo

enums

fromIterable

fromIterator

fromStream

of

empty

span

splitBy

split

take

takeWhile

dropWhile

drop

reverse

duplicate

unzip

emptyUnit

replaceFirst

get

getOrElse

getOrElseGet

removeFirst

plus

prependAll

append

iterator

map