LinkedListX (cyclops-react 2.0.0-MI7 API)

All Superinterfaces:

java.util.Collection<T>, CollectionX<T>, Convert<Higher<LinkedListX.µ,T>>, CyclopsCollectable<T>, ExtendedTraversable<T>, FilterableTransformable<T>, Filters<T>, FluentCollectionX<T>, FoldableTraversable<T>, Folds<T>, Higher<LinkedListX.µ,T>, IndexedSequenceX<T>, java.lang.Iterable<T>, IterableFilterable<T>, LazyCollectionX<T>, java.util.List<T>, OnEmpty<T>, OnEmptySwitch<T,org.pcollections.PStack<T>>, org.pcollections.PCollection<T>, org.pcollections.PSequence<T>, org.pcollections.PStack<T>, org.reactivestreams.Publisher<T>, ReactiveStreamsTerminalOperations<T>, Sequential<T>, To<LinkedListX<T>>, Transformable<T>, TransformerTraversable<T>, Traversable<T>, Unit<T>, Unwrapable, Zippable<T>

All Known Implementing Classes:

LazyLinkedListX
```
public interface LinkedListX<T>
extends To<LinkedListX<T>>, org.pcollections.PStack<T>, LazyCollectionX<T>, IndexedSequenceX<T>, OnEmptySwitch<T,org.pcollections.PStack<T>>, Higher<LinkedListX.µ,T>
```

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static class`	`LinkedListX.µ`
`static class`	`LinkedListX.Instances` Companion class for creating Type Class instances for working with PStacks

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default AnyMSeq<Witness.linkedListX,T>`	`anyM()`
`default LinkedListX<T>`	`append(T... values)` Append values toNested the take of this ReactiveSeq
`default LinkedListX<T>`	`append(T value)`
`default <U> LinkedListX<U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a reactiveStream toNested a given type, possibly throwing a `ClassCastException`.
`default <R> LinkedListX<R>`	`coflatMap(java.util.function.Function<? super LinkedListX<T>,? extends R> fn)` coflatMap pattern, can be used toNested perform maybe reductions / collections / folds and other terminal operations
`default LinkedListX<ReactiveSeq<T>>`	`combinations()` Generate the combinations based on values in the ExtendedTraversable.
`default LinkedListX<ReactiveSeq<T>>`	`combinations(int size)` Generate the combinations based on values in the ExtendedTraversable.
`default LinkedListX<T>`	`combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)` Combine two adjacent elements in a LinkedListX using the supplied BinaryOperator This is a stateful grouping & reduction operation.
`default LinkedListX<T>`	`combine(Monoid<T> op, java.util.function.BiPredicate<? super T,? super T> predicate)` Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation.
`default LinkedListX<T>`	`cycle(long times)` Convert toNested a Stream with the values repeated specified times
`default LinkedListX<T>`	`cycle(Monoid<T> m, long times)` Convert toNested a Stream with the result of a reduction operation repeated specified times
`default LinkedListX<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream until specified predicate holds
`default LinkedListX<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream while specified predicate holds
`default LinkedListX<T>`	`deleteBetween(int start, int end)` Delete elements between given indexes in a Stream
`default LinkedListX<T>`	`distinct()`
`default LinkedListX<T>`	`drop(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7)));`
`default LinkedListX<T>`	`dropRight(int num)` Generate a new Traversable that drops the specified number elements from the take of this Traversable
`default LinkedListX<T>`	`dropUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that drops elements from this Traversable until the predicate holds
`default LinkedListX<T>`	`dropWhile(java.util.function.Predicate<? super T> p)` Generate a new Traversable that drops elements from this Traversable as long as the predicate holds
`static <T> LinkedListX<T>`	`empty()` `List<String> empty = PStack.empty(); //or PStack<String> empty = PStack.empty();`
`default <R> LinkedListX<R>`	`emptyUnit()`
`static <T> LinkedListX<T>`	`fill(long limit, T s)` Generate a LinkedListX from the provided value up toNested the provided limit number of times
`default LinkedListX<T>`	`filter(java.util.function.Predicate<? super T> pred)` Keep only elements for which the supplied predicates hold e.g.
`default LinkedListX<T>`	`filterNot(java.util.function.Predicate<? super T> fn)` Remove any elements for which the predicate holds (inverse operation toNested filter) e.g.
`default <R> LinkedListX<R>`	`flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)` Perform a flatMap operation on this collection.
`default <R> LinkedListX<R>`	`flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)`
`default <R> LinkedListX<R>`	`flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)`
`default <R1,R> LinkedListX<R>`	`forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)` Perform a two level nested internal iteration over this Stream and the supplied reactiveStream
`default <R1,R> LinkedListX<R>`	`forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1, java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)` Perform a two level nested internal iteration over this Stream and the supplied reactiveStream
`default <R1,R2,R> LinkedListX<R>`	`forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> stream2, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)` Perform a three level nested internal iteration over this Stream and the supplied streams
`default <R1,R2,R> LinkedListX<R>`	`forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> stream2, Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)` Perform a three level nested internal iteration over this Stream and the supplied streams
`default <R1,R2,R3,R> LinkedListX<R>`	`forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> stream2, Fn3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> stream3, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)` Perform a three level nested internal iteration over this Stream and the supplied streams
`default <R1,R2,R3,R> LinkedListX<R>`	`forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> stream2, Fn3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> stream3, Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)` Perform a three level nested internal iteration over this Stream and the supplied streams
`default <X> LinkedListX<X>`	`from(java.util.Collection<X> col)` Conctruct an Extended Collection from a standard Collection
`static <T> LinkedListX<T>`	`fromIterable(java.lang.Iterable<T> iterable)`
`static <T> LinkedListX<T>`	`fromIterator(java.util.Iterator<T> it)` Construct a LinkedListX from the provided Iterator
`static <T> LinkedListX<T>`	`fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)` Construct a LinkedListX from an Publisher
`default <T> LinkedListX<T>`	`fromStream(ReactiveSeq<T> stream)` Reduce (immutable Collection) a Stream toNested a PStack, note for efficiency reasons, the emitted PStack is reversed.
`static <T> LinkedListX<T>`	`generate(long limit, java.util.function.Supplier<T> s)` Generate a LinkedListX from the provided Supplier up toNested the provided limit number of times
`default <K> LinkedListX<org.jooq.lambda.tuple.Tuple2<K,ReactiveSeq<T>>>`	`grouped(java.util.function.Function<? super T,? extends K> classifier)` Group this Traversable by the provided classifying function and collected by the provided Collector
`default <K,A,D> LinkedListX<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
`default LinkedListX<ListX<T>>`	`grouped(int groupSize)` Group elements in a Stream
`default <C extends java.util.Collection<? super T>> LinkedListX<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
`default LinkedListX<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.
`default LinkedListX<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
`default <C extends java.util.Collection<? super T>> LinkedListX<C>`	`groupedUntil(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)` Create a ReactiveSeq batched by a Collection, where each batch is populated until the predicate holds
`default LinkedListX<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
`default <C extends java.util.Collection<? super T>> LinkedListX<C>`	`groupedWhile(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)` Create a SequenceM batched by a Collection, where each batch is populated while the predicate holds
`default LinkedListX<T>`	`insertAt(int pos, T... values)` Insert data into a reactiveStream at given position
`default LinkedListX<T>`	`insertAtS(int pos, java.util.stream.Stream<T> stream)` Insert a Stream into the middle of this reactiveStream at the specified position
`default LinkedListX<T>`	`intersperse(T value)` Returns a reactiveStream with a given value interspersed between any two values of this reactiveStream.
`static <T> LinkedListX<T>`	`iterate(long limit, T seed, java.util.function.UnaryOperator<T> f)` Create a LinkedListX by iterative application of a function toNested an initial element up toNested the supplied limit number of times
`default <W extends WitnessType<W>> ListT<W,T>`	`liftM(W witness)`
`default LinkedListX<T>`	`limit(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`default LinkedListX<T>`	`limitLast(int num)` Limit results toNested the last x elements in a SequenceM
`default LinkedListX<T>`	`limitUntil(java.util.function.Predicate<? super T> p)` Take elements from the Stream until the predicate returns true, after which all elements are excluded.
`default LinkedListX<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
`static <T> LinkedListX<T>`	`linkedListX(ReactiveSeq<T> stream)` `import static cyclops.stream.ReactiveSeq.range; LinkedListX<Integer> bag = linkedListX(range(10,20));`
`default <R> LinkedListX<R>`	`map(java.util.function.Function<? super T,? extends R> mapper)` Transform this functor using the supplied transformation function
`default LinkedListX<T>`	`materialize()`
`LinkedListX<T>`	`minus(int i)` Remove the element at the supplied index
`LinkedListX<T>`	`minus(java.lang.Object remove)` Remove the specified element from this collection
`LinkedListX<T>`	`minusAll(java.util.Collection<?> list)` Remove all the specified elements from this collection
`default <T> Reducer<org.pcollections.PStack<T>>`	`monoid()`
`static <T> LinkedListX<T>`	`narrow(LinkedListX<? extends T> stackX)` Narrow a covariant LinkedListX
`static <T> LinkedListX<T>`	`narrowK(Higher<LinkedListX.µ,T> list)` Convert the raw Higher Kinded Type for PStack types into the PStackType type definition class
`default LinkedListX<T>`	`notNull()` Filter elements retaining only values which are not null
`static <T> LinkedListX<T>`	`of(T... values)` Construct a Persistent LinkedList from the provided values
`default <U> LinkedListX<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a reactiveStream that are of a given type.
`default LinkedListX<T>`	`onEmpty(T value)` If this Container instance is empty, create a new instance containing the provided value
`default LinkedListX<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
`default LinkedListX<T>`	`onEmptySwitch(java.util.function.Supplier<? extends org.pcollections.PStack<T>> supplier)` Switch toNested container created by provided Supplier, if current Container empty
`default <X extends java.lang.Throwable> LinkedListX<T>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)` If this container instance is empty, throw the exception returned by the provided Supplier
`default LinkedListX<ReactiveSeq<T>>`	`permutations()` Generate the permutations based on values in the ExtendedTraversable.
`LinkedListX<T>`	`plus(int i, T e)` Add the supplied element at the supplied index
`LinkedListX<T>`	`plus(T e)` Add an element to this Collection
`LinkedListX<T>`	`plusAll(java.util.Collection<? extends T> list)` Add all supplied elements to this Collection
`LinkedListX<T>`	`plusAll(int i, java.util.Collection<? extends T> list)` Add all of the supplied elements at the supplied index
`default LinkedListX<T>`	`plusInOrder(T e)` Add an element to the collection
`default LinkedListX<T>`	`plusLoop(int max, java.util.function.IntFunction<T> value)`
`default LinkedListX<T>`	`plusLoop(java.util.function.Supplier<java.util.Optional<T>> supplier)`
`default LinkedListX<T>`	`prepend(T... values)` Prepend given values toNested the skip of the Stream
`default LinkedListX<T>`	`prepend(T value)`
`default LinkedListX<T>`	`prependS(java.util.stream.Stream<? extends T> stream)` Prepend Stream toNested this ReactiveSeq
`static LinkedListX<java.lang.Integer>`	`range(int start, int end)` Create a LinkedListX that contains the Integers between skip and take
`static LinkedListX<java.lang.Long>`	`rangeLong(long start, long end)` Create a LinkedListX that contains the Longs between skip and take
`default <EX extends java.lang.Throwable> LinkedListX<T>`	`recover(java.lang.Class<EX> exceptionClass, java.util.function.Function<? super EX,? extends T> fn)` Recover from a particular exception type
`default LinkedListX<T>`	`recover(java.util.function.Function<? super java.lang.Throwable,? extends T> fn)` Recover from an exception with an alternative value
`default LinkedListX<T>`	`removeAll(T... values)` Remove all supplied elements from this filterable
`default LinkedListX<T>`	`removeAllI(java.lang.Iterable<? extends T> it)` Remove all elements in the supplied Iterable from this filterable
`default LinkedListX<T>`	`removeAllS(java.util.stream.Stream<? extends T> stream)` Remove all elements in the supplied Stream from this filterable
`default LinkedListX<T>`	`retainAll(T... values)` Retain only the supplied elements in the returned Filters
`default LinkedListX<T>`	`retainAllI(java.lang.Iterable<? extends T> it)` Retain only the supplied elements in the returned Filters
`default LinkedListX<T>`	`retainAllS(java.util.stream.Stream<? extends T> seq)` Retain only the supplied elements in the returned Filters
`default <R> LinkedListX<R>`	`retry(java.util.function.Function<? super T,? extends R> fn)` Retry a transformation if it fails.
`default <R> LinkedListX<R>`	`retry(java.util.function.Function<? super T,? extends R> fn, int retries, long delay, java.util.concurrent.TimeUnit timeUnit)` Retry a transformation if it fails.
`default LinkedListX<T>`	`reverse()` Potentially efficient Stream reversal.
`default LinkedListX<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`default <U> LinkedListX<U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)` Scan left
`default LinkedListX<T>`	`scanRight(Monoid<T> monoid)` Scan right
`default <U> LinkedListX<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)` Scan right
`default LinkedListX<T>`	`shuffle()`
`default LinkedListX<T>`	`shuffle(java.util.Random random)`
`static <T> LinkedListX<T>`	`singleton(T value)` Construct a PStack containing a single value
`default LinkedListX<T>`	`skip(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`default LinkedListX<T>`	`skipLast(int num)` assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(1,2,3)));
`default LinkedListX<T>`	`skipUntil(java.util.function.Predicate<? super T> p)` Drop elements from the Stream until the predicate returns true, after which all elements are included
`default LinkedListX<T>`	`skipWhile(java.util.function.Predicate<? super T> p)` SkipWhile drops elements from the Stream while the predicate holds, once the predicte returns true all subsequent elements are included *
`default LinkedListX<T>`	`slice(long from, long to)`
`default LinkedListX<VectorX<T>>`	`sliding(int windowSize)` Create a sliding view over this Sequence
`default LinkedListX<VectorX<T>>`	`sliding(int windowSize, int increment)` Create a sliding view over this Sequence
`default LinkedListX<T>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`default LinkedListX<T>`	`sorted(java.util.Comparator<? super T> c)` `assertThat(ReactiveSeq.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));`
`default <U extends java.lang.Comparable<? super U>> LinkedListX<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`default ReactiveSeq<T>`	`stream()`
`LinkedListX<T>`	`subList(int start, int end)` Create a sub sequence between the two supplied index
`default LinkedListX<T>`	`take(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).take(2).toList(),equalTo(Arrays.asList(4,3));`
`default LinkedListX<T>`	`takeRight(int num)` Generate a new Traversable that takes the specified number elements from the take of this Traversable
`default LinkedListX<T>`	`takeUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that takes elements from this Traversable until the predicate holds
`default LinkedListX<T>`	`takeWhile(java.util.function.Predicate<? super T> p)` Generate a new Traversable that takes elements from this Traversable as long as the predicate holds
`default <R> LinkedListX<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
`LinkedListX<T>`	`type(Reducer<? extends org.pcollections.PStack<T>> reducer)`
`static <U,T> LinkedListX<T>`	`unfold(U seed, java.util.function.Function<? super U,java.util.Optional<org.jooq.lambda.tuple.Tuple2<T,U>>> unfolder)` Unfold a function into a LinkedListX
`default <R> LinkedListX<R>`	`unit(java.util.Collection<R> col)` Create a new instance of the same colleciton type from the supplied collection
`default <R> LinkedListX<R>`	`unit(R value)`
`default <R> LinkedListX<R>`	`unitIterator(java.util.Iterator<R> it)` Create an IterableFunctor instance of the same type from an Iterator
`static <C2,T> Higher<C2,Higher<LinkedListX.µ,T>>`	`widen2(Higher<C2,LinkedListX<T>> list)` Widen a PStackType nested inside another HKT encoded type
`LinkedListX<T>`	`with(int i, T e)` Replace the value at the specifed index with the supplied value
`default <U> LinkedListX<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
`default <U,R> LinkedListX<R>`	`zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
`default <S,U> LinkedListX<org.jooq.lambda.tuple.Tuple3<T,S,U>>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third)` zip 3 Streams into one
`default <T2,T3,T4> LinkedListX<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>`	`zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth)` zip 4 Streams into 1
`default <U> LinkedListX<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipS(java.util.stream.Stream<? extends U> other)` Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2
`default <U,R> LinkedListX<R>`	`zipS(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
`default LinkedListX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>`	`zipWithIndex()` Add an index toNested the current Stream

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

Methods inherited from interface org.pcollections.PStack
subList

Methods inherited from interface org.pcollections.PSequence
add, addAll, remove, set

Methods inherited from interface org.pcollections.PCollection
add, addAll, clear, remove, removeAll, retainAll

Methods inherited from interface java.util.List
add, addAll, clear, contains, containsAll, equals, get, hashCode, indexOf, isEmpty, iterator, lastIndexOf, listIterator, listIterator, remove, removeAll, replaceAll, retainAll, size, sort, spliterator, toArray, toArray

Methods inherited from interface com.aol.cyclops2.data.collections.extensions.standard.LazyCollectionX
reduce

Methods inherited from interface com.aol.cyclops2.data.collections.extensions.CollectionX
collection, findAny, findFirst, fromCollection, getAtIndex, groupBy, head, headAndTail, isEmpty, iterator, materializeReversed, peek, single, single, singleOptional

Methods inherited from interface com.aol.cyclops2.types.traversable.FoldableTraversable
asFunction, foldFuture, foldLazy, foldTry, forEach, forEach, forEach, forEach, forEach, forEachSubscribe, forEachSubscribe, forEachSubscribe, runFuture, runLazy, seq, toListX, toSetX, visit

Methods inherited from interface com.aol.cyclops2.types.foldable.CyclopsCollectable
allMatch, anyMatch, collect, collectors, commonPrefix, commonSuffix, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, max, maxBy, min, minBy, mode, noneMatch, sum, sumDouble, sumInt, sumLong, to, toList, toMap, toMap, toSet, toString, toString

Methods inherited from interface com.aol.cyclops2.types.foldable.Folds
endsWith, endsWithIterable, firstValue, foldLeft, foldLeft, foldLeft, foldLeft, 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, xMatch

Methods inherited from interface java.lang.Iterable
forEach

Methods inherited from interface java.util.Collection
parallelStream, removeIf

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

Methods inherited from interface com.aol.cyclops2.hkt.Higher
apply_, apply, apply

Methods inherited from interface com.aol.cyclops2.hkt.Convert
convert

- Method Detail
 - widen2
```
static <C2,T> Higher<C2,Higher<LinkedListX.µ,T>> widen2(Higher<C2,LinkedListX<T>> list)
```
 Widen a PStackType nested inside another HKT encoded type
 
 Parameters:
 
 list - HTK encoded type containing a PStack toNested widen
 
 Returns:
 
 HKT encoded type with a widened PStack
 - narrowK
```
static <T> LinkedListX<T> narrowK(Higher<LinkedListX.µ,T> list)
```
 Convert the raw Higher Kinded Type for PStack types into the PStackType type definition class
 
 Parameters:
 
 list - HKT encoded list into a PStackType
 
 Returns:
 
 PStackType
 - liftM
```
default <W extends WitnessType<W>> ListT<W,T> liftM(W witness)
```
 - narrow
```
static <T> LinkedListX<T> narrow(LinkedListX<? extends T> stackX)
```
 Narrow a covariant LinkedListX
```
 
 LinkedListX<? extends Fruit> set = LinkedListX.of(apple,bannana);
 LinkedListX<Fruit> fruitSet = LinkedListX.narrow(set);
 
 
```
 Parameters:
 
 stackX - toNested narrow generic type
 
 Returns:
 
 OrderedSetX with narrowed type
 - range
```
static LinkedListX<java.lang.Integer> range(int start,
 int end)
```
 Create a LinkedListX that contains the Integers between skip and take
 
 Parameters:
 
 start - Number of range toNested skip from
 
 end - Number for range toNested take at
 
 Returns:
 
 Range LinkedListX
 - rangeLong
```
static LinkedListX<java.lang.Long> rangeLong(long start,
 long end)
```
 Create a LinkedListX that contains the Longs between skip and take
 
 Parameters:
 
 start - Number of range toNested skip from
 
 end - Number for range toNested take at
 
 Returns:
 
 Range LinkedListX
 - unfold
```
static <U,T> LinkedListX<T> unfold(U seed,
 java.util.function.Function<? super U,java.util.Optional<org.jooq.lambda.tuple.Tuple2<T,U>>> unfolder)
```
 Unfold a function into a LinkedListX
```
 
 LinkedListX.unfold(1,i->i<=6 ? Optional.of(Tuple.tuple(i,i+1)) : Optional.empty());
 
 //(1,2,3,4,5)
 
 
```
 Parameters:
 
 seed - Initial value
 
 unfolder - Iteratively applied function, terminated by an empty Optional
 
 Returns:
 
 LinkedListX generated by unfolder function
 - generate
```
static <T> LinkedListX<T> generate(long limit,
 java.util.function.Supplier<T> s)
```
 Generate a LinkedListX from the provided Supplier up toNested the provided limit number of times
 
 Parameters:
 
 limit - Max number of elements toNested generate
 
 s - Supplier toNested generate LinkedListX elements
 
 Returns:
 
 LinkedListX generated from the provided Supplier
 - fill
```
static <T> LinkedListX<T> fill(long limit,
 T s)
```
 Generate a LinkedListX from the provided value up toNested the provided limit number of times
 
 Parameters:
 
 limit - Max number of elements toNested generate
 
 s - Value for LinkedListX elements
 
 Returns:
 
 LinkedListX generated from the provided Supplier
 - iterate
```
static <T> LinkedListX<T> iterate(long limit,
 T seed,
 java.util.function.UnaryOperator<T> f)
```
 Create a LinkedListX by iterative application of a function toNested an initial element up toNested the supplied limit number of times
 
 Parameters:
 
 limit - Max number of elements toNested generate
 
 seed - Initial element
 
 f - Iteratively applied toNested each element toNested generate the next element
 
 Returns:
 
 LinkedListX generated by iterative application
 - type
```
LinkedListX<T> type(Reducer<? extends org.pcollections.PStack<T>> reducer)
```
 - linkedListX
```
static <T> LinkedListX<T> linkedListX(ReactiveSeq<T> stream)
```
```
 
 import static cyclops.stream.ReactiveSeq.range;

 LinkedListX<Integer> bag = linkedListX(range(10,20));

 
 
```
 Type Parameters:
 
 T - LinkedListX generated from Stream
 
 Parameters:
 
 stream - To create LinkedListX from
 
 Returns:
 - of
```
@SafeVarargs
static <T> LinkedListX<T> of(T... values)
```
 Construct a Persistent LinkedList from the provided values
```
 
 List<String> list = LinkedListX.of("a","b","c");
 
 // or
 
 PStack<String> list = LinkedListX.of("a","b","c");
 
 
 
 
```
 Parameters:
 
 values - To add toNested PStack
 
 Returns:
 
 new PStack
 - fromIterator
```
static <T> LinkedListX<T> fromIterator(java.util.Iterator<T> it)
```
 Construct a LinkedListX from the provided Iterator
 
 Parameters:
 
 it - Iterator toNested populate LinkedListX
 
 Returns:
 
 Newly populated LinkedListX
 - fromPublisher
```
static <T> LinkedListX<T> fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)
```
 Construct a LinkedListX from an Publisher
 
 Parameters:
 
 publisher - toNested construct LinkedListX from
 
 Returns:
 
 LinkedListX
 - fromIterable
```
static <T> LinkedListX<T> fromIterable(java.lang.Iterable<T> iterable)
```
 - empty
```
static <T> LinkedListX<T> empty()
```
```
 
 List<String> empty = PStack.empty();
 //or
 
 PStack<String> empty = PStack.empty();
 
 
```
 Returns:
 
 an empty PStack
 - singleton
```
static <T> LinkedListX<T> singleton(T value)
```
 Construct a PStack containing a single value List<String> single = PStacks.singleton("1"); //or PStack<String> single = PStacks.singleton("1");
 
 Parameters:
 
 value - Single value for PVector
 
 Returns:
 
 PVector with a single value
 - fromStream
```
default <T> LinkedListX<T> fromStream(ReactiveSeq<T> stream)
```
 Reduce (immutable Collection) a Stream toNested a PStack, note for efficiency reasons, the emitted PStack is reversed.
```
 
 PStack<Integer> list = PStacks.fromStream(Stream.of(1,2,3));
 
 //list = [3,2,1]
 
```
 Specified by:
 
 fromStream in interface LazyCollectionX<T>
 
 Parameters:
 
 stream - toNested convert toNested a PVector
 
 Returns:
 - anyM
```
default AnyMSeq<Witness.linkedListX,T> anyM()
```
 - materialize
```
default LinkedListX<T> materialize()
```
 Specified by:
 
 materialize in interface CollectionX<T>
 - forEach4
```
default <R1,R2,R3,R> LinkedListX<R> forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1,
 java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> stream2,
 Fn3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> stream3,
 Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
```
 Description copied from interface: CollectionX
 Perform a three level nested internal iteration over this Stream and the supplied streams
```
 
 
 //collectionX [1,2]
 
 collectionX.forEach4(a->ListX.range(10,13),
 (a,b)->ListX.of(""+(a+b),"hello world"),
 (a,b,c)->ListX.of(a,b,c)),
 (a,b,c,d)->c+":"a+":"+b);
 
 
 
```
 Specified by:
 
 forEach4 in interface CollectionX<T>
 
 Parameters:
 
 stream1 - Nested Stream toNested iterate over
 
 stream2 - Nested Stream toNested iterate over
 
 stream3 - Nested Stream toNested iterate over
 
 yieldingFunction - Function with pointers toNested the current element from both Streams that generates the new elements
 
 Returns:
 
 CollectionX with elements generated via nested iteration
 - forEach4
```
default <R1,R2,R3,R> LinkedListX<R> forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1,
 java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> stream2,
 Fn3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> stream3,
 Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
 Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
```
 Description copied from interface: CollectionX
 Perform a three level nested internal iteration over this Stream and the supplied streams
```
 
 //collectionX [1,2,3]
 
 collectionX.forEach4(a->ListX.range(10,13),
 (a,b)->ListX.of(""+(a+b),"hello world"),
 (a,b,c)->ListX.of(a,b,c),
 (a,b,c,d)-> c!=3,
 (a,b,c)->c+":"a+":"+b);
 
 
 
 
 
```
 Specified by:
 
 forEach4 in interface CollectionX<T>
 
 Parameters:
 
 stream1 - Nested Stream toNested iterate over
 
 stream2 - Nested Stream toNested iterate over
 
 stream3 - Nested Stream toNested iterate over
 
 filterFunction - Filter toNested apply over elements before passing non-filtered values toNested the yielding function
 
 yieldingFunction - Function with pointers toNested the current element from both Streams that generates the new elements
 
 Returns:
 
 CollectionX with elements generated via nested iteration
 - forEach3
```
default <R1,R2,R> LinkedListX<R> forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1,
 java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> stream2,
 Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
```
 Description copied from interface: CollectionX
 Perform a three level nested internal iteration over this Stream and the supplied streams
```
 
 
 //collectionX [1,2]
 
 collectionX.forEach3(a->IntStream.range(10,13),
 (a,b)->Stream.of(""+(a+b),"hello world"),
 (a,b,c)->c+":"a+":"+b);
 
 
 //CollectionX[11:1:2,hello world:1:2,14:1:4,hello world:1:4,12:1:2,hello world:1:2,15:1:5,hello world:1:5]
 
 
```
 Specified by:
 
 forEach3 in interface CollectionX<T>
 
 Parameters:
 
 stream1 - Nested Stream toNested iterate over
 
 stream2 - Nested Stream toNested iterate over
 
 yieldingFunction - Function with pointers toNested the current element from both Streams that generates the new elements
 
 Returns:
 
 ReactiveSeq with elements generated via nested iteration
 - forEach3
```
default <R1,R2,R> LinkedListX<R> forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1,
 java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> stream2,
 Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction,
 Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
```
 Description copied from interface: CollectionX
 Perform a three level nested internal iteration over this Stream and the supplied streams
```
 
 //collectionX [1,2,3]
 
 collectionX.forEach3(a->ListX.range(10,13),
 (a,b)->Stream.of(""+(a+b),"hello world"),
 (a,b,c)-> c!=3,
 (a,b,c)->c+":"a+":"+b);
 
 
 //CollectionX[11:1:2,hello world:1:2,14:1:4,hello world:1:4,12:1:2,hello world:1:2,15:1:5,hello world:1:5]
 
 
```
 Specified by:
 
 forEach3 in interface CollectionX<T>
 
 Parameters:
 
 stream1 - Nested Stream toNested iterate over
 
 stream2 - Nested Stream toNested iterate over
 
 filterFunction - Filter toNested apply over elements before passing non-filtered values toNested the yielding function
 
 yieldingFunction - Function with pointers toNested the current element from both Streams that generates the new elements
 
 Returns:
 
 ReactiveSeq with elements generated via nested iteration
 - forEach2
```
default <R1,R> LinkedListX<R> forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1,
 java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
```
 Description copied from interface: CollectionX
 Perform a two level nested internal iteration over this Stream and the supplied reactiveStream
```
 
 //collectionX [1,2,3]
 
 collectionX.of(1,2,3).forEach2(a->ListX.range(10,13),
 (a,b)->a+b);
 
 
 //ReactiveSeq[11,14,12,15,13,16]
 
 
```
 Specified by:
 
 forEach2 in interface CollectionX<T>
 
 Parameters:
 
 stream1 - Nested Iterable toNested iterate over
 
 yieldingFunction - Function with pointers toNested the current element from both Streams that generates the new elements
 
 Returns:
 
 ReactiveSeq with elements generated via nested iteration
 - forEach2
```
default <R1,R> LinkedListX<R> forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1,
 java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction,
 java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
```
 Description copied from interface: CollectionX
 Perform a two level nested internal iteration over this Stream and the supplied reactiveStream
```
 
 
 //collectionX [1,2,3]
 
 collectionX.of(1,2,3).forEach2(a->ListX.range(10,13),
 (a,b)-> a<3 && b>10,
 (a,b)->a+b);
 
 
 //CollectionX[14,15]
 
 
```
 Specified by:
 
 forEach2 in interface CollectionX<T>
 
 Parameters:
 
 stream1 - Nested Stream toNested iterate over
 
 filterFunction - Filter toNested apply over elements before passing non-filtered values toNested the yielding function
 
 yieldingFunction - Function with pointers toNested the current element from both Streams that generates the new elements
 
 Returns:
 
 ReactiveSeq with elements generated via nested iteration
 - take
```
default LinkedListX<T> take(long num)
```
 Description copied from interface: Traversable
```
 assertThat(ReactiveSeq.of(4,3,6,7).take(2).toList(),equalTo(Arrays.asList(4,3));
 
```
 Specified by:
 
 take in interface CollectionX<T>
 
 Specified by:
 
 take in interface Traversable<T>
 
 Parameters:
 
 num - Limit element size toNested num
 
 Returns:
 
 Monad converted toNested Stream with elements up toNested num
 - drop
```
default LinkedListX<T> drop(long num)
```
 Description copied from interface: Traversable
```
 assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7))); 
 
```
 Specified by:
 
 drop in interface CollectionX<T>
 
 Specified by:
 
 drop in interface Traversable<T>
 
 Parameters:
 
 num - Number of elemenets toNested drop
 
 Returns:
 
 Traversable with specified number of elements skipped
 - coflatMap
```
default <R> LinkedListX<R> coflatMap(java.util.function.Function<? super LinkedListX<T>,? extends R> fn)
```
 coflatMap pattern, can be used toNested perform maybe reductions / collections / folds and other terminal operations
```
 
 
 LinkedListX.of(1,2,3)
 .map(i->i*2)
 .coflatMap(s -> s.reduce(0,(a,b)->a+b))
 
 //LinkedListX[12]
 
 
```
 Parameters:
 
 fn - mapping function
 
 Returns:
 
 Transformed LinkedListX
 - combine
```
default LinkedListX<T> combine(java.util.function.BiPredicate<? super T,? super T> predicate,
 java.util.function.BinaryOperator<T> op)
```
 Combine two adjacent elements in a LinkedListX using the supplied BinaryOperator This is a stateful grouping & reduction operation. The emitted of a combination may in turn be combined with it's neighbor
```
 
 LinkedListX.of(1,1,2,3)
 .combine((a, b)->a.equals(b),Semigroups.intSum)
 .listX()
 
 //ListX(3,4) 
 
```
 Specified by:
 
 combine in interface CollectionX<T>
 
 Specified by:
 
 combine in interface LazyCollectionX<T>
 
 Specified by:
 
 combine in interface Traversable<T>
 
 Parameters:
 
 predicate - Test toNested see if two neighbors should be joined
 
 op - Reducer toNested combine neighbors
 
 Returns:
 
 Combined / Partially Reduced LinkedListX
 - combine
```
default LinkedListX<T> combine(Monoid<T> op,
 java.util.function.BiPredicate<? super T,? super T> predicate)
```
 Description copied from interface: Traversable
 Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation. The emitted of a combination may in turn be combined with it's neighbour
```
 
 ReactiveSeq.of(1,1,2,3)
 .combine(Monoids.intMult,(a, b)->a.equals(b))
 .listX()

 //ListX(1)
 
```
 Simalar toNested @see Traversable.combine(BiPredicate, BinaryOperator) but differs in that the first comparison is always toNested the Monoid zero This allows us toNested terminate with just a single value
 Specified by:
 
 combine in interface Traversable<T>
 
 Parameters:
 
 op - Monoid toNested combine neighbours
 
 predicate - Test toNested see if two neighbours should be joined. The first parameter toNested the bi-predicate is the currently accumulated result and the second is the next element
 
 Returns:
 
 Combined / Partially Reduced Traversable
 - unit
```
default <R> LinkedListX<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>
 
 Parameters:
 
 col - Collection data to populate the new collection
 
 Returns:
 
 Collection as the same type as this collection
 - unit
```
default <R> LinkedListX<R> unit(R value)
```
 Specified by:
 
 unit in interface CollectionX<T>
 
 Specified by:
 
 unit in interface Unit<T>
 - unitIterator
```
default <R> LinkedListX<R> unitIterator(java.util.Iterator<R> it)
```
 Description copied from interface: Traversable
 Create an IterableFunctor instance of the same type from an Iterator
```
 
 ReactiveSeq<Integer> newSeq = seq.unitIterable(myIterator);

 
 
```
 Specified by:
 
 unitIterator in interface Traversable<T>
 
 Parameters:
 
 it - Iterator toNested create new IterableFunctor from
 
 Returns:
 
 New IterableFunctor instance
 - emptyUnit
```
default <R> LinkedListX<R> emptyUnit()
```
 - plusInOrder
```
default LinkedListX<T> plusInOrder(T e)
```
 Description copied from interface: FluentCollectionX
 
 Add an element to the collection
 
 Specified by:
 
 plusInOrder in interface FluentCollectionX<T>
 
 Parameters:
 
 e - Element to add
 
 Returns:
 
 Collection with element added
 - stream
```
default ReactiveSeq<T> stream()
```
 Specified by:
 
 stream in interface java.util.Collection<T>
 
 Specified by:
 
 stream in interface CollectionX<T>
 
 Specified by:
 
 stream in interface ExtendedTraversable<T>
 
 Specified by:
 
 stream in interface FoldableTraversable<T>
 
 Specified by:
 
 stream in interface Folds<T>
 
 Specified by:
 
 stream in interface Sequential<T>
 
 Specified by:
 
 stream in interface TransformerTraversable<T>
 
 Specified by:
 
 stream in interface Traversable<T>
 
 Returns:
 
 This Traversable converted toNested a Stream
 - from
```
default <X> LinkedListX<X> from(java.util.Collection<X> col)
```
 Description copied from interface: CollectionX
 
 Conctruct an Extended Collection from a standard Collection
 
 Specified by:
 
 from in interface CollectionX<T>
 
 Parameters:
 
 col - Collection toNested extend
 
 Returns:
 
 Extended Collection
 - monoid
```
default <T> Reducer<org.pcollections.PStack<T>> monoid()
```
 - reverse
```
default LinkedListX<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 toNested 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 LazyCollectionX<T>
 
 Specified by:
 
 reverse in interface Traversable<T>
 - filter
```
default LinkedListX<T> filter(java.util.function.Predicate<? super T> pred)
```
 Description copied from interface: Filters
 Keep only elements for which the supplied predicates hold e.g.
```
 
 
 of(1,2,3).filter(i->i>2);
 
 //[3]
 
 
 
```
 Specified by:
 
 filter in interface CollectionX<T>
 
 Specified by:
 
 filter in interface FilterableTransformable<T>
 
 Specified by:
 
 filter in interface Filters<T>
 
 Specified by:
 
 filter in interface IndexedSequenceX<T>
 
 Specified by:
 
 filter in interface LazyCollectionX<T>
 
 Parameters:
 
 pred - toNested filter elements by, retaining matches
 
 Returns:
 
 Filters with elements removed where the predicate does not hold
 - map
```
default <R> LinkedListX<R> map(java.util.function.Function<? super T,? extends R> mapper)
```
 Description copied from interface: Transformable
 Transform this functor using the supplied transformation function
```
 


 of(1,2,3).map(i->i*2)

 //[2,4,6]

 
 
```
 Specified by:
 
 map in interface CollectionX<T>
 
 Specified by:
 
 map in interface FilterableTransformable<T>
 
 Specified by:
 
 map in interface IndexedSequenceX<T>
 
 Specified by:
 
 map in interface LazyCollectionX<T>
 
 Specified by:
 
 map in interface Transformable<T>
 
 Parameters:
 
 mapper - Transformation function
 
 Returns:
 
 Transformed Transformable
 - flatMap
```
default <R> LinkedListX<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 IndexedSequenceX<T>
 
 Specified by:
 
 flatMap in interface LazyCollectionX<T>
 
 Parameters:
 
 mapper - Transformation function toNested be applied (and flattened)
 
 Returns:
 
 A collection containing the flattened results of the transformation function
 - limit
```
default LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 limit in interface Traversable<T>
 
 Parameters:
 
 num - Limit element size toNested num
 
 Returns:
 
 Monad converted toNested Stream with elements up toNested num
 - skip
```
default LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 skip in interface Traversable<T>
 
 Parameters:
 
 num - Number of elemenets toNested skip
 
 Returns:
 
 Stream with specified number of elements skipped
 - takeRight
```
default LinkedListX<T> takeRight(int num)
```
 Description copied from interface: Traversable
 Generate a new Traversable that takes the specified number elements from the take of this Traversable
```
 
 ListX.of(1,2,3).takeRight(2);
 //[2,3]
 
 
```
 Specified by:
 
 takeRight in interface CollectionX<T>
 
 Specified by:
 
 takeRight in interface LazyCollectionX<T>
 
 Specified by:
 
 takeRight in interface Traversable<T>
 
 Parameters:
 
 num - Take this number of elements from the take of this Traversable
 
 Returns:
 
 Traversable generated by application of the predicate toNested the elements in this Traversable in order
 - dropRight
```
default LinkedListX<T> dropRight(int num)
```
 Description copied from interface: Traversable
 Generate a new Traversable that drops the specified number elements from the take of this Traversable
```
 
 ListX.of(1,2,3).dropRight(2);
 //[1]
 
 
```
 Specified by:
 
 dropRight in interface CollectionX<T>
 
 Specified by:
 
 dropRight in interface LazyCollectionX<T>
 
 Specified by:
 
 dropRight in interface Traversable<T>
 
 Parameters:
 
 num - Drop this number of elements from the take of this Traversable
 
 Returns:
 
 Traversable generated by application of the predicate toNested the elements in this Traversable in order
 - takeWhile
```
default LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 takeWhile in interface Traversable<T>
 
 Parameters:
 
 p - Predicate toNested determine when values should be taken
 
 Returns:
 
 Traversable generated by application of the predicate toNested the elements in this Traversable in order
 - dropWhile
```
default LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 dropWhile in interface Traversable<T>
 
 Parameters:
 
 p - Predicate toNested determine when values should be dropped
 
 Returns:
 
 Traversable generated by application of the predicate toNested the elements in this Traversable in order
 - takeUntil
```
default LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 takeUntil in interface Traversable<T>
 
 Parameters:
 
 p - Predicate toNested determine when values should be taken until
 
 Returns:
 
 Traversable generated by application of the predicate toNested the elements in this Traversable in order
 - dropUntil
```
default LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 dropUntil in interface Traversable<T>
 
 Parameters:
 
 p - Predicate toNested determine when values should be dropped
 
 Returns:
 
 Traversable generated by application of the predicate toNested the elements in this Traversable in order
 - trampoline
```
default <R> LinkedListX<R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)
```
 Description copied from interface: Transformable
 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 LazyCollectionX<T>
 
 Specified by:
 
 trampoline in interface Transformable<T>
 
 Parameters:
 
 mapper - TCO Transformation function
 
 Returns:
 
 Transformable transformed by the supplied transformation function
 - slice
```
default LinkedListX<T> slice(long from,
 long to)
