LazyDequeX (cyclops-reactor 8.4.2 API)

java.lang.Object
- com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX<T>
- - com.aol.cyclops.reactor.collections.extensions.standard.LazyDequeX<T>

Type Parameters:

T - the type of elements held in this collection

All Implemented Interfaces:

CollectionX<T>, FluentCollectionX<T>, DequeX<T>, MutableCollectionX<T>, LazyFluentCollectionX<T>, ReactorConvertable<T>, ZippingApplicativable<T>, ExtendedTraversable<T>, Filterable<T>, Foldable<T>, Functor<T>, IterableFilterable<T>, IterableFoldable<T>, IterableFunctor<T>, OnEmpty<T>, OnEmptySwitch<T,java.util.Deque<T>>, Sequential<T>, ConvertableSequence<T>, CyclopsCollectable<T>, To<DequeX<T>>, TransformerTraversable<T>, Traversable<T>, Unit<T>, Zippable<T>, java.lang.Iterable<T>, java.util.Collection<T>, java.util.Deque<T>, java.util.Queue<T>, org.jooq.lambda.Collectable<T>, org.reactivestreams.Publisher<T>
```
public class LazyDequeX<T>
extends AbstractFluentCollectionX<T>
implements DequeX<T>
```
An extended Deque type Deque Extended Deque operations execute lazily e.g.
```
 
 LazyDequeX<Integer> q = LazyDequeX.of(1,2,3)
 .map(i->i*2);
 
 
```
The map operation above is not executed immediately. It will only be executed when (if) the data inside the queue is accessed. This allows lazy operations to be chained and executed more efficiently e.g.
```
 
 LazyDequeX<Integer> q = LazyDequeX.of(1,2,3)
 .map(i->i*2);
 .filter(i->i<5);
 
 
```
The operation above is more efficient than the equivalent operation with a DequeX.

