com.aol.cyclops.types

Interface Traversable<T>

All Superinterfaces:

ConvertableSequence<T>, Foldable<T>, java.lang.Iterable<T>, org.reactivestreams.Publisher<T>

All Known Subinterfaces:

AnyMSeq<T>, CollectionX<T>, ConvertableSequentialFunctor<T>, DequeX<T>, ExtendedTraversable<T>, FluentCollectionX<T>, FluentSequenceX<T>, IterableFunctor<T>, LazyFutureStream<U>, ListX<T>, MapX<K,V>, MutableCollectionX<T>, MutableSequenceX<T>, PBagX<T>, PersistentCollectionX<T>, PMapX<K,V>, POrderedSetX<T>, PQueueX<T>, PSetX<T>, PStackX<T>, PVectorX<T>, QueueX<T>, ReactiveSeq<T>, Sequential<T>, SetX<T>, SortedSetX<T>, Streamable<T>, ZippingApplicativable<T>

All Known Implementing Classes:

AnyMSeqImpl, CollectionXImpl, DequeXImpl, LazyFutureStreamImpl, ListXImpl, MapXImpl, MaterializedList, PBagXImpl, PMapXImpl, POrderedSetXImpl, PQueueXImpl, PSetXImpl, PStackXImpl, PVectorXImpl, QueueXImpl, ReactiveSeqImpl, ReversedIterator, SetXImpl, SortedSetXImpl, StreamableImpl

public interface Traversable<T>
extends Foldable<T>, java.lang.Iterable<T>, ConvertableSequence<T>, org.reactivestreams.Publisher<T>

Method Summary