```
 Specified by:
 
 slice in interface CollectionX<T>
 
 Specified by:
 
 slice in interface LazyCollectionX<T>
 
 Specified by:
 
 slice in interface Traversable<T>
 - sorted
```
default > LinkedListX<T> sorted(java.util.function.Function<? super T,? extends U> function)
```
 Specified by:
 
 sorted in interface CollectionX<T>
 
 Specified by:
 
 sorted in interface LazyCollectionX<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 - minusAll
```
LinkedListX<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 IndexedSequenceX<T>
 
 Specified by:
 
 minusAll in interface LazyCollectionX<T>
 
 Specified by:
 
 minusAll in interface org.pcollections.PCollection<T>
 
 Specified by:
 
 minusAll in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 minusAll in interface org.pcollections.PStack<T>
 
 Parameters:
 
 list - of elements to remove
 
 Returns:
 
 Collection with the elements removed
 - minus
```
LinkedListX<T> minus(java.lang.Object remove)
```
 Description copied from interface: FluentCollectionX
 
 Remove the specified element from this collection
 
 Specified by:
 
 minus in interface FluentCollectionX<T>
 
 Specified by:
 
 minus in interface IndexedSequenceX<T>
 
 Specified by:
 
 minus in interface LazyCollectionX<T>
 
 Specified by:
 
 minus in interface org.pcollections.PCollection<T>
 
 Specified by:
 
 minus in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 minus in interface org.pcollections.PStack<T>
 
 Parameters:
 
 remove - Element to remove
 
 Returns:
 
 Collection with element removed
 - with
