Traversable (cyclops-react 2.0.0-MI6 API)

Type Parameters:

T - The data type of the elements in this Traversable

All Superinterfaces:

FilterableTransformable<T>, Filters<T>, java.lang.Iterable<T>, IterableFilterable<T>, OnEmpty<T>, org.reactivestreams.Publisher<T>, Sequential<T>, Transformable<T>, TransformerTraversable<T>, Zippable<T>

All Known Subinterfaces:

AnyMSeq<W,T>, BagX<T>, CollectionX<T>, DequeX<T>, ExtendedTraversable<T>, FluentCollectionX<T>, FoldableTransformerSeq<W,T>, FoldableTraversable<T>, FutureStream, IndexedSequenceX<T>, LazyCollectionX<T>, LazyFluentCollectionX<T>, LinkedListX<T>, ListX<T>, MutableSequenceX<T>, OrderedSetX<T>, PersistentQueueX<T>, PersistentSetX<T>, QueueX<T>, ReactiveSeq<T>, SetX<T>, SortedSetX<T>, Streamable<T>, TransformerSeq<W,T>, VectorX<T>

All Known Implementing Classes:

AbstractLazyCollection, AbstractLazyPersistentCollection, CollectionXImpl, LazyDequeX, LazyLinkedListX, LazyListX, LazyPBagX, LazyPOrderedSetX, LazyPQueueX, LazyPSetX, LazyPVectorX, LazyQueueX, LazySetX, LazySortedSetX, ListT, StreamT
```
public interface Traversable<T>
extends org.reactivestreams.Publisher<T>, OnEmpty<T>, Zippable<T>, IterableFilterable<T>, FilterableTransformable<T>, TransformerTraversable<T>, Sequential<T>
```
A non-scalar navigatable data type

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default Traversable<T>`	`append(T... values)` Append values toNested the take of this ReactiveSeq
`default Traversable<T>`	`append(T value)`
`default Traversable<T>`	`combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)` Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation.
`default Traversable<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 Traversable<T>`	`cycle(long times)` Convert toNested a Stream with the values repeated specified times
`default Traversable<T>`	`cycle(Monoid<T> m, long times)` Convert toNested a Stream with the result of a reduction operation repeated specified times
`default Traversable<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream until specified predicate holds
`default Traversable<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream while specified predicate holds
`default Traversable<T>`	`deleteBetween(int start, int end)` Delete elements between given indexes in a Stream
`default Traversable<T>`	`distinct()`
`default Traversable<T>`	`drop(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7)));`
`default Traversable<T>`	`dropRight(int num)` Generate a new Traversable that drops the specified number elements from the take of this Traversable
`default Traversable<T>`	`dropUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that drops elements from this Traversable until the predicate holds
`default Traversable<T>`	`dropWhile(java.util.function.Predicate<? super T> p)` Generate a new Traversable that drops elements from this Traversable as long as the predicate holds
`default <K> Traversable<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> Traversable<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 Traversable<ListX<T>>`	`grouped(int groupSize)` Group elements in a Stream
`default <C extends java.util.Collection<? super T>> Traversable<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 Traversable<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 Traversable<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>> Traversable<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 Traversable<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>> Traversable<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 Traversable<T>`	`insertAt(int pos, T... values)` Insert data into a reactiveStream at given position
`default Traversable<T>`	`insertAtS(int pos, java.util.stream.Stream<T> stream)` Insert a Stream into the middle of this reactiveStream at the specified position
`default Traversable<T>`	`intersperse(T value)` Returns a reactiveStream with a given value interspersed between any two values of this reactiveStream.
`default Traversable<T>`	`limit(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`default Traversable<T>`	`limitLast(int num)` Limit results toNested the last x elements in a SequenceM
`default Traversable<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 Traversable<T>`	`limitWhile(java.util.function.Predicate<? super T> p)` Take elements from the Stream while the predicate holds, once the predicate returns false all subsequent elements are excluded
`default java.util.stream.DoubleStream`	`mapToDouble(java.util.function.ToDoubleFunction<? super T> fn)`
`default java.util.stream.IntStream`	`mapToInt(java.util.function.ToIntFunction<? super T> fn)`
`default java.util.stream.LongStream`	`mapToLong(java.util.function.ToLongFunction<? super T> fn)`
`default Traversable<T>`	`onEmpty(T value)` If this Container instance is empty, create a new instance containing the provided value
`default Traversable<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 <X extends java.lang.Throwable> Traversable<T>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)` If this container instance is empty, throw the exception returned by the provided Supplier
`default Traversable<T>`	`prepend(T... values)` Prepend given values toNested the skip of the Stream
`default Traversable<T>`	`prepend(T value)`
`default Traversable<T>`	`prependS(java.util.stream.Stream<? extends T> stream)` Prepend Stream toNested this ReactiveSeq
`default <EX extends java.lang.Throwable> Traversable<T>`	`recover(java.lang.Class<EX> exceptionClass, java.util.function.Function<? super EX,? extends T> fn)` Recover from a particular exception type
`default Traversable<T>`	`recover(java.util.function.Function<? super java.lang.Throwable,? extends T> fn)` Recover from an exception with an alternative value
`default Traversable<T>`	`reverse()` Potentially efficient Stream reversal.
`default Traversable<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`default <U> Traversable<U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)` Scan left
`default Traversable<T>`	`scanRight(Monoid<T> monoid)` Scan right
`default <U> Traversable<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)` Scan right
`default Traversable<T>`	`shuffle()`
`default Traversable<T>`	`shuffle(java.util.Random random)`
`default Traversable<T>`	`skip(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`default Traversable<T>`	`skipLast(int num)` assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(1,2,3)));
`default Traversable<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 Traversable<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 Traversable<T>`	`slice(long from, long to)`
`default Traversable<VectorX<T>>`	`sliding(int windowSize)` Create a sliding view over this Sequence
`default Traversable<VectorX<T>>`	`sliding(int windowSize, int increment)` Create a sliding view over this Sequence
`default Traversable<T>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`default Traversable<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>> Traversable<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`default ReactiveSeq<T>`	`stream()`
`default void`	`subscribe(org.reactivestreams.Subscriber<? super T> s)`
`default Traversable<T>`	`take(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).take(2).toList(),equalTo(Arrays.asList(4,3));`
`default Traversable<T>`	`takeRight(int num)` Generate a new Traversable that takes the specified number elements from the take of this Traversable
`default Traversable<T>`	`takeUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that takes elements from this Traversable until the predicate holds
`default Traversable<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 Traversable<T>`	`traversable()`
`<U> Traversable<U>`	`unitIterator(java.util.Iterator<U> U)` Create an IterableFunctor instance of the same type from an Iterator
`default <U,R> Traversable<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> Traversable<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> Traversable<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> Traversable<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 Traversable<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.Zippable
zip, zip, zip3, zip4, zipP, zipP, zipS, zipWith, zipWithP, zipWithS

Methods inherited from interface com.aol.cyclops2.types.traversable.IterableFilterable
removeAll, removeAllI, removeAllS, retainAll, retainAllI, retainAllS

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

Methods inherited from interface com.aol.cyclops2.types.functor.FilterableTransformable
filter, map

Methods inherited from interface com.aol.cyclops2.types.Filters
filterNot, notNull, ofType

Methods inherited from interface com.aol.cyclops2.types.functor.Transformable
cast, peek, retry, retry, trampoline

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

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

Method Detail

mapToDouble

default java.util.stream.DoubleStream mapToDouble(java.util.function.ToDoubleFunction<? super T> fn)

mapToLong

default java.util.stream.LongStream mapToLong(java.util.function.ToLongFunction<? super T> fn)

mapToInt

default java.util.stream.IntStream mapToInt(java.util.function.ToIntFunction<? super T> fn)

stream
```
default ReactiveSeq<T> stream()
```
Specified by:

stream in interface Sequential<T>

Specified by:

stream in interface TransformerTraversable<T>

Returns:

This Traversable converted toNested a Stream

unitIterator
```
 Traversable unitIterator(java.util.Iterator U)