Nested Class Summary
- Nested classes/interfaces inherited from class com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX
 AbstractFluentCollectionX.LazyCollection<T,C extends java.util.Collection<T>>, AbstractFluentCollectionX.PersistentLazyCollection<T,C extends java.util.Collection<T>>

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`add(T e)`
`boolean`	`addAll(java.util.Collection<? extends T> c)`
`void`	`addFirst(T e)`
`void`	`addLast(T e)`
`<U> LazyDequeX<U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`void`	`clear()`
`<R,A> R`	`collect(java.util.stream.Collector<? super T,A,R> collector)`
`LazyDequeX<ReactiveSeq<T>>`	`combinations()` Generate the combinations based on values in the ExtendedTraversable.
`LazyDequeX<ReactiveSeq<T>>`	`combinations(int size)` Generate the combinations based on values in the ExtendedTraversable.
`LazyDequeX<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.
`boolean`	`contains(java.lang.Object e)`
`boolean`	`containsAll(java.util.Collection<?> c)`
`long`	`count()`
`LazyDequeX<T>`	`cycle(int times)` Convert to a Stream with the values repeated specified times
`LazyDequeX<T>`	`cycle(Monoid<T> m, int times)` Convert to a Stream with the result of a reduction operation repeated specified times
`LazyDequeX<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream until specified predicate holds
`LazyDequeX<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream while specified predicate holds
`java.util.Iterator<T>`	`descendingIterator()`
`LazyDequeX<T>`	`distinct()`
`LazyDequeX<T>`	`dropRight(int num)` Generate a new Traversable that drops the specified number elements from the end of this Traversable
`LazyDequeX<T>`	`dropUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that drops elements from this Traversable until the predicate holds
`LazyDequeX<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
`T`	`element()`
`static <T> LazyDequeX<T>`	`empty()`
`boolean`	`equals(java.lang.Object o)`
`LazyDequeX<T>`	`filter(java.util.function.Predicate<? super T> pred)` Keep only elements for which the supplied predicates hold e.g.
`LazyDequeX<T>`	`filterNot(java.util.function.Predicate<? super T> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<R> LazyDequeX<R>`	`flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)` Perform a flatMap operation on this collection.
`reactor.core.publisher.Flux<T>`	`flux()` Convert this type to a Reactor Flux
`void`	`forEach(java.util.function.Consumer<? super T> action)`
`<T1> LazyDequeX<T1>`	`from(java.util.Collection<T1> c)` Conctruct an Extended Collection from a standard Collection
`static <T> LazyDequeX<T>`	`fromIterable(java.util.stream.Collector<T,?,java.util.Deque<T>> collector, java.lang.Iterable<T> it)` Construct a LazyListX from an Iterable, using the specified Collector.
`static <T> LazyDequeX<T>`	`fromIterable(java.lang.Iterable<T> it)` Construct LazyListX from an Iterable
`static <T> LazyDequeX<T>`	`fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)` Construct a LazyListX from an Publisher
`<X> LazyDequeX<X>`	`fromStream(java.util.stream.Stream<X> stream)`
`static <T> LazyDequeX<T>`	`fromStreamS(java.util.stream.Stream<T> stream)` Create a LazyDequeX from a Stream
`static <T> LazyDequeX<T>`	`generate(long limit, java.util.function.Supplier<T> s)` Generate a LazyListX from the provided Supplier up to the provided limit number of times
`T`	`getFirst()`
`T`	`getLast()`
`<K> LazyDequeX<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>>`	`grouped(java.util.function.Function<? super T,? extends K> classifier)` Group this Traversable by the provided classifying function and collected by the provided Collector
`<K,A,D> LazyDequeX<org.jooq.lambda.tuple.Tuple2<K,D>>`	`grouped(java.util.function.Function<? super T,? extends K> classifier, java.util.stream.Collector<? super T,A,D> downstream)` Group this Traversable by the provided classifying function and collected by the provided Collector
`LazyDequeX<ListX<T>>`	`grouped(int groupSize)` Group elements in a Stream
`<C extends java.util.Collection<? super T>> LazyDequeX<C>`	`grouped(int size, java.util.function.Supplier<C> supplier)` Batch elements in a Stream by size into a collection created by the supplied factory
`LazyDequeX<ListX<T>>`	`groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)` Create Travesable of Lists where each List is populated while the supplied bipredicate holds.
`LazyDequeX<ListX<T>>`	`groupedUntil(java.util.function.Predicate<? super T> predicate)` Create a Traversable batched by List, where each batch is populated until the predicate holds
`<C extends java.util.Collection<? super T>> LazyDequeX<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
`LazyDequeX<ListX<T>>`	`groupedWhile(java.util.function.Predicate<? super T> predicate)` Create a Traversable batched by List, where each batch is populated while the predicate holds
`<C extends java.util.Collection<? super T>> LazyDequeX<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()`
`LazyDequeX<T>`	`intersperse(T value)` Returns a stream with a given value interspersed between any two values of this stream.
`boolean`	`isEmpty()`
`static <T> LazyDequeX<T>`	`iterate(long limit, T seed, java.util.function.UnaryOperator<T> f)` Create a LazyListX by iterative application of a function to an initial element up to the supplied limit number of times
`java.util.Iterator<T>`	`iterator()`
`LazyDequeX<T>`	`limit(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`LazyDequeX<T>`	`limitLast(int num)` Limit results to the last x elements in a SequenceM
`LazyDequeX<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.
`LazyDequeX<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
`<R> LazyDequeX<R>`	`map(java.util.function.Function<? super T,? extends R> mapper)` Transform this functor using the supplied transformation function
`LazyDequeX<T>`	`materialize()`
`LazyDequeX<T>`	`minus(java.lang.Object e)` Remove the specified element from this collection
`LazyDequeX<T>`	`minusAll(java.util.Collection<?> list)` Remove all the specified elements from this collection
`LazyDequeX<T>`	`minusAllLazy(java.util.Collection<?> list)` Lazily remove the elements in the supplied Collection from this Collection.
`LazyDequeX<T>`	`minusLazy(java.lang.Object e)` Lazily remove an element from this Collection.
`LazyDequeX<T>`	`notNull()` Filter elements retaining only values which are not null
`static <T> LazyDequeX<T>`	`of(T... values)` Create a LazyListX from the specified values
`boolean`	`offer(T e)`
`boolean`	`offerFirst(T e)`
`boolean`	`offerLast(T e)`
`<U> LazyDequeX<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`LazyDequeX<T>`	`onEmpty(T value)` If this Container instance is empty, create a new instance containing the provided value
`LazyDequeX<T>`	`onEmptyGet(java.util.function.Supplier<? extends T> supplier)` If this Container instance is empty, create a new instance containing the value returned from the provided Supplier
`LazyDequeX<T>`	`onEmptySwitch(java.util.function.Supplier<? extends java.util.Deque<T>> supplier)` Switch to container created by provided Supplier, if current Container empty
`<X extends java.lang.Throwable> LazyDequeX<T>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)` If this container instance is empty, throw the exception returned by the provided Supplier
`java.util.stream.Stream<T>`	`parallelStream()`
`<R> LazyDequeX<R>`	`patternMatch(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,R>> case1, java.util.function.Supplier<? extends R> otherwise)` Transform the elements of this Stream with a Pattern Matching case and default value
`T`	`peek()`
`LazyDequeX<T>`	`peek(java.util.function.Consumer<? super T> c)` Peek at the current value of this Functor, without transforming it
`T`	`peekFirst()`
`T`	`peekLast()`
`LazyDequeX<ReactiveSeq<T>>`	`permutations()` Generate the permutations based on values in the ExtendedTraversable.
`LazyDequeX<T>`	`plus(T e)` Add an element to this Collection
`LazyDequeX<T>`	`plusAll(java.util.Collection<? extends T> list)` Add all supplied elements to this Collection
`LazyDequeX<T>`	`plusAllLazy(java.util.Collection<? extends T> list)` Lazily add all the elements in the supplied Collection to this Collection.
`LazyDequeX<T>`	`plusInOrder(T e)` Add an element to the collection
`LazyDequeX<T>`	`plusLazy(T e)` Lazily add an element to this Collection.
`LazyDequeX<T>`	`plusLoop(int max, java.util.function.IntFunction<T> value)`
`LazyDequeX<T>`	`plusLoop(java.util.function.Supplier<java.util.Optional<T>> supplier)`
`T`	`poll()`
`T`	`pollFirst()`
`T`	`pollLast()`
`T`	`pop()`
`void`	`push(T e)`
`static LazyDequeX<java.lang.Integer>`	`range(int start, int end)` Create a LazyListX that contains the Integers between start and end
`static LazyDequeX<java.lang.Long>`	`rangeLong(long start, long end)` Create a LazyListX that contains the Longs between start and end
`T`	`remove()`
`boolean`	`remove(java.lang.Object o)`
`boolean`	`removeAll(java.util.Collection<?> c)`
`LazyDequeX<T>`	`removeAll(java.lang.Iterable<? extends T> it)` Remove all elements in the supplied Iterable from this filterable
`LazyDequeX<T>`	`removeAll(org.jooq.lambda.Seq<? extends T> stream)` Remove all elements from this collection that match the values in the provided Seq
`LazyDequeX<T>`	`removeAll(java.util.stream.Stream<? extends T> stream)` Remove all elements in the supplied Stream from this filterable
`LazyDequeX<T>`	`removeAll(T... values)` Remove all supplied elements from this filterable
`T`	`removeFirst()`
`boolean`	`removeFirstOccurrence(java.lang.Object o)`
`boolean`	`removeIf(java.util.function.Predicate<? super T> filter)`
`T`	`removeLast()`
`boolean`	`removeLastOccurrence(java.lang.Object o)`
`boolean`	`retainAll(java.util.Collection<?> c)`
`LazyDequeX<T>`	`retainAll(java.lang.Iterable<? extends T> it)` Retain only the supplied elements in the returned Filterable
`LazyDequeX<T>`	`retainAll(org.jooq.lambda.Seq<? extends T> stream)` Retain all elements from this collection that match the values in the provided Seq
`LazyDequeX<T>`	`retainAll(java.util.stream.Stream<? extends T> stream)` Retain only the supplied elements in the returned Filterable
`LazyDequeX<T>`	`retainAll(T... values)` Retain only the supplied elements in the returned Filterable
`LazyDequeX<T>`	`reverse()` Potentially efficient Stream reversal.
`LazyDequeX<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`<U> LazyDequeX<U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)` Scan left
`LazyDequeX<T>`	`scanRight(Monoid<T> monoid)` Scan right
`<U> LazyDequeX<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)` Scan right
`LazyDequeX<T>`	`shuffle()`
`LazyDequeX<T>`	`shuffle(java.util.Random random)`
`static <T> LazyDequeX<T>`	`singleton(T value)` Construct a LazyListX with a single value
`int`	`size()`
`LazyDequeX<T>`	`skip(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`LazyDequeX<T>`	`skipLast(int num)` assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
`LazyDequeX<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
`LazyDequeX<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 *
`LazyDequeX<T>`	`slice(long from, long to)`
`LazyDequeX<ListX<T>>`	`sliding(int windowSize)` Create a sliding view over this Sequence
`LazyDequeX<ListX<T>>`	`sliding(int windowSize, int increment)` Create a sliding view over this Sequence
`LazyDequeX<T>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`LazyDequeX<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>> LazyDequeX<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`java.util.Spliterator<T>`	`spliterator()`
`ReactiveSeq<T>`	`stream()`
`<X> LazyDequeX<X>`	`stream(reactor.core.publisher.Flux<X> stream)` Create a LazyFluentCollection from a Flux.
`LazyDequeX<T>`	`takeRight(int num)` Generate a new Traversable that takes the specified number elements from the end of this Traversable
`LazyDequeX<T>`	`takeUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that takes elements from this Traversable until the predicate holds
`LazyDequeX<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.Object[]`	`toArray()`
`<T> T[]`	`toArray(T[] a)`
`java.lang.String`	`toString()`
`<R> LazyDequeX<R>`	`trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)` Performs a map operation that can call a recursive method without running out of stack space
`<R> LazyDequeX<R>`	`unit(java.util.Collection<R> col)` Create a new instance of the same colleciton type from the supplied collection
`<R> LazyDequeX<R>`	`unit(R value)`
`<R> LazyDequeX<R>`	`unitIterator(java.util.Iterator<R> it)` Create an IterableFunctor instance of the same type from an Iterator
`LazyDequeX<T>`	`with(int i, T element)` ListX methods
`<T2,R> LazyDequeX<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> LazyDequeX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.lang.Iterable<? extends U> other)` Zip (merge) this collection with the supplied Iterable into a Colleciton containing Tuples Each Tuple contains one element from this collection and one from the other
`<U,R> LazyDequeX<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
`<U> LazyDequeX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(org.jooq.lambda.Seq<? extends U> other)` Zip (combine) this Zippable with the supplied Seq combining both into a Tuple2
`<U,R> LazyDequeX<R>`	`zip(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Seq, using the supplied combining function
`<U> LazyDequeX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.util.stream.Stream<? extends U> other)` Zip 2 streams into one
`<U,R> LazyDequeX<R>`	`zip(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
`<S,U> LazyDequeX<org.jooq.lambda.tuple.Tuple3<T,S,U>>`	`zip3(java.util.stream.Stream<? extends S> second, java.util.stream.Stream<? extends U> third)` zip 3 Streams into one
`<T2,T3,T4> LazyDequeX<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>`	`zip4(java.util.stream.Stream<? extends T2> second, java.util.stream.Stream<? extends T3> third, java.util.stream.Stream<? extends T4> fourth)` zip 4 Streams into 1
`LazyDequeX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>`	`zipWithIndex()` Add an index to the current Stream

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

Methods inherited from interface com.aol.cyclops.data.collections.extensions.standard.DequeX
coflatMap, defaultCollector, drop, fill, forEach2, forEach2, forEach3, forEach3, forEach4, forEach4, getCollector, narrow, take, toDequeX, withCollector

Methods inherited from interface com.aol.cyclops.types.To
to

Methods inherited from interface com.aol.cyclops.data.collections.extensions.standard.MutableCollectionX
reduce

Methods inherited from interface com.aol.cyclops.data.collections.extensions.CollectionX
collectable, findAny, findFirst, fromCollection, getAtIndex, groupBy, head, headAndTail, single, single, singleOptional

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

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

Methods inherited from interface com.aol.cyclops.types.IterableFoldable
foldable, visit

Methods inherited from interface com.aol.cyclops.types.applicative.zipping.ZippingApplicativable
ap1, ap2, ap3, ap4, ap5, applicatives

Methods inherited from interface com.aol.cyclops.types.IterableFunctor
flatMapPublisher, flatMapPublisher, flatMapPublisher, mergePublisher, mergePublisher

Methods inherited from interface com.aol.cyclops.types.Foldable
endsWith, endsWithIterable, firstValue, foldRight, foldRight, foldRight, foldRightMapToType, get, join, join, join, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, startsWith, startsWithIterable, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, validate, xMatch

Methods inherited from interface com.aol.cyclops.types.Traversable
futureOperations, lazyOperations, subscribe, traversable

Methods inherited from interface com.aol.cyclops.types.stream.ConvertableSequence
seq, toCompletableFuture, toEvalAlways, toEvalLater, toEvalNow, toFutureStream, toFutureStream, toFutureW, toIor, toIorSecondary, toListX, toMapX, toMaybe, toOptional, toPBagX, toPMapX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toStreamable, toTry, toValue, toValueMap, toValueSet, toXor, toXorSecondary

Methods inherited from interface com.aol.cyclops.types.stream.CyclopsCollectable
allMatch, anyMatch, avg, avg, avgDouble, avgInt, avgLong, bitAnd, bitAnd, bitAndInt, bitAndLong, bitOr, bitOr, bitOrInt, bitOrLong, commonPrefix, commonSuffix, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, foldFuture, foldLazy, foldTry, max, max, max, max, maxAll, maxAll, maxAll, maxAll, maxAllBy, maxAllBy, maxBy, maxBy, median, median, medianBy, medianBy, min, min, min, min, minAll, minAll, minAll, minAll, minAllBy, minAllBy, minBy, minBy, mode, modeAll, modeAllBy, modeBy, noneMatch, percentile, percentile, percentileBy, percentileBy, sum, sum, sumDouble, sumInt, sumLong, toCollection, toList, toList, toMap, toMap, toSet, toSet, toString, toString

Methods inherited from interface org.jooq.lambda.Collectable
collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect

Methods inherited from interface com.aol.cyclops.reactor.types.ReactorConvertable
mono

- Method Detail
 - plusLoop
```
public LazyDequeX<T> plusLoop(int max,
 java.util.function.IntFunction<T> value)
```
 Specified by:
 
 plusLoop in interface LazyFluentCollectionX<T>
 - plusLoop
```
public LazyDequeX<T> plusLoop(java.util.function.Supplier<java.util.Optional<T>> supplier)
```
 Specified by:
 
 plusLoop in interface LazyFluentCollectionX<T>
 - fromStreamS
```
public static <T> LazyDequeX<T> fromStreamS(java.util.stream.Stream<T> stream)
```
 Create a LazyDequeX from a Stream
 
 Parameters:
 
 stream - to construct a LazyQueueX from
 
 Returns:
 
 LazyDequeX
 - range
```
public static LazyDequeX<java.lang.Integer> range(int start,
 int end)
```
 Create a LazyListX that contains the Integers between start and end
 
 Specified by:
 
 range in interface DequeX<T>
 
 Parameters:
 
 start - Number of range to start from
 
 end - Number for range to end at
 
 Returns:
 
 Range ListX
 - rangeLong
```
public static LazyDequeX<java.lang.Long> rangeLong(long start,
 long end)
```
 Create a LazyListX that contains the Longs between start and end
 
 Specified by:
 
 rangeLong in interface DequeX<T>
 
 Parameters:
 
 start - Number of range to start from
 
 end - Number for range to end at
 
 Returns:
 
 Range ListX
 - generate
```
public static <T> LazyDequeX<T> generate(long limit,
 java.util.function.Supplier<T> s)
```
 Generate a LazyListX from the provided Supplier up to the provided limit number of times
 
 Specified by:
 
 generate in interface DequeX<T>
 
 Parameters:
 
 limit - Max number of elements to generate
 
 s - Supplier to generate ListX elements
 
 Returns:
 
 ListX generated from the provided Supplier
 - iterate
```
public static <T> LazyDequeX<T> iterate(long limit,
 T seed,
 java.util.function.UnaryOperator<T> f)
```
 Create a LazyListX by iterative application of a function to an initial element up to the supplied limit number of times
 
 Specified by:
 
 iterate in interface DequeX<T>
 
 Parameters:
 
 limit - Max number of elements to generate
 
 seed - Initial element
 
 f - Iteratively applied to each element to generate the next element
 
 Returns:
 
 ListX generated by iterative application
 - empty
```
public static <T> LazyDequeX<T> empty()
```
 Specified by:
 
 empty in interface DequeX<T>
 
 Returns:
 
 An empty LazyListX
 - of
```
@SafeVarargs
public static <T> LazyDequeX<T> of(T... values)
```
 Create a LazyListX from the specified values
```
 
 ListX<Integer> lazy = LazyListX.of(1,2,3,4,5);
 
 //lazily map List
 ListX<String> mapped = lazy.map(i->"mapped " +i); 
 
 String value = mapped.get(0); //transformation triggered now
 
 
```
 Specified by:
 
 of in interface DequeX<T>
 
 Parameters:
 
 values - To populate LazyListX with
 
 Returns:
 
 LazyListX
 - singleton
```
public static <T> LazyDequeX<T> singleton(T value)
```
 Construct a LazyListX with a single value
```
 
 ListX<Integer> lazy = LazyListX.singleton(5);
 
 
 
```
 Specified by:
 
 singleton in interface DequeX<T>
 
 Parameters:
 
 value - To populate LazyListX with
 
 Returns:
 
 LazyListX with a single value
 - fromPublisher
```
public static <T> LazyDequeX<T> fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)
```
 Construct a LazyListX from an Publisher
 
 Specified by:
 
 fromPublisher in interface DequeX<T>
 
 Parameters:
 
 publisher - to construct LazyListX from
 
 Returns:
 
 ListX
 - fromIterable
```
public static <T> LazyDequeX<T> fromIterable(java.lang.Iterable<T> it)
```
 Construct LazyListX from an Iterable
 
 Specified by:
 
 fromIterable in interface DequeX<T>
 
 Parameters:
 
 it - to construct LazyListX from
 
 Returns:
 
 LazyListX from Iterable
 - fromIterable
```
public static <T> LazyDequeX<T> fromIterable(java.util.stream.Collector<T,?,java.util.Deque<T>> collector,
 java.lang.Iterable<T> it)