```
LinkedListX<T> with(int i,
 T e)
```
 Description copied from interface: IndexedSequenceX
 
 Replace the value at the specifed index with the supplied value
 
 Specified by:
 
 with in interface IndexedSequenceX<T>
 
 Specified by:
 
 with in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 with in interface org.pcollections.PStack<T>
 
 Parameters:
 
 i -
 
 e -
 
 Returns:
 
 See Also:
 
 PStack.with(int, java.lang.Object)
 - plus
```
LinkedListX<T> plus(int i,
 T e)
```
 Description copied from interface: IndexedSequenceX
 
 Add the supplied element at the supplied index
 
 Specified by:
 
 plus in interface IndexedSequenceX<T>
 
 Specified by:
 
 plus in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 plus in interface org.pcollections.PStack<T>
 
 Parameters:
 
 i -
 
 e -
 
 Returns:
 
 See Also:
 
 PStack.plus(int, java.lang.Object)
 - plus
```
LinkedListX<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 IndexedSequenceX<T>
 
 Specified by:
 
 plus in interface LazyCollectionX<T>
 
 Specified by:
 
 plus in interface org.pcollections.PCollection<T>
 
 Specified by:
 
 plus in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 plus in interface org.pcollections.PStack<T>
 
 Parameters:
 
 e - Element to add
 
 Returns:
 
 Collection with element added
 - plusAll
```
LinkedListX<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 IndexedSequenceX<T>
 
 Specified by:
 
 plusAll in interface LazyCollectionX<T>
 
 Specified by:
 
 plusAll in interface org.pcollections.PCollection<T>
 
 Specified by:
 
 plusAll in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 plusAll in interface org.pcollections.PStack<T>
 
 Parameters:
 
 list - of elements to add
 
 Returns:
 
 Collection with elements added
 - plusAll