```
Create an IterableFunctor instance of the same type from an Iterator
```
 
 ReactiveSeq<Integer> newSeq = seq.unitIterable(myIterator);

 
 
```
Parameters:

U - Iterator toNested create new IterableFunctor from

Returns:

New IterableFunctor instance

subscribe
```
default void subscribe(org.reactivestreams.Subscriber<? super T> s)
```
Specified by:

subscribe in interface org.reactivestreams.Publisher<T>

combine
```
default Traversable<T> combine(java.util.function.BiPredicate<? super T,? super T> predicate,
 java.util.function.BinaryOperator<T> op)
```
Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation. The emitted of a combination may in turn be combined with it's neighbour
```
 
 ReactiveSeq.of(1,1,2,3)
 .combine((a, b)->a.equals(b),Semigroups.intSum)
 .listX()
 
 //ListX(3,4) 
 
```
Parameters:

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

op - BinaryOperator toNested combine neighbours

Returns:

Combined / Partially Reduced Traversable

combine
```
default Traversable<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. 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 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
Parameters:

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

op - Monoid toNested combine neighbours

Returns:

Combined / Partially Reduced Traversable

cycle

default Traversable<T> cycle(long times)

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]

Parameters:: times - Times values should be repeated within a Stream
Returns:: Stream with values repeated