Modifier and Type	Method and Description
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 & reduction operation.
default Traversable<T>	cycle(int times) Convert to a Stream with the values repeated specified times
default Traversable<T>	cycle(Monoid<T> m, int times) Convert to 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>	distinct()
default Traversable<T>	dropRight(int num)
default Traversable<T>	dropUntil(java.util.function.Predicate<? super T> p)
default Traversable<T>	dropWhile(java.util.function.Predicate<? super T> p)
default boolean	endsWith(java.util.stream.Stream<T> stream) assertTrue(ReactiveSeq.of(1,2,3,4,5,6) .endsWith(Stream.of(5,6)));
default boolean	endsWithIterable(java.lang.Iterable<T> iterable) assertTrue(ReactiveSeq.of(1,2,3,4,5,6) .endsWith(Arrays.asList(5,6)));
default java.util.Optional<T>	findAny()
default java.util.Optional<T>	findFirst()
default T	firstValue() assertThat(ReactiveSeq.of(1,2,3,4) .map(u->{throw new RuntimeException();}) .recover(e->"hello") .firstValue(),equalTo("hello"));
default FutureOperations<T>	futureOperations(java.util.concurrent.Executor exec) Access asynchronous terminal operations (each returns a Future)
default java.util.Optional<T>	get(long index) Return the elementAt index or Optional.empty
default <K> MapX<K,java.util.List<T>>	groupBy(java.util.function.Function<? super T,? extends K> classifier) Use classifier function to group elements in this Sequence into a Map
default <K> Traversable<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>>	grouped(java.util.function.Function<? super T,? extends K> classifier)
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)
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>>	groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate) Create SequenceM of Streamables (replayable Streams / Sequences) where each Streamable is populated while the supplied bipredicate holds.
default Traversable<ListX<T>>	groupedUntil(java.util.function.Predicate<? super T> predicate) Create a SequenceM 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 SequenceM 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 SequenceM 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 HeadAndTail<T>	headAndTail() extract head and tail together, where head is expected to be present
default Traversable<T>	intersperse(T value) Returns a stream with a given value interspersed between any two values of this stream.
default java.lang.String	join() assertEquals("123".length(),ReactiveSeq.of(1, 2, 3).join().length());
default java.lang.String	join(java.lang.String sep) assertEquals("1, 2, 3".length(), ReactiveSeq.of(1, 2, 3).join(", ").length());
default java.lang.String	join(java.lang.String sep, java.lang.String start, java.lang.String end) assertEquals("^1|2|3$".length(), of(1, 2, 3).join("|", "^", "$").length());
default LazyOperations<T>	lazyOperations() Access a set of Lazy terminal operations (each returns an Eval)
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 to 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 Traversable<T>	onEmpty(T value)
default Traversable<T>	onEmptyGet(java.util.function.Supplier<T> supplier)
default <X extends java.lang.Throwable> Traversable<T>	onEmptyThrow(java.util.function.Supplier<X> supplier)
default Traversable<T>	reverse()
default Traversable<T>	scanLeft(Monoid<T> monoid) Scan left using supplied Monoid
default <U> Traversable<U>	scanLeft(U seed, java.util.function.BiFunction<U,? super T,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,U,U> combiner) Scan right
default HotStream<T>	schedule(java.lang.String cron, java.util.concurrent.ScheduledExecutorService ex) Execute this Stream on a schedule
default HotStream<T>	scheduleFixedDelay(long delay, java.util.concurrent.ScheduledExecutorService ex) Execute this Stream on a schedule
default HotStream<T>	scheduleFixedRate(long rate, java.util.concurrent.ScheduledExecutorService ex) Execute this Stream on a schedule
default Traversable<T>	shuffle()
default Traversable<T>	shuffle(java.util.Random random)
default T	single() //1 ReactiveSeq.of(1).single(); //UnsupportedOperationException ReactiveSeq.of().single(); //UnsupportedOperationException ReactiveSeq.of(1,2,3).single();
default T	single(java.util.function.Predicate<? super T> predicate)
default java.util.Optional<T>	singleOptional() //Optional[1] ReactiveSeq.of(1).singleOptional(); //Optional.empty ReactiveSeq.of().singleOpional(); //Optional.empty ReactiveSeq.of(1,2,3).singleOptional();
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(Collectors.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<ListX<T>>	sliding(int windowSize) Create a sliding view over this Sequence
default Traversable<ListX<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 boolean	startsWith(java.util.Iterator<T> iterator) assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Arrays.asList(1,2,3).iterator()))
default boolean	startsWithIterable(java.lang.Iterable<T> iterable) assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Arrays.asList(1,2,3)));
default ReactiveSeq<T>	stream()
default void	subscribe(org.reactivestreams.Subscriber<? super T> s)
default Traversable<T>	takeRight(int num)
default Traversable<T>	takeUntil(java.util.function.Predicate<? super T> p)
default Traversable<T>	takeWhile(java.util.function.Predicate<? super T> p)
default CollectionX<T>	toConcurrentLazyCollection() Lazily converts this SequenceM into a Collection.
default Streamable<T>	toConcurrentLazyStreamable() { @code Streamable<Integer> repeat = ReactiveSeq.of(1, 2, 3, 4, 5, 6).map(i -> i + 2).toConcurrentLazyStreamable(); assertThat(repeat.sequenceM().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12))); assertThat(repeat.sequenceM().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12))); }
default CollectionX<T>	toLazyCollection() Lazily converts this SequenceM into a Collection.
default <S,F> Ior<ReactiveSeq<F>,ReactiveSeq<S>>	validate(Validator<T,S,F> validator)
default <R> R	visit(java.util.function.BiFunction<? super Maybe<T>,? super ReactiveSeq<T>,? extends R> match)
default <R> R	visit(java.util.function.BiFunction<? super T,? super ReactiveSeq<T>,? extends R> match, java.util.function.Supplier<? extends R> ifEmpty) Destructures this Traversable into it's head and tail.
default <U,R> Traversable<R>	zip(java.lang.Iterable<U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
default <U> Traversable<org.jooq.lambda.tuple.Tuple2<T,U>>	zip(org.jooq.lambda.Seq<U> other) Zip 2 streams into one
default <S,U> Traversable<org.jooq.lambda.tuple.Tuple3<T,S,U>>	zip3(java.util.stream.Stream<? extends S> second, java.util.stream.Stream<? extends U> third) zip 3 Streams into one
default <T2,T3,T4> Traversable<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>	zip4(java.util.stream.Stream<T2> second, java.util.stream.Stream<T3> third, java.util.stream.Stream<T4> fourth) zip 4 Streams into 1
default <U> Traversable<org.jooq.lambda.tuple.Tuple2<T,U>>	zipStream(java.util.stream.Stream<U> other) Zip 2 streams into one
default Traversable<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>	zipWithIndex() Add an index to the current Stream

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

foldRight, foldRight, foldRight, foldRightMapToType, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce

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

seq, toCompletableFuture, toDequeX, toEvalAlways, toEvalLater, toEvalNow, toFutureStream, toFutureStream, toFutureW, toIor, toIorSecondary, toListX, toMapX, toMaybe, toOptional, toPBagX, toPMapX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toStreamable, toTry, toValue, toValueMap, toValueSet, toXor, toXorSecondary

Methods inherited from interface java.lang.Iterable

forEach, iterator, spliterator

Method Detail

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 & reduction operation. The output of a combination may in turn be combined with it's neighbour

  
  ReactiveSeq.of(1,1,2,3)
                   .combine((a, b)->a.equals(b),Semigroups.intSum)
                   .toListX()
                   
  //ListX(3,4) 
 

Parameters:

predicate - Test to see if two neighbours should be joined

op - Reducer to combine neighbours

Returns:

Combined / Partially Reduced Traversable

visit

default <R> R visit(java.util.function.BiFunction<? super T,? super ReactiveSeq<T>,? extends R> match,
                    java.util.function.Supplier<? extends R> ifEmpty)

Destructures this Traversable into it's head and tail. If the traversable instance is not a SequenceM or Stream type, whenStream may be more efficient (as it is guaranteed to be lazy).

  
 ListX.of(1,2,3,4,5,6,7,8,9)
			 .dropRight(5)
			 .plus(10)
			 .visit((x,xs) ->
				 xs.join(x.>2?"hello":"world")),()->"NIL"
			 );
 
 
 //2world3world4
 
 