```
LinkedListX<T> plusAll(int i,
 java.util.Collection<? extends T> list)
```
 Description copied from interface: IndexedSequenceX
 
 Add all of the supplied elements at the supplied index
 
 Specified by:
 
 plusAll in interface IndexedSequenceX<T>
 
 Specified by:
 
 plusAll in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 plusAll in interface org.pcollections.PStack<T>
 
 Parameters:
 
 i -
 
 list -
 
 Returns:
 
 See Also:
 
 PStack.plusAll(int, java.util.Collection)
 - minus
```
LinkedListX<T> minus(int i)
```
 Description copied from interface: IndexedSequenceX
 
 Remove the element at the supplied index
 
 Specified by:
 
 minus in interface IndexedSequenceX<T>
 
 Specified by:
 
 minus in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 minus in interface org.pcollections.PStack<T>
 
 Parameters:
 
 i -
 
 Returns:
 
 See Also:
 
 PStack.minus(int)
 - subList
```
LinkedListX<T> subList(int start,
 int end)
```
 Description copied from interface: IndexedSequenceX
 
 Create a sub sequence between the two supplied index
 
 Specified by:
 
 subList in interface IndexedSequenceX<T>
 
 Specified by:
 
 subList in interface java.util.List<T>
 
 Specified by:
 
 subList in interface org.pcollections.PSequence<T>
 
 Specified by:
 
 subList in interface org.pcollections.PStack<T>
 
 Parameters:
 
 start - Index of our sub sequence (inclusive)
 
 end - Index of our sub sequence (exclusive)
 
 Returns:
 - grouped