cycle

default Traversable<T> cycle(Monoid<T> m,
                             long times)

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];

Parameters:: m - Monoid toNested be used in reduction; times - Number of times value should be repeated
Returns:: Stream with reduced values repeated

cycleWhile

default Traversable<T> cycleWhile(java.util.function.Predicate<? super T> predicate)

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)

Parameters:: predicate - repeat while true
Returns:: Repeating Stream

cycleUntil

default Traversable<T> cycleUntil(java.util.function.Predicate<? super T> predicate)

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]

Parameters:: predicate - repeat while true
Returns:: Repeating Stream

zip
```
default <U,R> Traversable<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 Zippable<T>

Parameters:

other - toNested zip with

zipper - Zip function

Returns:

Combined zippable

zip3

default <S,U> Traversable<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

 
  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 Zippable<T>

zip4

default <T2,T3,T4> Traversable<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

 
  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 Zippable<T>

zipWithIndex

default Traversable<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()

Add an index toNested the current Stream

  
 assertEquals(asList(new Tuple2("a", 0L), new Tuple2("b", 1L)), of("a", "b").zipWithIndex().toList());

sliding

default Traversable<VectorX<T>> sliding(int windowSize)

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));

Parameters:: windowSize - Size of sliding window
Returns:: SequenceM with sliding view

sliding

default Traversable<VectorX<T>> sliding(int windowSize,
                                        int increment)

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));

Parameters:: windowSize - number of elements in each batch; increment - for each window
Returns:: SequenceM with sliding view

grouped

default <C extends java.util.Collection<? super T>> Traversable<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

 
 assertThat(ReactiveSeq.of(1,1,1,1,1,1)
                      .batchBySize(3,()->new TreeSet<>())
                      .toList()
                      .get(0)
                      .size(),is(1));

Parameters:: size - batch size; supplier - Collection factory
Returns:: SequenceM batched into collection types by size

groupedUntil

default Traversable<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

  
  assertThat(ReactiveSeq.of(1,2,3,4,5,6)
              .groupedUntil(i->i%3==0)
              .toList()
              .size(),equalTo(2));

Parameters:: predicate - Batch until predicate holds, apply open next batch
Returns:: SequenceM batched into lists determined by the predicate supplied

groupedStatefullyUntil
```
default Traversable<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. 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));
 
 
```
Parameters:

predicate - Window while true

Returns:

Traversable windowed while predicate holds

zipS
```
default  Traversable<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

Specified by:

zipS in interface Zippable<T>

Parameters:

other - Stream toNested combine with

Returns:

Combined Zippable

groupedWhile
```
default Traversable<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
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .groupedWhile(i->i%3!=0)
 .toList().size(),equalTo(2));
 
 
 
```
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>> Traversable<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

  
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
              .batchWhile(i->i%3!=0)
              .toList()
              .size(),equalTo(2));

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>> Traversable<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

  
  ReactiveSeq.of(1,2,3,4,5,6)
             .groupedUntil(i->i%3!=0)
             .toList()
             
  //2