```
 Construct a LazyListX from an Iterable, using the specified Collector.
 
 Specified by:
 
 fromIterable in interface DequeX<T>
 
 Parameters:
 
 collector - To generate Lists from, this can be used to create mutable vs immutable Lists (for example), or control List type (ArrayList, LinkedList)
 
 it - Iterable to construct LazyListX from
 
 Returns:
 
 Newly constructed LazyListX
 - forEach
```
public void forEach(java.util.function.Consumer<? super T> action)
```
 Specified by:
 
 forEach in interface java.lang.Iterable<T>
 - iterator
```
public java.util.Iterator<T> iterator()
```
 Specified by:
 
 iterator in interface java.lang.Iterable<T>
 
 Specified by:
 
 iterator in interface java.util.Collection<T>
 
 Specified by:
 
 iterator in interface java.util.Deque<T>
 - size
```
public int size()
```
 Specified by:
 
 size in interface java.util.Collection<T>
 
 Specified by:
 
 size in interface java.util.Deque<T>
 - contains
```
public boolean contains(java.lang.Object e)
```
 Specified by:
 
 contains in interface java.util.Collection<T>
 
 Specified by:
 
 contains in interface java.util.Deque<T>
 - equals
```
public boolean equals(java.lang.Object o)
```
 Specified by:
 
 equals in interface java.util.Collection<T>
 
 Overrides:
 
 equals in class java.lang.Object
 - isEmpty
```
public boolean isEmpty()
```
 Specified by:
 
 isEmpty in interface java.util.Collection<T>
 - hashCode
```
public int hashCode()
```
 Specified by:
 
 hashCode in interface java.util.Collection<T>
 
 Overrides:
 
 hashCode in class java.lang.Object
 - toArray
```
public java.lang.Object[] toArray()
```
 Specified by:
 
 toArray in interface java.util.Collection<T>
 - removeAll
```
public boolean removeAll(java.util.Collection<?> c)
```
 Specified by:
 
 removeAll in interface java.util.Collection<T>
 - toArray
```
public <T> T[] toArray(T[] a)
```
 Specified by:
 
 toArray in interface java.util.Collection<T>
 - add
```
public boolean add(T e)
```
 Specified by:
 
 add in interface java.util.Collection<T>
 
 Specified by:
 
 add in interface java.util.Deque<T>
 
 Specified by:
 
 add in interface java.util.Queue<T>
 - remove
```
public boolean remove(java.lang.Object o)
```
 Specified by:
 
 remove in interface java.util.Collection<T>
 
 Specified by:
 
 remove in interface java.util.Deque<T>
 - containsAll
```
public boolean containsAll(java.util.Collection<?> c)
```
 Specified by:
 
 containsAll in interface java.util.Collection<T>
 - addAll
```
public boolean addAll(java.util.Collection<? extends T> c)
```
 Specified by:
 
 addAll in interface java.util.Collection<T>
 - retainAll
```
public boolean retainAll(java.util.Collection<?> c)
```
 Specified by:
 
 retainAll in interface java.util.Collection<T>
 - clear
```
public void clear()
```
 Specified by:
 
 clear in interface java.util.Collection<T>
 - toString
```
public java.lang.String toString()
```
 Overrides:
 
 toString in class java.lang.Object
 - collect
```
public <R,A> R collect(java.util.stream.Collector<? super T,A,R> collector)
```
 Specified by:
 
 collect in interface CyclopsCollectable<T>
 
 Specified by:
 
 collect in interface org.jooq.lambda.Collectable<T>
 - count
```
public long count()
```
 Specified by:
 
 count in interface CyclopsCollectable<T>
 
 Specified by:
 
 count in interface org.jooq.lambda.Collectable<T>
 - removeIf
```
public boolean removeIf(java.util.function.Predicate<? super T> filter)
```
 Specified by:
 
 removeIf in interface java.util.Collection<T>
 - parallelStream
```
public java.util.stream.Stream<T> parallelStream()
```
 Specified by:
 
 parallelStream in interface java.util.Collection<T>
 - spliterator
```
public java.util.Spliterator<T> spliterator()
```
 Specified by:
 
 spliterator in interface java.lang.Iterable<T>
 
 Specified by:
 
 spliterator in interface java.util.Collection<T>
 - stream
```
public <X> LazyDequeX<X> stream(reactor.core.publisher.Flux<X> stream)
```
 Description copied from interface: LazyFluentCollectionX
 Create a LazyFluentCollection from a Flux. The created LazyFluentCollection will be of the same type as the object this method is called on. i.e. Calling stream(Flux) on a LazyListX results in a LazyListX
```
 
 
 LazyListX<Integer> lazyInts = LazyListX.of(1,2,3);
 LazyListX<String> lazyStrs = lazyInts.stream(Flux.just("hello","world"));
 
 
 
```
 Calling stream(Flux) on a LazySetX results in a LazySetX etc. The same collection / reduction method will be used in the newly created Object. I.e. Calling stream(Flux) on a collection which as an Immutable Collector will result in an Immutable Collection.
 Specified by:
 
 stream in interface LazyFluentCollectionX<T>
 
 Specified by:
 
 stream in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 stream - Flux to create new collection from
 
 Returns:
 
 New collection from Flux
 - stream
```
public ReactiveSeq<T> stream()
```
 Specified by:
 
 stream in interface CollectionX<T>
 
 Specified by:
 
 stream in interface DequeX<T>
 
 Specified by:
 
 stream in interface ExtendedTraversable<T>
 
 Specified by:
 
 stream in interface Foldable<T>
 
 Specified by:
 
 stream in interface IterableFunctor<T>
 
 Specified by:
 
 stream in interface Sequential<T>
 
 Specified by:
 
 stream in interface ConvertableSequence<T>
 
 Specified by:
 
 stream in interface TransformerTraversable<T>
 
 Specified by:
 
 stream in interface Traversable<T>
 
 Specified by:
 
 stream in interface java.util.Collection<T>
 
 Returns:
 
 This Traversable converted to a Stream
 - flux
```
public reactor.core.publisher.Flux<T> flux()
```
 Description copied from interface: ReactorConvertable
 
 Convert this type to a Reactor Flux
 
 Specified by:
 
 flux in interface ReactorConvertable<T>
 
 Specified by:
 
 flux in class AbstractFluentCollectionX<T>
 
 Returns:
 
 Reactor Flux
 - combine
```
public LazyDequeX<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 output of a combination may in turn be combined with it's neighbour
```
 
 ReactiveSeq.of(1,1,2,3)
 .combine((a, b)->a.equals(b),Semigroups.intSum)
 .toListX()
 
 //ListX(3,4) 
 
```
 Specified by:
 
 combine in interface CollectionX<T>
 
 Specified by:
 
 combine in interface DequeX<T>
 
 Specified by:
 
 combine in interface MutableCollectionX<T>
 
 Specified by:
 
 combine in interface Traversable<T>
 
 Overrides:
 
 combine in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 predicate - Test to see if two neighbours should be joined
 
 op - Reducer to combine neighbours
 
 Returns:
 
 Combined / Partially Reduced Traversable
 - reverse
```
public LazyDequeX<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 CollectionX<T>
 
 Specified by:
 
 reverse in interface DequeX<T>
 
 Specified by:
 
 reverse in interface MutableCollectionX<T>
 
 Specified by:
 
 reverse in interface Traversable<T>
 
 Overrides:
 
 reverse in class AbstractFluentCollectionX<T>
 - filter
```
public LazyDequeX<T> filter(java.util.function.Predicate<? super T> pred)
```
 Description copied from interface: Filterable
 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 CollectionX<T>
 
 Specified by:
 
 filter in interface DequeX<T>
 
 Specified by:
 
 filter in interface MutableCollectionX<T>
 
 Specified by:
 
 filter in interface Filterable<T>
 
 Overrides:
 
 filter in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 pred - to filter elements by, retaining matches
 
 Returns:
 
 Filterable with elements removed where the predicate does not hold
 - map
```
public <R> LazyDequeX<R> map(java.util.function.Function<? super T,? extends R> mapper)
```
 Description copied from interface: Functor
 Transform this functor using the supplied transformation function
```
 
 
 
 of(1,2,3).map(i->i*2)
 
 //[2,4,6]
 
 
 
```
 Specified by:
 
 map in interface CollectionX<T>
 
 Specified by:
 
 map in interface DequeX<T>
 
 Specified by:
 
 map in interface MutableCollectionX<T>
 
 Specified by:
 
 map in interface Functor<T>
 
 Specified by:
 
 map in interface IterableFunctor<T>
 
 Overrides:
 
 map in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 mapper - Transformation function
 
 Returns:
 
 Transformed Functor
 - flatMap
```
public <R> LazyDequeX<R> flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
```
 Description copied from interface: CollectionX
 
 Perform a flatMap operation on this collection. Results from the returned Iterables (from the provided transformation function) are flattened into the resulting collection.
 
 Specified by:
 
 flatMap in interface CollectionX<T>
 
 Specified by:
 
 flatMap in interface DequeX<T>
 
 Specified by:
 
 flatMap in interface MutableCollectionX<T>
 
 Overrides:
 
 flatMap in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 mapper - Transformation function to be applied (and flattened)
 
 Returns:
 
 A collection containing the flattened results of the transformation function
 - limit
```
public LazyDequeX<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 CollectionX<T>
 
 Specified by:
 
 limit in interface DequeX<T>
 
 Specified by:
 
 limit in interface MutableCollectionX<T>
 
 Specified by:
 
 limit in interface Traversable<T>
 
 Overrides:
 
 limit in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 num - Limit element size to num
 
 Returns:
 
 Monad converted to Stream with elements up to num
 - skip
```
public LazyDequeX<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 CollectionX<T>
 
 Specified by:
 
 skip in interface DequeX<T>
 
 Specified by:
 
 skip in interface MutableCollectionX<T>
 
 Specified by:
 
 skip in interface Traversable<T>
 
 Overrides:
 
 skip in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 num - Number of elemenets to skip
 
 Returns:
 
 Stream with specified number of elements skipped
 - takeRight
```
public LazyDequeX<T> takeRight(int num)
```
 Description copied from interface: Traversable
 Generate a new Traversable that takes the specified number elements from the end of this Traversable
```
 
 ListX.of(1,2,3).takeRight(2);
 //[2,3]
 
 