```
default LinkedListX<ListX<T>> grouped(int groupSize)
```
 Description copied from interface: Traversable
 Group elements in a Stream
```
 
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).grouped(3).collect(CyclopsCollectors.toList());
 
 assertThat(list.get(0), hasItems(1, 2, 3));
 assertThat(list.get(1), hasItems(4, 5, 6));
 
 
 
```
 Specified by:
 
 grouped in interface CollectionX<T>
 
 Specified by:
 
 grouped in interface LazyCollectionX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 groupSize - Size of each Group
 
 Returns:
 
 Stream with elements grouped by size
 - grouped
```
default <K,A,D> LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 classifier - Grouping function
 
 downstream - Collector toNested create the grouping collection
 
 Returns:
 
 Traversable of grouped data
 - grouped
```
default <K> LinkedListX<org.jooq.lambda.tuple.Tuple2<K,ReactiveSeq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)
```
 Description copied from interface: Traversable
 
 Group this Traversable by the provided classifying function and collected by the provided Collector
 
 Specified by:
 
 grouped in interface CollectionX<T>
 
 Specified by:
 
 grouped in interface LazyCollectionX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 classifier - Grouping function
 
 Returns:
 
 Traversable of grouped data
 - zip
```
default  LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Collection toNested merge with this one
 
 Returns:
 
 Merged collection
 - zip