Parameters:: predicate - Batch until predicate holds, apply open next batch; factory - Collection factory
Returns:: SequenceM batched into collections determined by the predicate supplied

grouped

default Traversable<ListX<T>> grouped(int groupSize)

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));

Parameters:: groupSize - Size of each Group
Returns:: Stream with elements grouped by size

grouped

default <K,A,D> Traversable<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

Parameters:: classifier - Grouping function; downstream - Collector toNested create the grouping collection
Returns:: Traversable of grouped data

grouped
```
default <K> Traversable<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

Parameters:

classifier - Grouping function

Returns:

Traversable of grouped data

distinct
```
default Traversable<T> distinct()
```

scanLeft

default Traversable<T> scanLeft(Monoid<T> monoid)

Scan left using supplied Monoid

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

Parameters:: monoid -
Returns:

scanLeft

default <U> Traversable<U> scanLeft(U seed,
                                    java.util.function.BiFunction<? super U,? super T,? extends U> function)

Scan left

  
  assertThat(of("a", "b", "c").scanLeft("", String::concat).toList().size(),
         		is(4));

scanRight

default Traversable<T> scanRight(Monoid<T> monoid)

Scan right

  
 assertThat(of("a", "b", "c").scanRight(Monoid.of("", String::concat)).toList().size(),
             is(asList("", "c", "bc", "abc").size()));

scanRight

default <U> Traversable<U> scanRight(U identity,
                                     java.util.function.BiFunction<? super T,? super U,? extends U> combiner)

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()));

sorted

default Traversable<T> sorted()

  assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));

sorted

default Traversable<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)));

Parameters:: c - Compartor toNested sort with
Returns:: Sorted Stream

takeWhile
```
default Traversable<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
```
 
 ListX.of(1,2,3).takeWhile(i<3);
 //[1,2]
 
 
```
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 Traversable<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
```
 
 ListX.of(1,2,3).dropWhile(i<3);
 //[3]
 
 
```
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 Traversable<T> takeUntil(java.util.function.Predicate<? super T> p)
```
Generate a new Traversable that takes elements from this Traversable until the predicate holds
```
 
 ListX.of(1,2,3).takeUntil(i<2);
 //[1,2]
 
 
```
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 Traversable<T> dropUntil(java.util.function.Predicate<? super T> p)
```
Generate a new Traversable that drops elements from this Traversable until the predicate holds
```
 
 ListX.of(1,2,3).dropUntil(i>2);
 //[3]
 
 
```
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

dropRight
```
default Traversable<T> dropRight(int num)
```
Generate a new Traversable that drops the specified number elements from the take of this Traversable
```
 
 ListX.of(1,2,3).dropRight(2);
 //[1]
 
 
```
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

takeRight
```
default Traversable<T> takeRight(int num)
```
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]
 
 
```
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

drop

default Traversable<T> drop(long num)

  assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7)));

Parameters:: num - Number of elemenets toNested drop
Returns:: Traversable with specified number of elements skipped

skip

default Traversable<T> skip(long num)

  assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));

Parameters:: num - Number of elemenets toNested skip
Returns:: Stream with specified number of elements skipped

skipWhile
```
default Traversable<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 *
```
 
 assertThat(ReactiveSeq.of(4,3,6,7).sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));
 
 
```
Parameters:

p - Predicate toNested skip while true

Returns:

Stream with elements skipped while predicate holds

skipUntil
```
default Traversable<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
```
 assertThat(ReactiveSeq.of(4,3,6,7).skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));
 
```
Parameters:

p - Predicate toNested skip until true

Returns:

Stream with elements skipped until predicate holds

take

default Traversable<T> take(long num)

  assertThat(ReactiveSeq.of(4,3,6,7).take(2).toList(),equalTo(Arrays.asList(4,3));

Parameters:: num - Limit element size toNested num
Returns:: Monad converted toNested Stream with elements up toNested num

limit

default Traversable<T> limit(long num)

  assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));

Parameters:: num - Limit element size toNested num
Returns:: Monad converted toNested Stream with elements up toNested num

limitWhile
```
default Traversable<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
```
 assertThat(ReactiveSeq.of(4,3,6,7).sorted().limitWhile(i->i<6).toList(),equalTo(Arrays.asList(3,4)));
 
```
Parameters:

p - Limit while predicate is true

Returns:

Stream with limited elements

limitUntil
```
default Traversable<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.
```
 assertThat(ReactiveSeq.of(4,3,6,7).limitUntil(i->i==6).toList(),equalTo(Arrays.asList(4,3))); 
 
```
Parameters:

p - Limit until predicate is true

Returns:

Stream with limited elements

intersperse
```
default Traversable<T> intersperse(T value)
```
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)

reverse
```
default Traversable<T> reverse()
```
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))); 
```

shuffle
```
default Traversable<T> shuffle()
```

skipLast
```
default Traversable<T> skipLast(int num)
```
assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(1,2,3)));

Parameters:

num -

Returns:

limitLast

default Traversable<T> limitLast(int num)

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)));

Parameters:: num - of elements toNested return (last elements)
Returns:: SequenceM limited toNested last num elements

onEmpty
```
default Traversable<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 OnEmpty<T>

Returns:

New instance containing value if container is empty, otherwise returns this container

onEmptyGet
```
default Traversable<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 OnEmpty<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> Traversable<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 OnEmpty<T>

Parameters:

supplier - toNested create exception from

Returns:

Throw exception if empty, otherwise this container

shuffle

default Traversable<T> shuffle(java.util.Random random)

slice

default Traversable<T> slice(long from,
                             long to)

sorted

default <U extends java.lang.Comparable<? super U>> Traversable<T> sorted(java.util.function.Function<? super T,? extends U> function)

traversable
```
default Traversable<T> traversable()
```
Returns:

This Traversable converted toNested a Stream and type narrowed toNested Traversable

prependS

default Traversable<T> prependS(java.util.stream.Stream<? extends T> stream)

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!!")));

Parameters:: stream - toNested Prepend
Returns:: ReactiveSeq with Stream prepended

append

default Traversable<T> append(T... values)

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!!")));     *

Parameters:: values - toNested append
Returns:: ReactiveSeq with appended values

append

default Traversable<T> append(T value)

prepend

default Traversable<T> prepend(T value)

prepend

default Traversable<T> prepend(T... values)

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!!")));

Parameters:: values - toNested prepend
Returns:: ReactiveSeq with values prepended

insertAt

default Traversable<T> insertAt(int pos,
                                T... values)

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!!")));     *

Parameters:: pos - toNested insert data at; values - toNested insert
Returns:: Stream with new data inserted

deleteBetween

default Traversable<T> deleteBetween(int start,
                                     int end)

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!!")));     *

Parameters:: start - index; end - index
Returns:: Stream with elements removed

insertAtS

default Traversable<T> insertAtS(int pos,
                                 java.util.stream.Stream<T> stream)

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!!")));

Parameters:: pos - toNested insert Stream at; stream - toNested insert
Returns:: newly conjoined Traversable

recover

default Traversable<T> recover(java.util.function.Function<? super java.lang.Throwable,? extends T> fn)

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"));

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> Traversable<T> recover(java.lang.Class<EX> exceptionClass,
                                                                java.util.function.Function<? super EX,? extends T> fn)

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"));

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

Interface Traversable<T>

Method Summary

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

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

Methods inherited from interface java.lang.Iterable

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

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

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

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

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

Method Detail

mapToDouble

mapToLong

mapToInt

stream

unitIterator

subscribe

combine

combine

cycle

cycle

cycleWhile

cycleUntil

zip

zip3

zip4

zipWithIndex

sliding

sliding

grouped

groupedUntil

groupedStatefullyUntil

zipS

groupedWhile

groupedWhile

groupedUntil

grouped

grouped

grouped

distinct

scanLeft

scanLeft

scanRight

scanRight

sorted

sorted

takeWhile

dropWhile

takeUntil

dropUntil

dropRight

takeRight

drop

skip

skipWhile

skipUntil

take

limit

limitWhile

limitUntil

intersperse

reverse

shuffle

skipLast

limitLast

onEmpty

onEmptyGet

onEmptyThrow

shuffle

slice

sorted

traversable

prependS

append

append

prepend

prepend

insertAt

deleteBetween

insertAtS