Parameters:

match -

Returns:

visit

default <R> R visit(java.util.function.BiFunction<? super Maybe<T>,? super ReactiveSeq<T>,? extends R> match)

cycle

default Traversable<T> cycle(int times)

Convert to a Stream with the values repeated specified times

  
 		ReactiveSeq.of(1,2,2)
 								.cycle(3)
 								.collect(Collectors.toList());
 								
 		//List[1,2,2,1,2,2,1,2,2]
 
 
 

Parameters:

times - Times values should be repeated within a Stream

Returns:

Stream with values repeated

cycle

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

Convert to a Stream with the result of a reduction operation repeated specified times

  
   List<Integer> list = ReactiveSeq.of(1,2,2))
                                 .cycle(Reducers.toCountInt(),3)
                                 .collect(Collectors.toList());
   //List[3,3,3];
   
 

Parameters:

m - Monoid to 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

 {
        @code
        MutableInt count = MutableInt.of(0);
        ReactiveSeq.of(1, 2, 2).cycleWhile(next -> count++ < 6).collect(Collectors.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(Collectors.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<U> other,
                                 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)

zipStream

default <U> Traversable<org.jooq.lambda.tuple.Tuple2<T,U>> zipStream(java.util.stream.Stream<U> other)

Zip 2 streams into one

 {
        @code
        List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
        // [[1,"a"],[2,"b"]]
 }
 

zip

default <U> Traversable<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<U> other)

Zip 2 streams into one

 {
        @code
        List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
        // [[1,"a"],[2,"b"]]
 }
 

zip3

default <S,U> Traversable<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.util.stream.Stream<? extends S> second,
                                                                    java.util.stream.Stream<? extends U> third)

zip 3 Streams into one

 {
        @code
        List<Tuple3<Integer, Integer, Character>> list = of(1, 2, 3, 4, 5, 6).zip3(of(100, 200, 300, 400), of('a', 'b', 'c')).collect(Collectors.toList());
 
        // [[1,100,'a'],[2,200,'b'],[3,300,'c']]
 }
 
 

zip4

default <T2,T3,T4> Traversable<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.util.stream.Stream<T2> second,
                                                                              java.util.stream.Stream<T3> third,
                                                                              java.util.stream.Stream<T4> fourth)

zip 4 Streams into 1

 {
        @code
        List<Tuple4<Integer, Integer, Character, String>> list = of(1, 2, 3, 4, 5, 6).zip4(of(100, 200, 300, 400), of('a', 'b', 'c'), of("hello", "world"))
                        .collect(Collectors.toList());
 
 }
 // [[1,100,'a',"hello"],[2,200,'b',"world"]]
 

zipWithIndex

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

Add an index to the current Stream

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

sliding

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

Create a sliding view over this Sequence

 {
        @code
        List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(2).collect(Collectors.toList());
 
        assertThat(list.get(0), hasItems(1, 2));
        assertThat(list.get(1), hasItems(2, 3));
 
 }
 
 