```
default <U,R> LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - toNested zip with
 
 zipper - Zip function
 
 Returns:
 
 Combined zippable
 - zipS
```
default <U,R> LinkedListX<R> zipS(java.util.stream.Stream<? extends U> other,
 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
 
 Specified by:
 
 zipS in interface CollectionX<T>
 
 Specified by:
 
 zipS in interface LazyCollectionX<T>
 
 Specified by:
 
 zipS in interface Zippable<T>
 
 Parameters:
 
 other - Stream toNested combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - permutations
```
default LinkedListX<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 ExtendedTraversable<T>
 
 Specified by:
 
 permutations in interface LazyCollectionX<T>
 
 Returns:
 
 Permutations from this ExtendedTraversable
 - combinations
```
default LinkedListX<ReactiveSeq<T>> combinations(int size)
```
 Description copied from interface: ExtendedTraversable
 Generate the combinations based on values in the ExtendedTraversable.
```
 
 ExtendedTraversable<Integer> reactiveStream = ReactiveSeq.of(1,2,3);
 reactiveStream.combinations(2)
 
 //ReactiveSeq[ReactiveSeq[1,2],ReactiveSeq[1,3],ReactiveSeq[2,3]]
 
 
```
 Specified by:
 
 combinations in interface CollectionX<T>
 
 Specified by:
 
 combinations in interface ExtendedTraversable<T>
 
 Specified by:
 
 combinations in interface LazyCollectionX<T>
 
 Parameters:
 
 size - of combinations
 
 Returns:
 
 All combinations of the elements in this ExtendedTraversable of the specified size
 - combinations
```
default LinkedListX<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 ExtendedTraversable<T>
 
 Specified by:
 
 combinations in interface LazyCollectionX<T>
 
 Returns:
 
 All combinations of the elements in this ExtendedTraversable
 - sliding
```
default LinkedListX<VectorX<T>> sliding(int windowSize)
```
 Description copied from interface: Traversable
 Create a sliding view over this Sequence
```
 
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(2).collect(CyclopsCollectors.toList());
 
 assertThat(list.get(0), hasItems(1, 2));
 assertThat(list.get(1), hasItems(2, 3));
 
 
 
 
```
 Specified by:
 
 sliding in interface CollectionX<T>
 
 Specified by:
 
 sliding in interface LazyCollectionX<T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Parameters:
 
 windowSize - Size of sliding window
 
 Returns:
 
 SequenceM with sliding view
 - sliding
```
default LinkedListX<VectorX<T>> sliding(int windowSize,
 int increment)
```
 Description copied from interface: Traversable
 Create a sliding view over this Sequence
```
 
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(3, 2).collect(CyclopsCollectors.toList());
 
 assertThat(list.get(0), hasItems(1, 2, 3));
 assertThat(list.get(1), hasItems(3, 4, 5)); 
 
 
 
 
 
```
 Specified by:
 
 sliding in interface CollectionX<T>
 
 Specified by:
 
 sliding in interface LazyCollectionX<T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Parameters:
 
 windowSize - number of elements in each batch
 
 increment - for each window
 
 Returns:
 
 SequenceM with sliding view
 - scanLeft
```
default  LinkedListX 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 LazyCollectionX<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 - scanRight
```
default  LinkedListX 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 LazyCollectionX<T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 - scanLeft
```
default LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 
 Returns:
 - scanRight
```
default LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 - cycle
```
default LinkedListX<T> cycle(long times)
```
 Description copied from interface: Traversable
 Convert toNested a Stream with the values repeated specified times
```
 
 		ReactiveSeq.of(1,2,2)
 								.cycle(3)
 								.collect(CyclopsCollectors.toList());
 								
 		//List[1,2,2,1,2,2,1,2,2]
 
 
 
```
 Specified by:
 
 cycle in interface CollectionX<T>
 
 Specified by:
 
 cycle in interface LazyCollectionX<T>
 
 Specified by:
 
 cycle in interface Traversable<T>
 
 Parameters:
 
 times - Times values should be repeated within a Stream
 
 Returns:
 
 Stream with values repeated
 - cycle
```
default LinkedListX<T> cycle(Monoid<T> m,
 long times)
```
 Description copied from interface: Traversable
 Convert toNested a Stream with the result of a reduction operation repeated specified times
```
 
 List<Integer> list = ReactiveSeq.of(1,2,2))
 .cycle(Reducers.toCountInt(),3)
 .collect(CyclopsCollectors.toList());
 //List[3,3,3];
 
 
```
 Specified by:
 
 cycle in interface CollectionX<T>
 
 Specified by:
 
 cycle in interface LazyCollectionX<T>
 
 Specified by:
 
 cycle in interface Traversable<T>
 
 Parameters:
 
 m - Monoid toNested be used in reduction
 
 times - Number of times value should be repeated
 
 Returns:
 
 Stream with reduced values repeated
 - cycleWhile
```
default LinkedListX<T> cycleWhile(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Repeat in a Stream while specified predicate holds
```
 
 MutableInt count = MutableInt.of(0);
 ReactiveSeq.of(1, 2, 2).cycleWhile(next -> count++ < 6).collect(CyclopsCollectors.toList());
 
 // List(1,2,2,1,2,2)
 
 
```
 Specified by:
 
 cycleWhile in interface CollectionX<T>
 
 Specified by:
 
 cycleWhile in interface LazyCollectionX<T>
 
 Specified by:
 
 cycleWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - cycleUntil
```
default LinkedListX<T> cycleUntil(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Repeat in a Stream until specified predicate holds
```
 
 	MutableInt count =MutableInt.of(0);
 		ReactiveSeq.of(1,2,2)
 		 		.cycleUntil(next -> count.get()>6)
 		 		.peek(i-> count.mutate(i->i+1))
 		 		.collect(CyclopsCollectors.toList());
 
 		//List[1,2,2,1,2,2,1]	
 
 
```
 Specified by:
 
 cycleUntil in interface CollectionX<T>
 
 Specified by:
 
 cycleUntil in interface LazyCollectionX<T>
 
 Specified by:
 
 cycleUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - zipS
```
default  LinkedListX<org.jooq.lambda.tuple.Tuple2<T,U>> zipS(java.util.stream.Stream<? extends U> other)
```
 Description copied from interface: Traversable
 
 Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2
 
 Specified by:
 
 zipS in interface CollectionX<T>
 
 Specified by:
 
 zipS in interface LazyCollectionX<T>
 
 Specified by:
 
 zipS in interface Traversable<T>
 
 Specified by:
 
 zipS in interface Zippable<T>
 
 Parameters:
 
 other - Stream toNested combine with
 
 Returns:
 
 Combined Zippable
 - zip3
```
default <S,U> LinkedListX<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.lang.Iterable<? extends S> second,
 java.lang.Iterable<? extends U> third)
```
 Description copied from interface: Traversable
 zip 3 Streams into one
```
 
 List<Tuple3<Integer, Integer, Character>> list = of(1, 2, 3, 4, 5, 6).zip3(of(100, 200, 300, 400), of('a', 'b', 'c')).collect(CyclopsCollectors.toList());
 
 // [[1,100,'a'],[2,200,'b'],[3,300,'c']]
 
 
 
```
 Specified by:
 
 zip3 in interface CollectionX<T>
 
 Specified by:
 
 zip3 in interface LazyCollectionX<T>
 
 Specified by:
 
 zip3 in interface Traversable<T>
 
 Specified by:
 
 zip3 in interface Zippable<T>
 - zip4
```
default <T2,T3,T4> LinkedListX<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.lang.Iterable<? extends T2> second,
 java.lang.Iterable<? extends T3> third,
 java.lang.Iterable<? extends T4> fourth)
```
 Description copied from interface: Traversable
 zip 4 Streams into 1
```
 
 List<Tuple4<Integer, Integer, Character, String>> list = of(1, 2, 3, 4, 5, 6).zip4(of(100, 200, 300, 400), of('a', 'b', 'c'), of("hello", "world"))
 .collect(CyclopsCollectors.toList());
 
 
 // [[1,100,'a',"hello"],[2,200,'b',"world"]]
 
```
 Specified by:
 
 zip4 in interface CollectionX<T>
 
 Specified by:
 
 zip4 in interface LazyCollectionX<T>
 
 Specified by:
 
 zip4 in interface Traversable<T>
 
 Specified by:
 
 zip4 in interface Zippable<T>
 - zipWithIndex
```
default LinkedListX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()
```
 Description copied from interface: Traversable
 Add an index toNested 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 LazyCollectionX<T>
 
 Specified by:
 
 zipWithIndex in interface Traversable<T>
 - distinct
```
default LinkedListX<T> distinct()
```
 Specified by:
 
 distinct in interface CollectionX<T>
 
 Specified by:
 
 distinct in interface LazyCollectionX<T>
 
 Specified by:
 
 distinct in interface Traversable<T>
 - sorted
```
default LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 - sorted
```
default LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 
 Parameters:
 
 c - Compartor toNested sort with
 
 Returns:
 
 Sorted Stream
 - skipWhile
```
default LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 skipWhile in interface Traversable<T>
 
 Parameters:
 
 p - Predicate toNested skip while true
 
 Returns:
 
 Stream with elements skipped while predicate holds
 - skipUntil
```
default LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 skipUntil in interface Traversable<T>
 
 Parameters:
 
 p - Predicate toNested skip until true
 
 Returns:
 
 Stream with elements skipped until predicate holds
 - limitWhile
```
default LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 limitWhile in interface Traversable<T>
 
 Parameters:
 
 p - Limit while predicate is true
 
 Returns:
 
 Stream with limited elements
 - limitUntil
```
default LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 limitUntil in interface Traversable<T>
 
 Parameters:
 
 p - Limit until predicate is true
 
 Returns:
 
 Stream with limited elements
 - intersperse
```
default LinkedListX<T> intersperse(T value)
```
 Description copied from interface: Traversable
 
 Returns a reactiveStream with a given value interspersed between any two values of this reactiveStream. // (1, 0, 2, 0, 3, 0, 4) ReactiveSeq.of(1, 2, 3, 4).intersperse(0)
 
 Specified by:
 
 intersperse in interface CollectionX<T>
 
 Specified by:
 
 intersperse in interface LazyCollectionX<T>
 
 Specified by:
 
 intersperse in interface Traversable<T>
 - shuffle
```
default LinkedListX<T> shuffle()
```
 Specified by:
 
 shuffle in interface CollectionX<T>
 
 Specified by:
 
 shuffle in interface LazyCollectionX<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 - skipLast
```
default LinkedListX<T> skipLast(int num)
```
 Description copied from interface: Traversable
 
 assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(1,2,3)));
 
 Specified by:
 
 skipLast in interface CollectionX<T>
 
 Specified by:
 
 skipLast in interface LazyCollectionX<T>
 
 Specified by:
 
 skipLast in interface Traversable<T>
 
 Returns:
 - limitLast