```
 Specified by:
 
 takeRight in interface CollectionX<T>
 
 Specified by:
 
 takeRight in interface DequeX<T>
 
 Specified by:
 
 takeRight in interface MutableCollectionX<T>
 
 Specified by:
 
 takeRight in interface Traversable<T>
 
 Overrides:
 
 takeRight in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 num - Take this number of elements from the end of this Traversable
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - dropRight
```
public LazyDequeX<T> dropRight(int num)
```
 Description copied from interface: Traversable
 Generate a new Traversable that drops the specified number elements from the end of this Traversable
```
 
 ListX.of(1,2,3).dropRight(2);
 //[1]
 
 
```
 Specified by:
 
 dropRight in interface CollectionX<T>
 
 Specified by:
 
 dropRight in interface DequeX<T>
 
 Specified by:
 
 dropRight in interface MutableCollectionX<T>
 
 Specified by:
 
 dropRight in interface Traversable<T>
 
 Overrides:
 
 dropRight in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 num - Drop this number of elements from the end of this Traversable
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - takeWhile
```
public LazyDequeX<T> takeWhile(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that takes elements from this Traversable as long as the predicate holds
```
 
 ListX.of(1,2,3).takeWhile(i<3);
 //[1,2]
 
 
```
 Specified by:
 
 takeWhile in interface CollectionX<T>
 
 Specified by:
 
 takeWhile in interface DequeX<T>
 
 Specified by:
 
 takeWhile in interface MutableCollectionX<T>
 
 Specified by:
 
 takeWhile in interface Traversable<T>
 
 Overrides:
 
 takeWhile in class AbstractFluentCollectionX<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 LazyDequeX<T> dropWhile(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that drops elements from this Traversable as long as the predicate holds
```
 
 ListX.of(1,2,3).dropWhile(i<3);
 //[3]
 
 
```
 Specified by:
 
 dropWhile in interface CollectionX<T>
 
 Specified by:
 
 dropWhile in interface DequeX<T>
 
 Specified by:
 
 dropWhile in interface MutableCollectionX<T>
 
 Specified by:
 
 dropWhile in interface Traversable<T>
 
 Overrides:
 
 dropWhile in class AbstractFluentCollectionX<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 LazyDequeX<T> takeUntil(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that takes elements from this Traversable until the predicate holds
```
 
 ListX.of(1,2,3).takeUntil(i<2);
 //[1,2]
 
 
```
 Specified by:
 
 takeUntil in interface CollectionX<T>
 
 Specified by:
 
 takeUntil in interface DequeX<T>
 
 Specified by:
 
 takeUntil in interface MutableCollectionX<T>
 
 Specified by:
 
 takeUntil in interface Traversable<T>
 
 Overrides:
 
 takeUntil in class AbstractFluentCollectionX<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 LazyDequeX<T> dropUntil(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that drops elements from this Traversable until the predicate holds
```
 
 ListX.of(1,2,3).dropUntil(i>2);
 //[3]
 
 
```
 Specified by:
 
 dropUntil in interface CollectionX<T>
 
 Specified by:
 
 dropUntil in interface DequeX<T>
 
 Specified by:
 
 dropUntil in interface MutableCollectionX<T>
 
 Specified by:
 
 dropUntil in interface Traversable<T>
 
 Overrides:
 
 dropUntil in class AbstractFluentCollectionX<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
 - trampoline
```
public <R> LazyDequeX<R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)
```
 Description copied from interface: Functor
 Performs a map operation that can call a recursive method without running out of stack space
```
 
 ReactiveSeq.of(10,20,30,40)
 			 .trampoline(i-> fibonacci(i))
 			 .forEach(System.out::println); 
 			 
 	Trampoline<Long> fibonacci(int i){
 		return fibonacci(i,1,0);
 	}
 	Trampoline<Long> fibonacci(int n, long a, long b) {
 	return n == 0 ? Trampoline.done(b) : Trampoline.more( ()->fibonacci(n-1, a+b, a));
 	}		 
 			 
 55
 	6765
 	832040
 	102334155
 
 
 ReactiveSeq.of(10_000,200_000,3_000_000,40_000_000)
 			 .trampoline(i-> fibonacci(i))
 			 .forEach(System.out::println);
 			 
 			 
 completes successfully
 
 
```
 Specified by:
 
 trampoline in interface CollectionX<T>
 
 Specified by:
 
 trampoline in interface DequeX<T>
 
 Specified by:
 
 trampoline in interface MutableCollectionX<T>
 
 Specified by:
 
 trampoline in interface Functor<T>
 
 Overrides:
 
 trampoline in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 mapper - TCO Transformation function
 
 Returns:
 
 Functor transformed by the supplied transformation function
 - slice
```
public LazyDequeX<T> slice(long from,
 long to)
```
 Specified by:
 
 slice in interface CollectionX<T>
 
 Specified by:
 
 slice in interface DequeX<T>
 
 Specified by:
 
 slice in interface MutableCollectionX<T>
 
 Specified by:
 
 slice in interface Traversable<T>
 
 Overrides:
 
 slice in class AbstractFluentCollectionX<T>
 - grouped
```
public LazyDequeX<ListX<T>> grouped(int groupSize)
```
 Description copied from interface: Traversable
 Group elements in a Stream
```
 
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).grouped(3).collect(Collectors.toList());
 
 assertThat(list.get(0), hasItems(1, 2, 3));
 assertThat(list.get(1), hasItems(4, 5, 6));
 
 
 
```
 Specified by:
 
 grouped in interface CollectionX<T>
 
 Specified by:
 
 grouped in interface DequeX<T>
 
 Specified by:
 
 grouped in interface MutableCollectionX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Overrides:
 
 grouped in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 groupSize - Size of each Group
 
 Returns:
 
 Stream with elements grouped by size
 - grouped
```
public <K,A,D> LazyDequeX<org.jooq.lambda.tuple.Tuple2<K,D>> grouped(java.util.function.Function<? super T,? extends K> classifier,
 java.util.stream.Collector<? super T,A,D> downstream)
```
 Description copied from interface: Traversable
 
 Group this Traversable by the provided classifying function and collected by the provided Collector
 
 Specified by:
 
 grouped in interface CollectionX<T>
 
 Specified by:
 
 grouped in interface DequeX<T>
 
 Specified by:
 
 grouped in interface MutableCollectionX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Overrides:
 
 grouped in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 classifier - Grouping function
 
 downstream - Collector to create the grouping collection
 
 Returns:
 
 Traversable of grouped data
 - grouped
```
public <K> LazyDequeX<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)
```
 Description copied from interface: Traversable
 
 Group this Traversable by the provided classifying function and collected by the provided Collector
 
 Specified by:
 
 grouped in interface CollectionX<T>
 
 Specified by:
 
 grouped in interface DequeX<T>
 
 Specified by:
 
 grouped in interface MutableCollectionX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Overrides:
 
 grouped in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 classifier - Grouping function
 
 Returns:
 
 Traversable of grouped data
 - zip
```
public  LazyDequeX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
```
 Description copied from interface: CollectionX
 
 Zip (merge) this collection with the supplied Iterable into a Colleciton containing Tuples Each Tuple contains one element from this collection and one from the other
 
 Specified by:
 
 zip in interface CollectionX<T>
 
 Specified by:
 
 zip in interface DequeX<T>
 
 Specified by:
 
 zip in interface MutableCollectionX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Overrides:
 
 zip in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 other - Collection to merge with this one
 
 Returns:
 
 Merged collection
 - zip
```
public <U,R> LazyDequeX<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 CollectionX<T>
 
 Specified by:
 
 zip in interface DequeX<T>
 
 Specified by:
 
 zip in interface MutableCollectionX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Overrides:
 
 zip in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 other - to zip with
 
 zipper - Zip function
 
 Returns:
 
 Combined zippable
 - sliding
```
public LazyDequeX<ListX<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(Collectors.toList());
 
 assertThat(list.get(0), hasItems(1, 2));
 assertThat(list.get(1), hasItems(2, 3));
 
 
 
 
```
 Specified by:
 
 sliding in interface CollectionX<T>
 
 Specified by:
 
 sliding in interface DequeX<T>
 
 Specified by:
 
 sliding in interface MutableCollectionX<T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Overrides:
 
 sliding in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 windowSize - Size of sliding window
 
 Returns:
 
 SequenceM with sliding view
 - sliding
```
public LazyDequeX<ListX<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(Collectors.toList());
 
 assertThat(list.get(0), hasItems(1, 2, 3));
 assertThat(list.get(1), hasItems(3, 4, 5)); 
 
 
 
 
 
```
 Specified by:
 
 sliding in interface CollectionX<T>
 
 Specified by:
 
 sliding in interface DequeX<T>
 
 Specified by:
 
 sliding in interface MutableCollectionX<T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Overrides:
 
 sliding in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 windowSize - number of elements in each batch
 
 increment - for each window
 
 Returns:
 
 SequenceM with sliding view
 - scanLeft
```
public LazyDequeX<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 CollectionX<T>
 
 Specified by:
 
 scanLeft in interface DequeX<T>
 
 Specified by:
 
 scanLeft in interface MutableCollectionX<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 
 Overrides:
 
 scanLeft in class AbstractFluentCollectionX<T>
 
 Returns:
 - scanLeft
```
public  LazyDequeX 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 CollectionX<T>
 
 Specified by:
 
 scanLeft in interface DequeX<T>
 
 Specified by:
 
 scanLeft in interface MutableCollectionX<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 
 Overrides:
 
 scanLeft in class AbstractFluentCollectionX<T>
 - scanRight
```
public LazyDequeX<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 CollectionX<T>
 
 Specified by:
 
 scanRight in interface DequeX<T>
 
 Specified by:
 
 scanRight in interface MutableCollectionX<T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 
 Overrides:
 
 scanRight in class AbstractFluentCollectionX<T>
 - scanRight
```
public  LazyDequeX 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 CollectionX<T>
 
 Specified by:
 
 scanRight in interface DequeX<T>
 
 Specified by:
 
 scanRight in interface MutableCollectionX<T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 
 Overrides:
 
 scanRight in class AbstractFluentCollectionX<T>
 - sorted
```
public > LazyDequeX<T> sorted(java.util.function.Function<? super T,? extends U> function)
```
 Specified by:
 
 sorted in interface CollectionX<T>
 
 Specified by:
 
 sorted in interface DequeX<T>
 
 Specified by:
 
 sorted in interface MutableCollectionX<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 
 Overrides:
 
 sorted in class AbstractFluentCollectionX<T>
 - plus
```
public LazyDequeX<T> plus(T e)
```
 Description copied from interface: FluentCollectionX
 
 Add an element to this Collection
 
 Specified by:
 
 plus in interface FluentCollectionX<T>
 
 Specified by:
 
 plus in interface DequeX<T>
 
 Specified by:
 
 plus in interface MutableCollectionX<T>
 
 Specified by:
 
 plus in interface LazyFluentCollectionX<T>
 
 Overrides:
 
 plus in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 e - Element to add
 
 Returns:
 
 Collection with element added
 - plusAll
```
public LazyDequeX<T> plusAll(java.util.Collection<? extends T> list)
```
 Description copied from interface: FluentCollectionX
 
 Add all supplied elements to this Collection
 
 Specified by:
 
 plusAll in interface FluentCollectionX<T>
 
 Specified by:
 
 plusAll in interface DequeX<T>
 
 Specified by:
 
 plusAll in interface MutableCollectionX<T>
 
 Specified by:
 
 plusAll in interface LazyFluentCollectionX<T>
 
 Overrides:
 
 plusAll in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 list - of elements to add
 
 Returns:
 
 Collection with elements added
 - minus
```
public LazyDequeX<T> minus(java.lang.Object e)
```
 Description copied from interface: FluentCollectionX
 
 Remove the specified element from this collection
 
 Specified by:
 
 minus in interface FluentCollectionX<T>
 
 Specified by:
 
 minus in interface DequeX<T>
 
 Specified by:
 
 minus in interface MutableCollectionX<T>
 
 Specified by:
 
 minus in interface LazyFluentCollectionX<T>
 
 Overrides:
 
 minus in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 e - Element to remove
 
 Returns:
 
 Collection with element removed
 - minusAll
```
public LazyDequeX<T> minusAll(java.util.Collection<?> list)
```
 Description copied from interface: FluentCollectionX
 
 Remove all the specified elements from this collection
 
 Specified by:
 
 minusAll in interface FluentCollectionX<T>
 
 Specified by:
 
 minusAll in interface DequeX<T>
 
 Specified by:
 
 minusAll in interface MutableCollectionX<T>
 
 Specified by:
 
 minusAll in interface LazyFluentCollectionX<T>
 
 Overrides:
 
 minusAll in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 list - of elements to remove
 
 Returns:
 
 Collection with the elements removed
 - plusLazy
```
public LazyDequeX<T> plusLazy(T e)
```
 Description copied from interface: LazyFluentCollectionX
 Lazily add an element to this Collection. The Collection will not be materialized (unlike via @see LazyFluentCollectionX.plus(Object)
```
 
 LazyListX<Integer> lazy = LazyListX.of(1,2,3)
 .map(i->i*2)
 .plusLazy(5);
 
 //Lazy List that will contain [2,4,6,5] when triggered 
 
 
```
 Specified by:
 
 plusLazy in interface LazyFluentCollectionX<T>
 
 Overrides:
 
 plusLazy in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 e - Element to add
 
 Returns:
 
 LazyFluentCollectionX with element added
 - plusAllLazy
```
public LazyDequeX<T> plusAllLazy(java.util.Collection<? extends T> list)
```
 Description copied from interface: LazyFluentCollectionX
 Lazily add all the elements in the supplied Collection to this Collection. The Collection will not be materialized (unlike via @see LazyFluentCollectionX#plusAll(Object)
```
 
 LazyListX<Integer> lazy = LazyListX.of(1,2,3)
 .map(i->i*2)
 .plusAllLazy(ListX.of(5,10));
 
 //Lazy List that will contain [2,4,6,5,10] when triggered 
 
 
```
 Specified by:
 
 plusAllLazy in interface LazyFluentCollectionX<T>
 
 Overrides:
 
 plusAllLazy in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 list - Collection to add
 
 Returns:
 
 LazyFluentCollectionX with Collection added
 - minusLazy
```
public LazyDequeX<T> minusLazy(java.lang.Object e)
```
 Description copied from interface: LazyFluentCollectionX
 Lazily remove an element from this Collection. The Collection will not be materialized (unlike via @see LazyFluentCollectionX.minus(Object)
```
 
 LazyListX<Integer> lazy = LazyListX.of(1,2,3)
 .map(i->i*2)
 .minusLazy(4);
 
 //Lazy List that will contain [2,6] when triggered 
 
 
```
 This is an equivalent operation to filtering by equality e.g.
```
 
 LazyListX<Integer> lazy = LazyListX.of(1,2,3)
 .map(i->i*2)
 .filter(i->i==4);
 
 //Lazy List that will contain [2,6] when triggered 
 
 
```
 Specified by:
 
 minusLazy in interface LazyFluentCollectionX<T>
 
 Overrides:
 
 minusLazy in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 e - Element to remove
 
 Returns:
 
 LazyFluentCollectionX with element removed
 - minusAllLazy
```
public LazyDequeX<T> minusAllLazy(java.util.Collection<?> list)
```
 Description copied from interface: LazyFluentCollectionX
 Lazily remove the elements in the supplied Collection from this Collection. The Collection will not be materialized (unlike via @see LazyFluentCollectionX.minusAll(Collection)
```
 
 LazyListX<Integer> lazy = LazyListX.of(1,2,3)
 .map(i->i*2)
 .minusAllLazy(ListX.of(4));
 
 //Lazy List that will contain [2,6] when triggered 
 
 
```
 This is an equivalent operation to filtering by equality e.g.
```
 
 LazyListX<Integer> lazy = LazyListX.of(1,2,3)
 .map(i->i*2)
 .filter(i->ListX.of(4).contains(i));
 
 //Lazy List that will contain [2,6] when triggered 
 
 
```
 Specified by:
 
 minusAllLazy in interface LazyFluentCollectionX<T>
 
 Overrides:
 
 minusAllLazy in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 list - of elements to remove
 
 Returns:
 
 LazyFluentCollectionX with elements removed
 - cycle
```
public LazyDequeX<T> cycle(int times)
```
 Description copied from interface: Traversable
 Convert to a Stream with the values repeated specified times
```
 
 		ReactiveSeq.of(1,2,2)
 								.cycle(3)
 								.collect(Collectors.toList());
 								
 		//List[1,2,2,1,2,2,1,2,2]
 
 
 
```
 Specified by:
 
 cycle in interface CollectionX<T>
 
 Specified by:
 
 cycle in interface DequeX<T>
 
 Specified by:
 
 cycle in interface MutableCollectionX<T>
 
 Specified by:
 
 cycle in interface Traversable<T>
 
 Overrides:
 
 cycle in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 times - Times values should be repeated within a Stream
 
 Returns:
 
 Stream with values repeated
 - cycle
```
public LazyDequeX<T> cycle(Monoid<T> m,
 int 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(Collectors.toList());
 //List[3,3,3];
 
 
```
 Specified by:
 
 cycle in interface CollectionX<T>
 
 Specified by:
 
 cycle in interface DequeX<T>
 
 Specified by:
 
 cycle in interface MutableCollectionX<T>
 
 Specified by:
 
 cycle in interface Traversable<T>
 
 Overrides:
 
 cycle in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 m - Monoid to be used in reduction
 
 times - Number of times value should be repeated
 
 Returns:
 
 Stream with reduced values repeated
 - cycleWhile
```
public LazyDequeX<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(Collectors.toList());
 
 // List(1,2,2,1,2,2)
 
 
```
 Specified by:
 
 cycleWhile in interface CollectionX<T>
 
 Specified by:
 
 cycleWhile in interface DequeX<T>
 
 Specified by:
 
 cycleWhile in interface MutableCollectionX<T>
 
 Specified by:
 
 cycleWhile in interface Traversable<T>
 
 Overrides:
 
 cycleWhile in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - cycleUntil
```
public LazyDequeX<T> cycleUntil(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Repeat in a Stream until specified predicate holds
```
 
 	MutableInt count =MutableInt.of(0);
 		ReactiveSeq.of(1,2,2)
 		 		.cycleUntil(next -> count.get()>6)
 		 		.peek(i-> count.mutate(i->i+1))
 		 		.collect(Collectors.toList());
 
 		//List[1,2,2,1,2,2,1]	
 
 
```
 Specified by:
 
 cycleUntil in interface CollectionX<T>
 
 Specified by:
 
 cycleUntil in interface DequeX<T>
 
 Specified by:
 
 cycleUntil in interface MutableCollectionX<T>
 
 Specified by:
 
 cycleUntil in interface Traversable<T>
 
 Overrides:
 
 cycleUntil in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - zip
```
public  LazyDequeX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<? extends U> other)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Seq combining both into a Tuple2
 
 Specified by:
 
 zip in interface CollectionX<T>
 
 Specified by:
 
 zip in interface DequeX<T>
 
 Specified by:
 
 zip in interface MutableCollectionX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Overrides:
 
 zip in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 other - Seq to combine with
 
 Returns:
 
 Combined Zippable
 - zip3
```
public <S,U> LazyDequeX<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.util.stream.Stream<? extends S> second,
 java.util.stream.Stream<? 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(Collectors.toList());
 
 // [[1,100,'a'],[2,200,'b'],[3,300,'c']]
 
 
 
```
 Specified by:
 
 zip3 in interface CollectionX<T>
 
 Specified by:
 
 zip3 in interface DequeX<T>
 
 Specified by:
 
 zip3 in interface MutableCollectionX<T>
 
 Specified by:
 
 zip3 in interface Traversable<T>
 
 Overrides:
 
 zip3 in class AbstractFluentCollectionX<T>
 - zip4
```
public <T2,T3,T4> LazyDequeX<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.util.stream.Stream<? extends T2> second,
 java.util.stream.Stream<? extends T3> third,
 java.util.stream.Stream<? 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(Collectors.toList());
 
 
 // [[1,100,'a',"hello"],[2,200,'b',"world"]]
 
```
 Specified by:
 
 zip4 in interface CollectionX<T>
 
 Specified by:
 
 zip4 in interface DequeX<T>
 
 Specified by:
 
 zip4 in interface MutableCollectionX<T>
 
 Specified by:
 
 zip4 in interface Traversable<T>
 
 Overrides:
 
 zip4 in class AbstractFluentCollectionX<T>
 - zipWithIndex
```
public LazyDequeX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()
```
 Description copied from interface: Traversable
 Add an index to the current Stream
```
 
 assertEquals(asList(new Tuple2("a", 0L), new Tuple2("b", 1L)), of("a", "b").zipWithIndex().toList());
 
 
```
 Specified by:
 
 zipWithIndex in interface CollectionX<T>
 
 Specified by:
 
 zipWithIndex in interface DequeX<T>
 
 Specified by:
 
 zipWithIndex in interface MutableCollectionX<T>
 
 Specified by:
 
 zipWithIndex in interface Traversable<T>
 
 Overrides:
 
 zipWithIndex in class AbstractFluentCollectionX<T>
 - distinct
```
public LazyDequeX<T> distinct()
```
 Specified by:
 
 distinct in interface CollectionX<T>
 
 Specified by:
 
 distinct in interface DequeX<T>
 
 Specified by:
 
 distinct in interface MutableCollectionX<T>
 
 Specified by:
 
 distinct in interface Traversable<T>
 
 Overrides:
 
 distinct in class AbstractFluentCollectionX<T>
 - sorted
```
public LazyDequeX<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 CollectionX<T>
 
 Specified by:
 
 sorted in interface DequeX<T>
 
 Specified by:
 
 sorted in interface MutableCollectionX<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 
 Overrides:
 
 sorted in class AbstractFluentCollectionX<T>
 - sorted
```
public LazyDequeX<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 CollectionX<T>
 
 Specified by:
 
 sorted in interface DequeX<T>
 
 Specified by:
 
 sorted in interface MutableCollectionX<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 
 Overrides:
 
 sorted in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 c - Compartor to sort with
 
 Returns:
 
 Sorted Stream
 - skipWhile
```
public LazyDequeX<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 CollectionX<T>
 
 Specified by:
 
 skipWhile in interface DequeX<T>
 
 Specified by:
 
 skipWhile in interface MutableCollectionX<T>
 
 Specified by:
 
 skipWhile in interface Traversable<T>
 
 Overrides:
 
 skipWhile in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 p - Predicate to skip while true
 
 Returns:
 
 Stream with elements skipped while predicate holds
 - skipUntil
```
public LazyDequeX<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 CollectionX<T>
 
 Specified by:
 
 skipUntil in interface DequeX<T>
 
 Specified by:
 
 skipUntil in interface MutableCollectionX<T>
 
 Specified by:
 
 skipUntil in interface Traversable<T>
 
 Overrides:
 
 skipUntil in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 p - Predicate to skip until true
 
 Returns:
 
 Stream with elements skipped until predicate holds
 - limitWhile
```
public LazyDequeX<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 CollectionX<T>
 
 Specified by:
 
 limitWhile in interface DequeX<T>
 
 Specified by:
 
 limitWhile in interface MutableCollectionX<T>
 
 Specified by:
 
 limitWhile in interface Traversable<T>
 
 Overrides:
 
 limitWhile in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 p - Limit while predicate is true
 
 Returns:
 
 Stream with limited elements
 - limitUntil
```
public LazyDequeX<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 CollectionX<T>
 
 Specified by:
 
 limitUntil in interface DequeX<T>
 
 Specified by:
 
 limitUntil in interface MutableCollectionX<T>
 
 Specified by:
 
 limitUntil in interface Traversable<T>
 
 Overrides:
 
 limitUntil in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 p - Limit until predicate is true
 
 Returns:
 
 Stream with limited elements
 - intersperse
```
public LazyDequeX<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 CollectionX<T>
 
 Specified by:
 
 intersperse in interface DequeX<T>
 
 Specified by:
 
 intersperse in interface MutableCollectionX<T>
 
 Specified by:
 
 intersperse in interface Traversable<T>
 
 Overrides:
 
 intersperse in class AbstractFluentCollectionX<T>
 - shuffle
```
public LazyDequeX<T> shuffle()
```
 Specified by:
 
 shuffle in interface CollectionX<T>
 
 Specified by:
 
 shuffle in interface DequeX<T>
 
 Specified by:
 
 shuffle in interface MutableCollectionX<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 
 Overrides:
 
 shuffle in class AbstractFluentCollectionX<T>
 - skipLast
```
public LazyDequeX<T> skipLast(int num)
```
 Description copied from interface: Traversable
 
 assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
 
 Specified by:
 
 skipLast in interface CollectionX<T>
 
 Specified by:
 
 skipLast in interface DequeX<T>
 
 Specified by:
 
 skipLast in interface MutableCollectionX<T>
 
 Specified by:
 
 skipLast in interface Traversable<T>
 
 Overrides:
 
 skipLast in class AbstractFluentCollectionX<T>
 
 Returns:
 - limitLast
```
public LazyDequeX<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(Collectors.toList()),equalTo(Arrays.asList(4,5)));
 
 
 
```
 Specified by:
 
 limitLast in interface CollectionX<T>
 
 Specified by:
 
 limitLast in interface DequeX<T>
 
 Specified by:
 
 limitLast in interface MutableCollectionX<T>
 
 Specified by:
 
 limitLast in interface Traversable<T>
 
 Overrides:
 
 limitLast in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 num - of elements to return (last elements)
 
 Returns:
 
 SequenceM limited to last num elements
 - onEmpty
```
public LazyDequeX<T> onEmpty(T value)
```
 Description copied from interface: OnEmpty
 
 If this Container instance is empty, create a new instance containing the provided value
 
 Specified by:
 
 onEmpty in interface CollectionX<T>
 
 Specified by:
 
 onEmpty in interface DequeX<T>
 
 Specified by:
 
 onEmpty in interface MutableCollectionX<T>
 
 Specified by:
 
 onEmpty in interface OnEmpty<T>
 
 Specified by:
 
 onEmpty in interface Traversable<T>
 
 Overrides:
 
 onEmpty in class AbstractFluentCollectionX<T>
 
 Returns:
 
 New instance containing value if container is empty, otherwise returns this container
 - onEmptyGet
```
public LazyDequeX<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
```
 Description copied from interface: OnEmpty
 
 If this Container instance is empty, create a new instance containing the value returned from the provided Supplier
 
 Specified by:
 
 onEmptyGet in interface CollectionX<T>
 
 Specified by:
 
 onEmptyGet in interface DequeX<T>
 
 Specified by:
 
 onEmptyGet in interface MutableCollectionX<T>
 
 Specified by:
 
 onEmptyGet in interface OnEmpty<T>
 
 Specified by:
 
 onEmptyGet in interface Traversable<T>
 
 Overrides:
 
 onEmptyGet in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 supplier - to determine new value for container
 
 Returns:
 
 New Container with value if this is empty, otherwise this container
 - onEmptyThrow
```
public <X extends java.lang.Throwable> LazyDequeX<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
```
 Description copied from interface: OnEmpty
 
 If this container instance is empty, throw the exception returned by the provided Supplier
 
 Specified by:
 
 onEmptyThrow in interface CollectionX<T>
 
 Specified by:
 
 onEmptyThrow in interface DequeX<T>
 
 Specified by:
 
 onEmptyThrow in interface MutableCollectionX<T>
 
 Specified by:
 
 onEmptyThrow in interface OnEmpty<T>
 
 Specified by:
 
 onEmptyThrow in interface Traversable<T>
 
 Overrides:
 
 onEmptyThrow in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 supplier - to create exception from
 
 Returns:
 
 Throw exception if empty, otherwise this container
 - shuffle
```
public LazyDequeX<T> shuffle(java.util.Random random)
```
 Specified by:
 
 shuffle in interface CollectionX<T>
 
 Specified by:
 
 shuffle in interface DequeX<T>
 
 Specified by:
 
 shuffle in interface MutableCollectionX<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 
 Overrides:
 
 shuffle in class AbstractFluentCollectionX<T>
 - ofType
```
public  LazyDequeX ofType(java.lang.Class<? extends U> type)
```
 Description copied from interface: Filterable
 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 DequeX<T>
 
 Specified by:
 
 ofType in interface MutableCollectionX<T>
 
 Specified by:
 
 ofType in interface Filterable<T>
 
 Overrides:
 
 ofType in class AbstractFluentCollectionX<T>
 - filterNot
```
public LazyDequeX<T> filterNot(java.util.function.Predicate<? super T> fn)
```
 Description copied from interface: Filterable
 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 CollectionX<T>
 
 Specified by:
 
 filterNot in interface DequeX<T>
 
 Specified by:
 
 filterNot in interface MutableCollectionX<T>
 
 Specified by:
 
 filterNot in interface Filterable<T>
 
 Overrides:
 
 filterNot in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 fn - to filter elements by, retaining matches
 
 Returns:
 
 Filterable with elements removed where the predicate does not hold
 - notNull
```
public LazyDequeX<T> notNull()
```
 Description copied from interface: Filterable
 Filter elements retaining only values which are not null
```
 
 
 of(1,2,null,4).nonNull();
 
 //[1,2,4]
 
 
 
```
 Specified by:
 
 notNull in interface CollectionX<T>
 
 Specified by:
 
 notNull in interface DequeX<T>
 
 Specified by:
 
 notNull in interface MutableCollectionX<T>
 
 Specified by:
 
 notNull in interface Filterable<T>
 
 Overrides:
 
 notNull in class AbstractFluentCollectionX<T>
 
 Returns:
 
 Filterable with nulls removed
 - removeAll
```
public LazyDequeX<T> removeAll(java.util.stream.Stream<? extends T> stream)
```
 Description copied from interface: IterableFilterable
 
 Remove all elements in the supplied Stream from this filterable
 
 Specified by:
 
 removeAll in interface CollectionX<T>
 
 Specified by:
 
 removeAll in interface DequeX<T>
 
 Specified by:
 
 removeAll in interface MutableCollectionX<T>
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Overrides:
 
 removeAll in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 stream - of elements to remove
 
 Returns:
 
 Filterable with all supplied elements removed
 - removeAll
```
public LazyDequeX<T> removeAll(org.jooq.lambda.Seq<? extends T> stream)
```
 Description copied from interface: CollectionX
 
 Remove all elements from this collection that match the values in the provided Seq
 
 Specified by:
 
 removeAll in interface CollectionX<T>
 
 Specified by:
 
 removeAll in interface DequeX<T>
 
 Specified by:
 
 removeAll in interface MutableCollectionX<T>
 
 Overrides:
 
 removeAll in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 stream - Stream of values to remove
 
 Returns:
 
 Collection with the values removed
 - removeAll
```
public LazyDequeX<T> removeAll(java.lang.Iterable<? extends T> it)
```
 Description copied from interface: IterableFilterable
 
 Remove all elements in the supplied Iterable from this filterable
 
 Specified by:
 
 removeAll in interface CollectionX<T>
 
 Specified by:
 
 removeAll in interface DequeX<T>
 
 Specified by:
 
 removeAll in interface MutableCollectionX<T>
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Overrides:
 
 removeAll in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 it - an Iterable of elements to remove
 
 Returns:
 
 Filterable with all supplied elements removed
 - removeAll
```
public LazyDequeX<T> removeAll(T... values)
```
 Description copied from interface: IterableFilterable
 
 Remove all supplied elements from this filterable
 
 Specified by:
 
 removeAll in interface CollectionX<T>
 
 Specified by:
 
 removeAll in interface DequeX<T>
 
 Specified by:
 
 removeAll in interface MutableCollectionX<T>
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Overrides:
 
 removeAll in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 values - to remove
 
 Returns:
 
 Filterable with all supplied values removed
 - retainAll
```
public LazyDequeX<T> retainAll(java.lang.Iterable<? extends T> it)
```
 Description copied from interface: IterableFilterable
 
 Retain only the supplied elements in the returned Filterable
 
 Specified by:
 
 retainAll in interface CollectionX<T>
 
 Specified by:
 
 retainAll in interface DequeX<T>
 
 Specified by:
 
 retainAll in interface MutableCollectionX<T>
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Overrides:
 
 retainAll in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 it - Iterable of elements to retain
 
 Returns:
 
 Filterable with supplied values retained, and others removed
 - retainAll
```
public LazyDequeX<T> retainAll(java.util.stream.Stream<? extends T> stream)
```
 Description copied from interface: IterableFilterable
 
 Retain only the supplied elements in the returned Filterable
 
 Specified by:
 
 retainAll in interface CollectionX<T>
 
 Specified by:
 
 retainAll in interface DequeX<T>
 
 Specified by:
 
 retainAll in interface MutableCollectionX<T>
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Overrides:
 
 retainAll in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 stream - of elements to retain
 
 Returns:
 
 Filterable with supplied values retained, and others removed
 - retainAll
```
public LazyDequeX<T> retainAll(org.jooq.lambda.Seq<? extends T> stream)
```
 Description copied from interface: CollectionX
 
 Retain all elements from this collection that match the values in the provided Seq
 
 Specified by:
 
 retainAll in interface CollectionX<T>
 
 Specified by:
 
 retainAll in interface DequeX<T>
 
 Specified by:
 
 retainAll in interface MutableCollectionX<T>
 
 Overrides:
 
 retainAll in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 stream - Stream of values to retain
 
 Returns:
 
 Collection with the values retained
 - retainAll
```
public LazyDequeX<T> retainAll(T... values)
```
 Description copied from interface: IterableFilterable
 
 Retain only the supplied elements in the returned Filterable
 
 Specified by:
 
 retainAll in interface CollectionX<T>
 
 Specified by:
 
 retainAll in interface DequeX<T>
 
 Specified by:
 
 retainAll in interface MutableCollectionX<T>
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Overrides:
 
 retainAll in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 values - elements to retain
 
 Returns:
 
 Filterable with supplied values retained, and others removed
 - cast
```
public  LazyDequeX cast(java.lang.Class<? extends U> type)
```
 Description copied from interface: Functor
 
 Cast all elements in a stream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)
 
 Specified by:
 
 cast in interface CollectionX<T>
 
 Specified by:
 
 cast in interface DequeX<T>
 
 Specified by:
 
 cast in interface MutableCollectionX<T>
 
 Specified by:
 
 cast in interface Functor<T>
 
 Overrides:
 
 cast in class AbstractFluentCollectionX<T>
 - patternMatch
```
public <R> LazyDequeX<R> patternMatch(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,R>> case1,
 java.util.function.Supplier<? extends R> otherwise)
```
 Description copied from interface: Functor
 Transform the elements of this Stream with a Pattern Matching case and default value
```
 
 List<String> result = CollectionX.of(1,2,3,4)
 .patternMatch(
 c->c.valuesWhere(i->"even", (Integer i)->i%2==0 )
 )
 
 // CollectionX["odd","even","odd","even"]
 
```
 Specified by:
 
 patternMatch in interface CollectionX<T>
 
 Specified by:
 
 patternMatch in interface DequeX<T>
 
 Specified by:
 
 patternMatch in interface MutableCollectionX<T>
 
 Specified by:
 
 patternMatch in interface Functor<T>
 
 Overrides:
 
 patternMatch in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 case1 - Function to generate a case (or chain of cases as a single case)
 
 otherwise - Value if supplied case doesn't match
 
 Returns:
 
 CollectionX where elements are transformed by pattern matching
 - permutations
```
public LazyDequeX<ReactiveSeq<T>> permutations()
```
 Description copied from interface: ExtendedTraversable
 
 Generate the permutations based on values in the ExtendedTraversable.
 
 Specified by:
 
 permutations in interface CollectionX<T>
 
 Specified by:
 
 permutations in interface DequeX<T>
 
 Specified by:
 
 permutations in interface MutableCollectionX<T>
 
 Specified by:
 
 permutations in interface ExtendedTraversable<T>
 
 Overrides:
 
 permutations in class AbstractFluentCollectionX<T>
 
 Returns:
 
 Permutations from this ExtendedTraversable
 - combinations
```
public LazyDequeX<ReactiveSeq<T>> combinations(int size)
```
 Description copied from interface: ExtendedTraversable
 Generate the combinations based on values in the ExtendedTraversable.
```
 
 ExtendedTraversable<Integer> stream = ReactiveSeq.of(1,2,3);
 stream.combinations(2)
 
 //ReactiveSeq[ReactiveSeq[1,2],ReactiveSeq[1,3],ReactiveSeq[2,3]]
 
 
```
 Specified by:
 
 combinations in interface CollectionX<T>
 
 Specified by:
 
 combinations in interface DequeX<T>
 
 Specified by:
 
 combinations in interface MutableCollectionX<T>
 
 Specified by:
 
 combinations in interface ExtendedTraversable<T>
 
 Overrides:
 
 combinations in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 size - of combinations
 
 Returns:
 
 All combinations of the elements in this ExtendedTraversable of the specified size
 - combinations
```
public LazyDequeX<ReactiveSeq<T>> combinations()
```
 Description copied from interface: ExtendedTraversable
 Generate the combinations based on values in the ExtendedTraversable.
```
 
 ReactiveSeq.of(1,2,3).combinations()
 
 //ReactiveSeq[ReactiveSeq[],ReactiveSeq[1],ReactiveSeq[2],ReactiveSeq[3].ReactiveSeq[1,2],ReactiveSeq[1,3],ReactiveSeq[2,3]
 			,ReactiveSeq[1,2,3]]
 
 
```
 Specified by:
 
 combinations in interface CollectionX<T>
 
 Specified by:
 
 combinations in interface DequeX<T>
 
 Specified by:
 
 combinations in interface MutableCollectionX<T>
 
 Specified by:
 
 combinations in interface ExtendedTraversable<T>
 
 Overrides:
 
 combinations in class AbstractFluentCollectionX<T>
 
 Returns:
 
 All combinations of the elements in this ExtendedTraversable
 - grouped
```
public <C extends java.util.Collection<? super T>> LazyDequeX<C> grouped(int size,
 java.util.function.Supplier<C> supplier)
```
 Description copied from interface: Traversable
 Batch elements in a Stream by size into a collection created by the supplied factory
```
 
 assertThat(ReactiveSeq.of(1,1,1,1,1,1)
 .batchBySize(3,()->new TreeSet<>())
 .toList()
 .get(0)
 .size(),is(1));
 
 
```
 Specified by:
 
 grouped in interface CollectionX<T>
 
 Specified by:
 
 grouped in interface DequeX<T>
 
 Specified by:
 
 grouped in interface MutableCollectionX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Overrides:
 
 grouped in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 size - batch size
 
 supplier - Collection factory
 
 Returns:
 
 SequenceM batched into collection types by size
 - groupedUntil
```
public LazyDequeX<ListX<T>> groupedUntil(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Create a Traversable batched by List, where each batch is populated until the predicate holds
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .groupedUntil(i->i%3==0)
 .toList()
 .size(),equalTo(2));
 
 
```
 Specified by:
 
 groupedUntil in interface CollectionX<T>
 
 Specified by:
 
 groupedUntil in interface DequeX<T>
 
 Specified by:
 
 groupedUntil in interface MutableCollectionX<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Overrides:
 
 groupedUntil in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, then open next batch
 
 Returns:
 
 SequenceM batched into lists determined by the predicate supplied
 - groupedWhile
```
public LazyDequeX<ListX<T>> groupedWhile(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Create a Traversable batched by List, where each batch is populated while the predicate holds
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .groupedWhile(i->i%3!=0)
 .toList().size(),equalTo(2));
 
 
 
```
 Specified by:
 
 groupedWhile in interface CollectionX<T>
 
 Specified by:
 
 groupedWhile in interface DequeX<T>
 
 Specified by:
 
 groupedWhile in interface MutableCollectionX<T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Overrides:
 
 groupedWhile in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, then open next batch
 
 Returns:
 
 SequenceM batched into lists determined by the predicate supplied
 - groupedWhile
```
public <C extends java.util.Collection<? super T>> LazyDequeX<C> groupedWhile(java.util.function.Predicate<? super T> predicate,
 java.util.function.Supplier<C> factory)
```
 Description copied from interface: Traversable
 Create a SequenceM batched by a Collection, where each batch is populated while the predicate holds
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .batchWhile(i->i%3!=0)
 .toList()
 .size(),equalTo(2));
 
 
```
 Specified by:
 
 groupedWhile in interface CollectionX<T>
 
 Specified by:
 
 groupedWhile in interface DequeX<T>
 
 Specified by:
 
 groupedWhile in interface MutableCollectionX<T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Overrides:
 
 groupedWhile in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, then open next batch
 
 factory - Collection factory
 
 Returns:
 
 SequenceM batched into collections determined by the predicate supplied
 - groupedUntil
```
public <C extends java.util.Collection<? super T>> LazyDequeX<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 CollectionX<T>
 
 Specified by:
 
 groupedUntil in interface DequeX<T>
 
 Specified by:
 
 groupedUntil in interface MutableCollectionX<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Overrides:
 
 groupedUntil in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, then open next batch
 
 factory - Collection factory
 
 Returns:
 
 SequenceM batched into collections determined by the predicate supplied
 - with
```
public LazyDequeX<T> with(int i,
 T element)
```
 ListX methods
 - unit
```
public <R> LazyDequeX<R> unit(java.util.Collection<R> col)
```
 Description copied from interface: FluentCollectionX
 
 Create a new instance of the same colleciton type from the supplied collection
 
 Specified by:
 
 unit in interface FluentCollectionX<T>
 
 Specified by:
 
 unit in interface DequeX<T>
 
 Specified by:
 
 unit in interface LazyFluentCollectionX<T>
 
 Parameters:
 
 col - Collection data to populate the new collection
 
 Returns:
 
 Collection as the same type as this collection
 - unit
```
public <R> LazyDequeX<R> unit(R value)
```
 Specified by:
 
 unit in interface CollectionX<T>
 
 Specified by:
 
 unit in interface DequeX<T>
 
 Specified by:
 
 unit in interface Unit<T>
 - unitIterator
```
public <R> LazyDequeX<R> unitIterator(java.util.Iterator<R> it)
```
 Description copied from interface: IterableFunctor
 Create an IterableFunctor instance of the same type from an Iterator
```
 
 ReactiveSeq<Integer> newSeq = seq.unitIterator(myIterator);
 
 
 
```
 Specified by:
 
 unitIterator in interface DequeX<T>
 
 Specified by:
 
 unitIterator in interface IterableFunctor<T>
 
 Specified by:
 
 unitIterator in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 it - Iterator to create new IterableFunctor from
 
 Returns:
 
 New IterableFunctor instance
 - plusInOrder
```
public LazyDequeX<T> plusInOrder(T e)
```
 Description copied from interface: FluentCollectionX
 
 Add an element to the collection
 
 Specified by:
 
 plusInOrder in interface FluentCollectionX<T>
 
 Specified by:
 
 plusInOrder in interface LazyFluentCollectionX<T>
 
 Parameters:
 
 e - Element to add
 
 Returns:
 
 Collection with element added
 - from
```
public <T1> LazyDequeX<T1> from(java.util.Collection<T1> c)
```
 Description copied from interface: CollectionX
 
 Conctruct an Extended Collection from a standard Collection
 
 Specified by:
 
 from in interface CollectionX<T>
 
 Specified by:
 
 from in interface DequeX<T>
 
 Specified by:
 
 from in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 c - Collection to extend
 
 Returns:
 
 Extended Collection
 - groupedStatefullyUntil
```
public LazyDequeX<ListX<T>> groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
```
 Description copied from interface: Traversable
 Create Travesable of Lists where each List is populated while the supplied bipredicate holds. The bipredicate recieves the List from the last window as well as the current value and can choose to aggregate the current value or create a new window
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .groupedStatefullyUntil((s,i)->s.contains(4) ? true : false)
 .toList().size(),equalTo(5));
 
 
```
 Specified by:
 
 groupedStatefullyUntil in interface CollectionX<T>
 
 Specified by:
 
 groupedStatefullyUntil in interface DequeX<T>
 
 Specified by:
 
 groupedStatefullyUntil in interface MutableCollectionX<T>
 
 Specified by:
 
 groupedStatefullyUntil in interface Traversable<T>
 
 Overrides:
 
 groupedStatefullyUntil in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 predicate - Window while true
 
 Returns:
 
 Traversable windowed while predicate holds
 - peek
```
public LazyDequeX<T> peek(java.util.function.Consumer<? super T> c)
```
 Description copied from interface: Functor
 Peek at the current value of this Functor, without transforming it
```
 
 
 
 of(1,2,3).map(System.out::println)
 
 1
 2
 3
 
 
 
```
 Specified by:
 
 peek in interface CollectionX<T>
 
 Specified by:
 
 peek in interface DequeX<T>
 
 Specified by:
 
 peek in interface Functor<T>
 
 Overrides:
 
 peek in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 c - Consumer that recieves each element from this Functor
 
 Returns:
 
 Functor that will peek at each value
 - zip
```
public <U,R> LazyDequeX<R> zip(org.jooq.lambda.Seq<? 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 Seq, using the supplied combining function
 
 Specified by:
 
 zip in interface CollectionX<T>
 
 Specified by:
 
 zip in interface DequeX<T>
 
 Specified by:
 
 zip in interface MutableCollectionX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Overrides:
 
 zip in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 other - Seq to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - zip
```
public <U,R> LazyDequeX<R> zip(java.util.stream.Stream<? extends U> other,
 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
 
 Specified by:
 
 zip in interface CollectionX<T>
 
 Specified by:
 
 zip in interface DequeX<T>
 
 Specified by:
 
 zip in interface MutableCollectionX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Overrides:
 
 zip in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 other - Stream to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - zip
```
public  LazyDequeX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.util.stream.Stream<? extends U> other)
```
 Description copied from interface: Traversable
 Zip 2 streams into one
```
 

 List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
 // [[1,"a"],[2,"b"]]
 
 
```
 Specified by:
 
 zip in interface CollectionX<T>
 
 Specified by:
 
 zip in interface DequeX<T>
 
 Specified by:
 
 zip in interface MutableCollectionX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Overrides:
 
 zip in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 other - Stream to combine with
 
 Returns:
 
 Combined Zippable
 - zip
```
public <T2,R> LazyDequeX<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 Zippable<T>
 
 Overrides:
 
 zip in class AbstractFluentCollectionX<T>
 
 Parameters:
 
 fn - Zip / combining function
 
 publisher - to combine with
 
 Returns:
 
 Combined zippable
 - fromStream
```
public <X> LazyDequeX<X> fromStream(java.util.stream.Stream<X> stream)
```
 Specified by:
 
 fromStream in interface DequeX<T>
 
 Specified by:
 
 fromStream in interface MutableCollectionX<T>
 
 Parameters:
 
 stream - Create a MultableCollectionX from a Stream
 
 Returns:
 
 MutableCollectionX
 - onEmptySwitch
```
public LazyDequeX<T> onEmptySwitch(java.util.function.Supplier<? extends java.util.Deque<T>> supplier)
```
 Description copied from interface: OnEmptySwitch
 Switch to container created by provided Supplier, if current Container empty
```
 
 ListX.empty().onEmptySwitch(()->ListX.of(1));
 
 
```
 Specified by:
 
 onEmptySwitch in interface DequeX<T>
 
 Specified by:
 
 onEmptySwitch in interface OnEmptySwitch<T,java.util.Deque<T>>
 
 Parameters:
 
 supplier - to create replacement container
 
 Returns:
 
 Either this container or if empty, an alternative returned by the provided supplier
 - addFirst
```
public void addFirst(T e)
```
 Specified by:
 
 addFirst in interface java.util.Deque<T>
 
 Parameters:
 
 e -
 
 See Also:
 
 Deque.addFirst(java.lang.Object)
 - addLast
```
public void addLast(T e)
```
 Specified by:
 
 addLast in interface java.util.Deque<T>
 
 Parameters:
 
 e -
 
 See Also:
 
 Deque.addLast(java.lang.Object)
 - offerFirst
```
public boolean offerFirst(T e)
```
 Specified by:
 
 offerFirst in interface java.util.Deque<T>
 
 Parameters:
 
 e -
 
 Returns:
 
 See Also:
 
 Deque.offerFirst(java.lang.Object)
 - offerLast
```
public boolean offerLast(T e)
```
 Specified by:
 
 offerLast in interface java.util.Deque<T>
 
 Parameters:
 
 e -
 
 Returns:
 
 See Also:
 
 Deque.offerLast(java.lang.Object)
 - removeFirst
```
public T removeFirst()
```
 Specified by:
 
 removeFirst in interface java.util.Deque<T>
 
 Returns:
 
 See Also:
 
 Deque.removeFirst()
 - removeLast
```
public T removeLast()
```
 Specified by:
 
 removeLast in interface java.util.Deque<T>
 
 Returns:
 
 See Also:
 
 Deque.removeLast()
 - pollFirst
```
public T pollFirst()
```
 Specified by:
 
 pollFirst in interface java.util.Deque<T>
 
 Returns:
 
 See Also:
 
 Deque.pollFirst()
 - pollLast
```
public T pollLast()
```
 Specified by:
 
 pollLast in interface java.util.Deque<T>
 
 Returns:
 
 See Also:
 
 Deque.pollLast()
 - getFirst
```
public T getFirst()
```
 Specified by:
 
 getFirst in interface java.util.Deque<T>
 
 Returns:
 
 See Also:
 
 Deque.getFirst()
 - getLast
```
public T getLast()
```
 Specified by:
 
 getLast in interface java.util.Deque<T>
 
 Returns:
 
 See Also:
 
 Deque.getLast()
 - peekFirst
```
public T peekFirst()
```
 Specified by:
 
 peekFirst in interface java.util.Deque<T>
 
 Returns:
 
 See Also:
 
 Deque.peekFirst()
 - peekLast
```
public T peekLast()
```
 Specified by:
 
 peekLast in interface java.util.Deque<T>
 
 Returns:
 
 See Also:
 
 Deque.peekLast()
 - removeFirstOccurrence
```
public boolean removeFirstOccurrence(java.lang.Object o)
```
 Specified by:
 
 removeFirstOccurrence in interface java.util.Deque<T>
 
 Parameters:
 
 o -
 
 Returns:
 
 See Also:
 
 Deque.removeFirstOccurrence(java.lang.Object)
 - removeLastOccurrence
```
public boolean removeLastOccurrence(java.lang.Object o)
```
 Specified by:
 
 removeLastOccurrence in interface java.util.Deque<T>
 
 Parameters:
 
 o -
 
 Returns:
 
 See Also:
 
 Deque.removeLastOccurrence(java.lang.Object)
 - offer
```
public boolean offer(T e)
```
 Specified by:
 
 offer in interface java.util.Deque<T>
 
 Specified by:
 
 offer in interface java.util.Queue<T>
 
 Parameters:
 
 e -
 
 Returns:
 
 See Also:
 
 Deque.offer(java.lang.Object)
 - remove
```
public T remove()
```
 Specified by:
 
 remove in interface java.util.Deque<T>
 
 Specified by:
 
 remove in interface java.util.Queue<T>
 
 Returns:
 
 See Also:
 
 Deque.remove()
 - poll
```
public T poll()
```
 Specified by:
 
 poll in interface java.util.Deque<T>
 
 Specified by:
 
 poll in interface java.util.Queue<T>
 
 Returns:
 
 See Also:
 
 Deque.poll()
 - element
```
public T element()
```
 Specified by:
 
 element in interface java.util.Deque<T>
 
 Specified by:
 
 element in interface java.util.Queue<T>
 
 Returns:
 
 See Also:
 
 Deque.element()
 - peek
```
public T peek()
```
 Specified by:
 
 peek in interface java.util.Deque<T>
 
 Specified by:
 
 peek in interface java.util.Queue<T>
 
 Returns:
 
 See Also:
 
 Deque.peek()
 - push
```
public void push(T e)
```
 Specified by:
 
 push in interface java.util.Deque<T>
 
 Parameters:
 
 e -
 
 See Also:
 
 Deque.push(java.lang.Object)
 - pop
```
public T pop()
```
 Specified by:
 
 pop in interface java.util.Deque<T>
 
 Returns:
 
 See Also:
 
 Deque.pop()
 - descendingIterator
```
public java.util.Iterator<T> descendingIterator()
```
 Specified by:
 
 descendingIterator in interface java.util.Deque<T>
 
 Returns:
 
 See Also:
 
 Deque.descendingIterator()
 - materialize
```
public LazyDequeX<T> materialize()
```
 Specified by:
 
 materialize in interface LazyFluentCollectionX<T>
 
 Returns:
 
 This collection with any queued Lazy Operations materialized

Class LazyDequeX<T>

Nested Class Summary

Nested classes/interfaces inherited from class com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.aol.cyclops.data.collections.extensions.standard.DequeX

Methods inherited from interface com.aol.cyclops.types.To

Methods inherited from interface com.aol.cyclops.data.collections.extensions.standard.MutableCollectionX

Methods inherited from interface com.aol.cyclops.data.collections.extensions.CollectionX

Methods inherited from interface com.aol.cyclops.types.TransformerTraversable

Methods inherited from interface com.aol.cyclops.types.Sequential

Methods inherited from interface com.aol.cyclops.types.IterableFoldable

Methods inherited from interface com.aol.cyclops.types.applicative.zipping.ZippingApplicativable

Methods inherited from interface com.aol.cyclops.types.IterableFunctor

Methods inherited from interface com.aol.cyclops.types.Foldable

Methods inherited from interface com.aol.cyclops.types.Traversable

Methods inherited from interface com.aol.cyclops.types.stream.ConvertableSequence

Methods inherited from interface com.aol.cyclops.types.stream.CyclopsCollectable

Methods inherited from interface org.jooq.lambda.Collectable

Methods inherited from interface com.aol.cyclops.reactor.types.ReactorConvertable

Method Detail

plusLoop

plusLoop

fromStreamS

range

rangeLong

generate

iterate

empty

of

singleton

fromPublisher

fromIterable

fromIterable

forEach

iterator

size

contains

equals

isEmpty

hashCode

toArray

removeAll

toArray

add

remove

containsAll

addAll

retainAll

clear

toString

collect

count

removeIf

parallelStream

spliterator

stream

stream

flux

combine

reverse

filter

map

flatMap

limit

skip

takeRight

dropRight

takeWhile

dropWhile

takeUntil

dropUntil

trampoline

slice

grouped

grouped

grouped

zip

zip

sliding