Parameters:

windowSize - Size of sliding window

Returns:

SequenceM with sliding view

sliding

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

Create a sliding view over this Sequence

 {
        @code
        List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(3, 2).collect(Collectors.toList());
 
        assertThat(list.get(0), hasItems(1, 2, 3));
        assertThat(list.get(1), hasItems(3, 4, 5));
 
 }
 
 

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 SequenceM batched by List, where each batch is populated until the predicate holds

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

Parameters:

predicate - Batch until predicate holds, then open next batch

Returns:

SequenceM batched into lists determined by the predicate supplied

groupedStatefullyWhile

default Traversable<ListX<T>> groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)

Create SequenceM of Streamables (replayable Streams / Sequences) where each Streamable is populated while the supplied bipredicate holds. The bipredicate recieves the Streamable from the last window as well as the current value and can choose to aggregate the current value or create a new window

  
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
              .windowStatefullyWhile((s,i)->s.sequenceM().toList().contains(4) ? true : false)
              .toList().size(),equalTo(5));
 
 

Parameters:

predicate - Window while true

Returns:

SequenceM windowed while predicate holds

groupedWhile

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

Create a SequenceM batched by List, 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, then 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, then 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 SequenceM batched by a Collection, where each batch is populated until the predicate holds

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

Parameters:

predicate - Batch until predicate holds, then 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

 {
        @code
        List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).grouped(3).collect(Collectors.toList());
 
        assertThat(list.get(0), hasItems(1, 2, 3));
        assertThat(list.get(1), hasItems(4, 5, 6));
 
 }
 

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)

grouped

default <K> Traversable<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)

groupBy

default <K> MapX<K,java.util.List<T>> groupBy(java.util.function.Function<? super T,? extends K> classifier)

Use classifier function to group elements in this Sequence into a Map

 {
        @code
        Map<Integer, List<Integer>> map1 = of(1, 2, 3, 4).groupBy(i -> i % 2);
        assertEquals(asList(2, 4), map1.get(0));
        assertEquals(asList(1, 3), map1.get(1));
        assertEquals(2, map1.size());
 
 }
 
 

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<U,? super T,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,U,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 to sort with

Returns:

Sorted Stream

takeWhile

default Traversable<T> takeWhile(java.util.function.Predicate<? super T> p)

dropWhile

default Traversable<T> dropWhile(java.util.function.Predicate<? super T> p)

takeUntil

default Traversable<T> takeUntil(java.util.function.Predicate<? super T> p)

dropUntil

default Traversable<T> dropUntil(java.util.function.Predicate<? super T> p)

dropRight

default Traversable<T> dropRight(int num)

takeRight

default Traversable<T> takeRight(int num)

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 to 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 to 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 to skip until true

Returns:

Stream with elements skipped until predicate holds

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 to num

Returns:

Monad converted to Stream with elements up to 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

join

default java.lang.String join()

 
  assertEquals("123".length(),ReactiveSeq.of(1, 2, 3).join().length());
 
 

Specified by:

join in interface Foldable<T>

Returns:

Stream as concatenated String

join

default java.lang.String join(java.lang.String sep)

 
 assertEquals("1, 2, 3".length(), ReactiveSeq.of(1, 2, 3).join(", ").length());
 
 

Specified by:

join in interface Foldable<T>

Returns:

Stream as concatenated String

join

default java.lang.String join(java.lang.String sep,
                              java.lang.String start,
                              java.lang.String end)

  
 assertEquals("^1|2|3$".length(), of(1, 2, 3).join("|", "^", "$").length());
 
 

Specified by:

join in interface Foldable<T>

Returns:

Stream as concatenated String

headAndTail

default HeadAndTail<T> headAndTail()

extract head and tail together, where head is expected to be present

 {
        @code
        SequenceM<String> helloWorld = ReactiveSeq.of("hello", "world", "last");
        HeadAndTail<String> headAndTail = helloWorld.headAndTail();
        String head = headAndTail.head();
        assertThat(head, equalTo("hello"));
 
        SequenceM<String> tail = headAndTail.tail();
        assertThat(tail.headAndTail().head(), equalTo("world"));
 }
 

Returns:

findFirst

default java.util.Optional<T> findFirst()

Returns:

First matching element in sequential order

 
 ReactiveSeq.of(1,2,3,4,5).filter(it -> it <3).findFirst().get();
 
 //3
 
 