```
default LinkedListX<T> limitLast(int num)
```
 Description copied from interface: Traversable
 Limit results toNested the last x elements in a SequenceM
```
 
 	assertThat(ReactiveSeq.of(1,2,3,4,5)
 							.limitLast(2)
 							.collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(4,5)));
 
 
 
```
 Specified by:
 
 limitLast in interface CollectionX<T>
 
 Specified by:
 
 limitLast in interface LazyCollectionX<T>
 
 Specified by:
 
 limitLast in interface Traversable<T>
 
 Parameters:
 
 num - of elements toNested return (last elements)
 
 Returns:
 
 SequenceM limited toNested last num elements
 - onEmptySwitch
```
default LinkedListX<T> onEmptySwitch(java.util.function.Supplier<? extends org.pcollections.PStack<T>> supplier)
```
 Description copied from interface: OnEmptySwitch
 Switch toNested container created by provided Supplier, if current Container empty
```
 
 ListX.empty().onEmptySwitch(()->ListX.of(1));
 
 
```
 Specified by:
 
 onEmptySwitch in interface OnEmptySwitch<T,org.pcollections.PStack<T>>
 
 Parameters:
 
 supplier - toNested create replacement container
 
 Returns:
 
 Either this container or if empty, an alternative returned by the provided supplier
 - onEmpty
```
default LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 onEmpty in interface OnEmpty<T>
 
 Specified by:
 
 onEmpty in interface Traversable<T>
 
 Returns:
 
 New instance containing value if container is empty, otherwise returns this container
 - onEmptyGet
```
default LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 onEmptyGet in interface OnEmpty<T>
 
 Specified by:
 
 onEmptyGet in interface Traversable<T>
 
 Parameters:
 
 supplier - toNested determine new value for container
 
 Returns:
 
 New Container with value if this is empty, otherwise this container
 - onEmptyThrow
```
default <X extends java.lang.Throwable> LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 onEmptyThrow in interface OnEmpty<T>
 
 Specified by:
 
 onEmptyThrow in interface Traversable<T>
 
 Parameters:
 
 supplier - toNested create exception from
 
 Returns:
 
 Throw exception if empty, otherwise this container
 - shuffle
```
default LinkedListX<T> shuffle(java.util.Random random)
```
 Specified by:
 
 shuffle in interface CollectionX<T>
 
 Specified by:
 
 shuffle in interface LazyCollectionX<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 - ofType
```
default  LinkedListX ofType(java.lang.Class<? extends U> type)
```
 Description copied from interface: Filters
 Keep only those elements in a reactiveStream that are of a given type.
```
 
 
 // (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)
 
 
 
```
 Specified by:
 
 ofType in interface Filters<T>
 
 Specified by:
 
 ofType in interface LazyCollectionX<T>
 - filterNot
```
default LinkedListX<T> filterNot(java.util.function.Predicate<? super T> fn)
```
 Description copied from interface: Filters
 Remove any elements for which the predicate holds (inverse operation toNested 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 Filters<T>
 
 Specified by:
 
 filterNot in interface LazyCollectionX<T>
 
 Parameters:
 
 fn - toNested filter elements by, retaining matches
 
 Returns:
 
 Filters with elements removed where the predicate does not hold
 - notNull
```
default LinkedListX<T> notNull()
```
 Description copied from interface: Filters
 Filter elements retaining only values which are not null
```
 
 
 of(1,2,null,4).nonNull();
 
 //[1,2,4]
 
 
 
```
 Specified by:
 
 notNull in interface CollectionX<T>
 
 Specified by:
 
 notNull in interface Filters<T>
 
 Specified by:
 
 notNull in interface LazyCollectionX<T>
 
 Returns:
 
 Filters with nulls removed
 - removeAllS
```
default LinkedListX<T> removeAllS(java.util.stream.Stream<? extends T> stream)
```
 Description copied from interface: IterableFilterable
 
 Remove all elements in the supplied Stream from this filterable
 
 Specified by:
 
 removeAllS in interface CollectionX<T>
 
 Specified by:
 
 removeAllS in interface IterableFilterable<T>
 
 Specified by:
 
 removeAllS in interface LazyCollectionX<T>
 
 Parameters:
 
 stream - of elements toNested remove
 
 Returns:
 
 Filters with all supplied elements removed
 - removeAllI
```
default LinkedListX<T> removeAllI(java.lang.Iterable<? extends T> it)
```
 Description copied from interface: IterableFilterable
 
 Remove all elements in the supplied Iterable from this filterable
 
 Specified by:
 
 removeAllI in interface CollectionX<T>
 
 Specified by:
 
 removeAllI in interface IterableFilterable<T>
 
 Specified by:
 
 removeAllI in interface LazyCollectionX<T>
 
 Parameters:
 
 it - an Iterable of elements toNested remove
 
 Returns:
 
 Filters with all supplied elements removed
 - removeAll
```
default LinkedListX<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 IterableFilterable<T>
 
 Specified by:
 
 removeAll in interface LazyCollectionX<T>
 
 Parameters:
 
 values - toNested remove
 
 Returns:
 
 Filters with all supplied values removed
 - retainAllI
```
default LinkedListX<T> retainAllI(java.lang.Iterable<? extends T> it)
```
 Description copied from interface: IterableFilterable
 
 Retain only the supplied elements in the returned Filters
 
 Specified by:
 
 retainAllI in interface CollectionX<T>
 
 Specified by:
 
 retainAllI in interface IterableFilterable<T>
 
 Specified by:
 
 retainAllI in interface LazyCollectionX<T>
 
 Parameters:
 
 it - Iterable of elements toNested retain
 
 Returns:
 
 Filters with supplied values retained, and others removed
 - retainAllS
```
default LinkedListX<T> retainAllS(java.util.stream.Stream<? extends T> seq)
```
 Description copied from interface: IterableFilterable
 
 Retain only the supplied elements in the returned Filters
 
 Specified by:
 
 retainAllS in interface CollectionX<T>
 
 Specified by:
 
 retainAllS in interface IterableFilterable<T>
 
 Specified by:
 
 retainAllS in interface LazyCollectionX<T>
 
 Parameters:
 
 seq - of elements toNested retain
 
 Returns:
 
 Filters with supplied values retained, and others removed
 - retainAll
```
default LinkedListX<T> retainAll(T... values)
```
 Description copied from interface: IterableFilterable
 
 Retain only the supplied elements in the returned Filters
 
 Specified by:
 
 retainAll in interface CollectionX<T>
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Specified by:
 
 retainAll in interface LazyCollectionX<T>
 
 Parameters:
 
 values - elements toNested retain
 
 Returns:
 
 Filters with supplied values retained, and others removed
 - cast
```
default  LinkedListX cast(java.lang.Class<? extends U> type)
```
 Description copied from interface: Transformable
 
 Cast all elements in a reactiveStream toNested 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 LazyCollectionX<T>
 
 Specified by:
 
 cast in interface Transformable<T>
 - grouped
```
default <C extends java.util.Collection<? super T>> LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 size - batch size
 
 supplier - Collection factory
 
 Returns:
 
 SequenceM batched into collection types by size
 - groupedUntil
```
default LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, apply open next batch
 
 Returns:
 
 SequenceM batched into lists determined by the predicate supplied
 - groupedStatefullyUntil
```
default LinkedListX<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 toNested 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 LazyCollectionX<T>
 
 Specified by:
 
 groupedStatefullyUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Window while true
 
 Returns:
 
 Traversable windowed while predicate holds
 - groupedWhile
```
default LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, apply open next batch
 
 Returns:
 
 SequenceM batched into lists determined by the predicate supplied
 - groupedWhile
```
default <C extends java.util.Collection<? super T>> LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, apply open next batch
 
 factory - Collection factory
 
 Returns:
 
 SequenceM batched into collections determined by the predicate supplied
 - groupedUntil
```
default <C extends java.util.Collection<? super T>> LinkedListX<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 LazyCollectionX<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, apply open next batch
 
 factory - Collection factory
 
 Returns:
 
 SequenceM batched into collections determined by the predicate supplied
 - retry
```
default <R> LinkedListX<R> retry(java.util.function.Function<? super T,? extends R> fn)
```
 Description copied from interface: Transformable
 Retry a transformation if it fails. Default settings are toNested retry up toNested 7 times, with an doubling backoff period starting @ 2 seconds delay before retry.
```
 
 given(serviceMock.apply(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");


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

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


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

 		//result = 42
 
 
```
 Specified by:
 
 retry in interface Transformable<T>
 
 Parameters:
 
 fn - Function toNested retry if fails
 
 retries - Number of retries
 
 delay - Delay in TimeUnits
 
 timeUnit - TimeUnit toNested use for delay
 - flatMapS
```
default <R> LinkedListX<R> flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)
```
 Specified by:
 
 flatMapS in interface CollectionX<T>
 
 Specified by:
 
 flatMapS in interface LazyCollectionX<T>
 - flatMapP
```
default <R> LinkedListX<R> flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
```
 Specified by:
 
 flatMapP in interface CollectionX<T>
 
 Specified by:
 
 flatMapP in interface LazyCollectionX<T>
 - prependS
```
default LinkedListX<T> prependS(java.util.stream.Stream<? extends T> stream)
```
 Description copied from interface: Traversable
 Prepend Stream toNested this ReactiveSeq
```
 
 List<String> result = ReactiveSeq.of(1, 2, 3)
 .prependS(of(100, 200, 300))
 .map(it -> it + "!!")
 .collect(CyclopsCollectors.toList());

 assertThat(result, equalTo(Arrays.asList("100!!", "200!!", "300!!", "1!!", "2!!", "3!!")));
 
 
```
 Specified by:
 
 prependS in interface LazyCollectionX<T>
 
 Specified by:
 
 prependS in interface Traversable<T>
 
 Parameters:
 
 stream - toNested Prepend
 
 Returns:
 
 ReactiveSeq with Stream prepended
 - append
```
default LinkedListX<T> append(T... values)
```
 Description copied from interface: Traversable
 Append values toNested the take of this ReactiveSeq
```
 
 List<String> result = ReactiveSeq.of(1, 2, 3).append(100, 200, 300).map(it -> it + "!!").collect(CyclopsCollectors.toList());

 assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "3!!", "100!!", "200!!", "300!!"))); * 
 
```
 Specified by:
 
 append in interface LazyCollectionX<T>
 
 Specified by:
 
 append in interface Traversable<T>
 
 Parameters:
 
 values - toNested append
 
 Returns:
 
 ReactiveSeq with appended values
 - append
```
default LinkedListX<T> append(T value)
```
 Specified by:
 
 append in interface LazyCollectionX<T>
 
 Specified by:
 
 append in interface Traversable<T>
 - prepend
```
default LinkedListX<T> prepend(T value)
```
 Specified by:
 
 prepend in interface LazyCollectionX<T>
 
 Specified by:
 
 prepend in interface Traversable<T>
 - prepend
```
default LinkedListX<T> prepend(T... values)
```
 Description copied from interface: Traversable
 Prepend given values toNested the skip of the Stream
```
 
 List<String> result = 	ReactiveSeq.of(1,2,3)
 									 .prepend(100,200,300)
 										 .map(it ->it+"!!")
 										 .collect(CyclopsCollectors.toList());

 			assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
 
```
 Specified by:
 
 prepend in interface LazyCollectionX<T>
 
 Specified by:
 
 prepend in interface Traversable<T>
 
 Parameters:
 
 values - toNested prepend
 
 Returns:
 
 ReactiveSeq with values prepended
 - insertAt
```
default LinkedListX<T> insertAt(int pos,
 T... values)
```
 Description copied from interface: Traversable
 Insert data into a reactiveStream at given position
```
 
 List<String> result = ReactiveSeq.of(1, 2, 3).insertAt(1, 100, 200, 300).map(it -> it + "!!").collect(CyclopsCollectors.toList());

 assertThat(result, equalTo(Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!"))); *
 
 
```
 Specified by:
 
 insertAt in interface LazyCollectionX<T>
 
 Specified by:
 
 insertAt in interface Traversable<T>
 
 Parameters:
 
 pos - toNested insert data at
 
 values - toNested insert
 
 Returns:
 
 Stream with new data inserted
 - deleteBetween
```
default LinkedListX<T> deleteBetween(int start,
 int end)
```
 Description copied from interface: Traversable
 Delete elements between given indexes in a Stream
```
 
 List<String> result = ReactiveSeq.of(1, 2, 3, 4, 5, 6).deleteBetween(2, 4).map(it -> it + "!!").collect(CyclopsCollectors.toList());

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

 assertThat(result, equalTo(Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!")));
 
 
```
 Specified by:
 
 insertAtS in interface LazyCollectionX<T>
 
 Specified by:
 
 insertAtS in interface Traversable<T>
 
 Parameters:
 
 pos - toNested insert Stream at
 
 stream - toNested insert
 
 Returns:
 
 newly conjoined Traversable
 - recover
```
default LinkedListX<T> recover(java.util.function.Function<? super java.lang.Throwable,? extends T> fn)
```
 Description copied from interface: Traversable
 Recover from an exception with an alternative value
```
 
 assertThat(ReactiveSeq.of(1,2,3,4)
 						 .map(i->i+2)
 						 .map(u->{throw new RuntimeException();})
 						 .recover(e->"hello")
 						 .firstValue(),equalTo("hello"));
 
 
```
 Specified by:
 
 recover in interface Traversable<T>
 
 Parameters:
 
 fn - Function that accepts a Throwable and returns an alternative value
 
 Returns:
 
 ReactiveSeq that can recover from an Exception
 - recover
```
default <EX extends java.lang.Throwable> LinkedListX<T> recover(java.lang.Class<EX> exceptionClass,
 java.util.function.Function<? super EX,? extends T> fn)
```
 Description copied from interface: Traversable
 Recover from a particular exception type
```
 
 assertThat(ReactiveSeq.of(1,2,3,4)
 					.map(i->i+2)
 					.map(u->{ExceptionSoftener.throwSoftenedException( new IOException()); return null;})
 					.recover(IOException.class,e->"hello")
 					.firstValue(),equalTo("hello"));

 
 
```
 Specified by:
 
 recover in interface Traversable<T>
 
 Parameters:
 
 exceptionClass - Type toNested recover from
 
 fn - That accepts an error and returns an alternative value
 
 Returns:
 
 Traversable that can recover from a particular exception
 - plusLoop
```
default LinkedListX<T> plusLoop(int max,
 java.util.function.IntFunction<T> value)
```
 Specified by:
 
 plusLoop in interface FluentCollectionX<T>
 - plusLoop
```
default LinkedListX<T> plusLoop(java.util.function.Supplier<java.util.Optional<T>> supplier)
```
 Specified by:
 
 plusLoop in interface FluentCollectionX<T>

Interface LinkedListX<T>

Nested Class Summary

Method Summary

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

Methods inherited from interface org.pcollections.PStack

Methods inherited from interface org.pcollections.PSequence

Methods inherited from interface org.pcollections.PCollection

Methods inherited from interface java.util.List

Methods inherited from interface com.aol.cyclops2.data.collections.extensions.standard.LazyCollectionX

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

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

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

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

Methods inherited from interface java.lang.Iterable

Methods inherited from interface java.util.Collection

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

Methods inherited from interface com.aol.cyclops2.hkt.Higher

Methods inherited from interface com.aol.cyclops2.hkt.Convert

Method Detail

widen2

narrowK

liftM

narrow

range

rangeLong

unfold

generate

fill

iterate

type

linkedListX

of

fromIterator

fromPublisher

fromIterable

empty

singleton

fromStream

anyM

materialize

forEach4

forEach4

forEach3

forEach3

forEach2

forEach2

take

drop

coflatMap

combine

combine

unit

unit

unitIterator

emptyUnit

plusInOrder

stream

from

monoid

reverse

filter

map

flatMap

limit

skip

takeRight

dropRight

takeWhile

dropWhile

takeUntil

dropUntil

trampoline

slice

sorted

minusAll

minus

with

plus

plus

plusAll