(deterministic)

findAny

default java.util.Optional<T> findAny()

Returns:

first matching element, but order is not guaranteed

 
 ReactiveSeq.of(1,2,3,4,5).filter(it -> it <3).findAny().get();
 
 //3
 
 

(non-deterministic)

startsWithIterable

default boolean startsWithIterable(java.lang.Iterable<T> iterable)

  
  assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Arrays.asList(1,2,3)));
 
 

Parameters:

iterable -

Returns:

True if Monad starts with Iterable sequence of data

startsWith

default boolean startsWith(java.util.Iterator<T> iterator)

  assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Arrays.asList(1,2,3).iterator())) 
 

Parameters:

iterator -

Returns:

True if Monad starts with Iterators sequence of data

endsWithIterable

default boolean endsWithIterable(java.lang.Iterable<T> iterable)

 
  assertTrue(ReactiveSeq.of(1,2,3,4,5,6)
 				.endsWith(Arrays.asList(5,6)));
 
 

Parameters:

iterable - Values to check

Returns:

true if SequenceM ends with values in the supplied iterable

endsWith

default boolean endsWith(java.util.stream.Stream<T> stream)

 
 assertTrue(ReactiveSeq.of(1,2,3,4,5,6)
 				.endsWith(Stream.of(5,6))); 
 
 

Parameters:

stream - Values to check

Returns:

true if SequenceM endswith values in the supplied Stream

toLazyCollection

default CollectionX<T> toLazyCollection()

Lazily converts this SequenceM into a Collection. This does not trigger the Stream. E.g. Collection is not thread safe on the first iteration.

 {
        @code
        Collection<Integer> col = ReactiveSeq.of(1, 2, 3, 4, 5).peek(System.out::println).toLazyCollection();
 
        col.forEach(System.out::println);
 }
 
 // Will print out "first!" before anything else
 

Returns:

toConcurrentLazyCollection

default CollectionX<T> toConcurrentLazyCollection()

Lazily converts this SequenceM into a Collection. This does not trigger the Stream. E.g.

 {
        @code
        Collection<Integer> col = ReactiveSeq.of(1, 2, 3, 4, 5).peek(System.out::println).toConcurrentLazyCollection();
 
        col.forEach(System.out::println);
 }
 
 // Will print out "first!" before anything else
 

Returns:

toConcurrentLazyStreamable

default Streamable<T> toConcurrentLazyStreamable()

 {
        @code
        Streamable<Integer> repeat = ReactiveSeq.of(1, 2, 3, 4, 5, 6).map(i -> i + 2).toConcurrentLazyStreamable();
 
        assertThat(repeat.sequenceM().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12)));
        assertThat(repeat.sequenceM().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12)));
 }
 

Returns:

Streamable that replay this SequenceM, populated lazily and can be populated across threads

firstValue

default T firstValue()

  
 	assertThat(ReactiveSeq.of(1,2,3,4)
 					.map(u->{throw new RuntimeException();})
 					.recover(e->"hello")
 					.firstValue(),equalTo("hello"));
 
 

Returns:

first value in this Stream

single

default T single()

  
    
    //1
    ReactiveSeq.of(1).single(); 
    
    //UnsupportedOperationException
    ReactiveSeq.of().single();
     
     //UnsupportedOperationException
    ReactiveSeq.of(1,2,3).single();
 
 

Returns:

a single value or an UnsupportedOperationException if 0/1 values in this Stream

single

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

singleOptional

default java.util.Optional<T> singleOptional()

  
    
    //Optional[1]
    ReactiveSeq.of(1).singleOptional(); 
    
    //Optional.empty
    ReactiveSeq.of().singleOpional();
     
     //Optional.empty
    ReactiveSeq.of(1,2,3).singleOptional();
 
 

Returns:

An Optional with single value if this Stream has exactly one element, otherwise Optional Empty

get

default java.util.Optional<T> get(long index)

Return the elementAt index or Optional.empty

 
 	assertThat(ReactiveSeq.of(1,2,3,4,5).elementAt(2).get(),equalTo(3));
 
 

Parameters:

index - to extract element from

Returns:

elementAt index

intersperse

default Traversable<T> intersperse(T value)

Returns a stream with a given value interspersed between any two values of this stream. // (1, 0, 2, 0, 3, 0, 4) ReactiveSeq.of(1, 2, 3, 4).intersperse(0)

reverse

default Traversable<T> reverse()

shuffle

default Traversable<T> shuffle()

futureOperations

default FutureOperations<T> futureOperations(java.util.concurrent.Executor exec)

Access asynchronous terminal operations (each returns a Future)

Parameters:

exec - Executor to use for Stream execution

Returns:

Async Future Terminal Operations

lazyOperations

default LazyOperations<T> lazyOperations()

Access a set of Lazy terminal operations (each returns an Eval)

Returns:

Lazy Terminal Operations

skipLast

default Traversable<T> skipLast(int num)

assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));

Parameters:

num -

Returns:

limitLast

default Traversable<T> limitLast(int num)

Limit results to the last x elements in a SequenceM

  
 	assertThat(ReactiveSeq.of(1,2,3,4,5)
 							.limitLast(2)
 							.collect(Collectors.toList()),equalTo(Arrays.asList(4,5)));
 
 

Parameters:

num - of elements to return (last elements)

Returns:

SequenceM limited to last num elements

onEmpty

default Traversable<T> onEmpty(T value)

onEmptyGet

default Traversable<T> onEmptyGet(java.util.function.Supplier<T> supplier)

onEmptyThrow

default <X extends java.lang.Throwable> Traversable<T> onEmptyThrow(java.util.function.Supplier<X> supplier)

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)

schedule

default HotStream<T> schedule(java.lang.String cron,
                              java.util.concurrent.ScheduledExecutorService ex)

Execute this Stream on a schedule

 
  //run at 8PM every night
  SequenceeM.generate(()->"next job:"+formatDate(new Date()))
            .map(this::processJob)
            .schedule("0 20 * * *",Executors.newScheduledThreadPool(1));
 
 

Connect to the Scheduled Stream

 {
        @code
        HotStream<Data> dataStream = SequenceeM.generate(() -> "next job:" + formatDate(new Date())).map(this::processJob)
                        .schedule("0 20 * * *", Executors.newScheduledThreadPool(1));
 
        data.connect().forEach(this::logToDB);
 }
 

Parameters:

cron - Expression that determines when each job will run

ex - ScheduledExecutorService

Returns:

Connectable HotStream of output from scheduled Stream

scheduleFixedDelay

default HotStream<T> scheduleFixedDelay(long delay,
                                        java.util.concurrent.ScheduledExecutorService ex)

Execute this Stream on a schedule

 
  //run every 60 seconds after last job completes
  SequenceeM.generate(()->"next job:"+formatDate(new Date()))
            .map(this::processJob)
            .scheduleFixedDelay(60_000,Executors.newScheduledThreadPool(1));
 
 

Connect to the Scheduled Stream

 {
        @code
        HotStream<Data> dataStream = SequenceeM.generate(() -> "next job:" + formatDate(new Date())).map(this::processJob)
                        .scheduleFixedDelay(60_000, Executors.newScheduledThreadPool(1));
 
        data.connect().forEach(this::logToDB);
 }
 

Parameters:

delay - Between last element completes passing through the Stream until the next one starts

ex - ScheduledExecutorService

Returns:

Connectable HotStream of output from scheduled Stream

scheduleFixedRate

default HotStream<T> scheduleFixedRate(long rate,
                                       java.util.concurrent.ScheduledExecutorService ex)

Execute this Stream on a schedule

 
  //run every 60 seconds
  SequenceeM.generate(()->"next job:"+formatDate(new Date()))
            .map(this::processJob)
            .scheduleFixedRate(60_000,Executors.newScheduledThreadPool(1));
 
 

Connect to the Scheduled Stream

 {
        @code
        HotStream<Data> dataStream = SequenceeM.generate(() -> "next job:" + formatDate(new Date())).map(this::processJob)
                        .scheduleFixedRate(60_000, Executors.newScheduledThreadPool(1));
 
        data.connect().forEach(this::logToDB);
 }
 

Parameters:

rate - Time in millis between job runs

ex - ScheduledExecutorService

Returns:

Connectable HotStream of output from scheduled Stream

stream

default ReactiveSeq<T> stream()

Specified by:

stream in interface ConvertableSequence<T>

Specified by:

stream in interface Foldable<T>

validate

default <S,F> Ior<ReactiveSeq<F>,ReactiveSeq<S>> validate(Validator<T,S,F> validator)