com.aol.cyclops2.types

Interface Folds<T>

Type Parameters:

T - Data type of element(s) in this Folds

All Superinterfaces:

ConvertableToReactiveSeq<T>, java.lang.Iterable<T>, ToStream<T>

All Known Subinterfaces:

AnyM<W,T>, AnyMSeq<W,T>, AnyMValue<W,T>, CollectionX<T>, CyclopsCollectable<T>, DequeX<T>, Either<ST,PT>, Either3<LT1,LT2,RT>, Either4<LT1,LT2,LT3,RT>, Either5<LT1,LT2,LT3,LT4,RT>, Eval<T>, FluentCollectionX<T>, FluentSequenceX<T>, FoldableTraversable<T>, FutureStream<U>, Ior<ST,PT>, LazyFluentCollectionX<T>, ListX<T>, MapX<K,V>, Maybe<T>, MonadicValue<T>, 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>, SetX<T>, SortedSetX<T>, Streamable<T>, Trampoline<T>, Try<T,X>, Value<T>, Xor<ST,PT>

All Known Implementing Classes:

AbstractLazyMutableCollection, AbstractLazyPersistentCollection, CollectionXImpl, Either.Lazy, Either.Left, Either.Right, Either3.Lazy, Either3.Left1, Either3.Left2, Either3.Right, Either4.Lazy, Either4.Left1, Either4.Left2, Either4.Left3, Either4.Right, Either5.Lazy, Either5.Left1, Either5.Left2, Either5.Left3, Either5.Left4, Either5.Right, Eval.Module.Always, Eval.Module.Later, Future, FutureT, Ior.Both, Ior.Primary, Ior.Secondary, LazyDequeX, LazyListX, LazyPBagX, LazyPOrderedSetX, LazyPQueueX, LazyPSetX, LazyPStackX, LazyPVectorX, LazyQueueX, LazySetX, LazySortedSetX, MapXImpl, Maybe.Just, Maybe.Lazy, Maybe.Nothing, PMapXImpl, Try.Failure, Try.Success, Value.ValueImpl, ValueSubscriber, ValueTransformer, Xor.Primary, Xor.Secondary

public interface Folds<T>
extends ToStream<T>

Represents a type that may be reducable (foldable) to a single value or collection

Method Summary

Modifier and Type	Method and Description
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 T	foldLeft(Monoid<T> reducer)
default T	foldLeft(T identity, java.util.function.BinaryOperator<T> accumulator)
default <U> U	foldLeft(U identity, java.util.function.BiFunction<U,? super T,U> accumulator)
default <U> U	foldLeft(U identity, java.util.function.BiFunction<U,? super T,U> accumulator, java.util.function.BinaryOperator<U> combiner)
default T	foldRight(Monoid<T> reducer) ReactiveSeq.of("a","b","c").foldRight(Reducers.toString("")); // "cab"
default T	foldRight(T identity, java.util.function.BinaryOperator<T> accumulator) Immutable reduction from right to left
default <U> U	foldRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> accumulator) Immutable reduction from right to left
default <T> T	foldRightMapToType(Reducer<T> reducer) Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
default java.util.Optional<T>	get(long index) Return the elementAt index or Optional.empty
default <K> MapX<K,ListX<T>>	groupBy(java.util.function.Function<? super T,? extends K> classifier) Use classifier function to group elements in this Sequence into a Map
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 <R> R	mapReduce(java.util.function.Function<? super T,? extends R> mapper, Monoid<R> reducer) Attempt to map this Monad to the same type as the supplied Monoid, using supplied function Then use Monoid to reduce values
default <R> R	mapReduce(Reducer<R> reducer) Attempt to map this Sequence to the same type as the supplied Monoid (Reducer) Then use Monoid to reduce values
default void	print(java.io.PrintStream str) Write each element within this Folds in turn to the supplied PrintStream
default void	print(java.io.PrintWriter writer) Write each element within this Folds in turn to the supplied PrintWriter
default void	printErr() Print each value in this Folds to the error console in turn (left-to-right)
default void	printOut() Print each value in this Folds to the console in turn (left-to-right)
default java.util.Optional<T>	reduce(java.util.function.BinaryOperator<T> accumulator) An equivalent function to Stream.reduce(BinaryOperator)
default ListX<T>	reduce(java.lang.Iterable<? extends Monoid<T>> reducers) Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first.
default T	reduce(Monoid<T> reducer) Reduce this Folds to a single value, using the supplied Monoid.
default ListX<T>	reduce(java.util.stream.Stream<? extends Monoid<T>> reducers) Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first.
default T	reduce(T identity, java.util.function.BinaryOperator<T> accumulator) An equivalent function to Stream.reduce(Object, BinaryOperator)
default <U> U	reduce(U identity, java.util.function.BiFunction<U,? super T,U> accumulator) An equivalent function to Stream.reduce(Object, BinaryOperator)
default <U> U	reduce(U identity, java.util.function.BiFunction<U,? super T,U> accumulator, java.util.function.BinaryOperator<U> combiner) An equivalent function to Stream.reduce(Object, BiFunction, BinaryOperator)
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 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 boolean	startsWith(java.util.stream.Stream<T> stream) assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Stream.of(1,2,3)))
default boolean	startsWithIterable(java.lang.Iterable<T> iterable) assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Arrays.asList(1,2,3)));
default CollectionX<T>	toConcurrentLazyCollection() Lazily converts this SequenceM into a Collection.
default Streamable<T>	toConcurrentLazyStreamable() 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 boolean	xMatch(int num, java.util.function.Predicate<? super T> c) Check that there are specified number of matches of predicate in the Stream

Methods inherited from interface com.aol.cyclops2.types.stream.ToStream

futureStream, getStreamable, isEmpty, jdkStream, reactiveSeq, reveresedJDKStream, reveresedStream, stream

Methods inherited from interface java.lang.Iterable

forEach, iterator, spliterator

Method Detail

mapReduce

default <R> R mapReduce(Reducer<R> reducer)

Attempt to map this Sequence to the same type as the supplied Monoid (Reducer) Then use Monoid to reduce values

  
 ReactiveSeq.of("hello","2","world","4").mapReduce(Reducers.toCountInt());
 
 //4
 
 

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

mapReduce

default <R> R mapReduce(java.util.function.Function<? super T,? extends R> mapper,
                        Monoid<R> reducer)

Attempt to map this Monad to the same type as the supplied Monoid, using supplied function Then use Monoid to reduce values

  
  ReactiveSeq.of("one","two","three","four")
           .mapReduce(this::toInt,Reducers.toTotalInt());
  
  //10
  
  int toInt(String s){
 		if("one".equals(s))
 			return 1;
 		if("two".equals(s))
 			return 2;
 		if("three".equals(s))
 			return 3;
 		if("four".equals(s))
 			return 4;
 		return -1;
 	   }
  
 

Parameters:

mapper - Function to map Monad type

reducer - Monoid to reduce values

Returns:

Reduce result

reduce

default T reduce(Monoid<T> reducer)

Reduce this Folds to a single value, using the supplied Monoid. For example

  
 ReactiveSeq.of("hello","2","world","4").reduce(Reducers.toString(","));
 
 //hello,2,world,4
 
 

Parameters:

reducer - Use supplied Monoid to reduce values

Returns:

reduced values

reduce

default java.util.Optional<T> reduce(java.util.function.BinaryOperator<T> accumulator)

An equivalent function to Stream.reduce(BinaryOperator)

 
  
       ReactiveSeq.of(1,2,3,4,5).map(it -> it*100).reduce(
 (acc,next) -> acc+next)
        //Optional[1500]
  
  

Parameters:

accumulator - Combiner function

Returns:

reduce

default T reduce(T identity,
                 java.util.function.BinaryOperator<T> accumulator)

An equivalent function to Stream.reduce(Object, BinaryOperator)

Parameters:

accumulator - Combiner function

Returns:

Value produced by applying the current accumulated value and the next value to the combiner function as this Folds is traversed from left to right

reduce

default <U> U reduce(U identity,
                     java.util.function.BiFunction<U,? super T,U> accumulator)

An equivalent function to Stream.reduce(Object, BinaryOperator)

Parameters:

identity - Identity value for the combiner function (leaves the input unchanged)

accumulator - Combiner function

Returns:

Value produced by applying the current accumulated value and the next value to the combiner function as this Folds is traversed from left to right

foldLeft

default <U> U foldLeft(U identity,
                       java.util.function.BiFunction<U,? super T,U> accumulator)

foldLeft

default <U> U foldLeft(U identity,
                       java.util.function.BiFunction<U,? super T,U> accumulator,
                       java.util.function.BinaryOperator<U> combiner)

foldLeft

default T foldLeft(T identity,
                   java.util.function.BinaryOperator<T> accumulator)

foldLeft

default T foldLeft(Monoid<T> reducer)

reduce

default <U> U reduce(U identity,
                     java.util.function.BiFunction<U,? super T,U> accumulator,
                     java.util.function.BinaryOperator<U> combiner)

An equivalent function to Stream.reduce(Object, BiFunction, BinaryOperator)

reduce

default ListX<T> reduce(java.util.stream.Stream<? extends Monoid<T>> reducers)

Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first. I.e. streamedMonad().reduce(reducer)

  
 	Monoid<Integer> sum = Monoid.of(0, (a, b) -&gt; a + b);
 	Monoid<Integer> mult = Monoid.of(1, (a, b) -&gt; a * b);
 	List<Integer> result = ReactiveSeq.of(1, 2, 3, 4)
                                    .reduce(Arrays.asList(sum, mult)
                                    .stream());
 
 	assertThat(result, equalTo(Arrays.asList(10, 24)));
 
 
 

Parameters:

reducers -

Returns:

List of reduced values

reduce

default ListX<T> reduce(java.lang.Iterable<? extends Monoid<T>> reducers)

Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first. I.e. streamedMonad().reduce(reducer)

  
 Monoid<Integer> sum = Monoid.of(0,(a,b)->a+b);
 		Monoid<Integer> mult = Monoid.of(1,(a,b)->a*b);
 		List<Integer> result = ReactiveSeq.of(1,2,3,4))
 										.reduce(Arrays.asList(sum,mult) );
 				
 		 
 		assertThat(result,equalTo(Arrays.asList(10,24)));
 
 
 

Parameters:

reducers -

Returns:

foldRight

default T foldRight(Monoid<T> reducer)

                
 		ReactiveSeq.of("a","b","c").foldRight(Reducers.toString(""));
        
         // "cab"
         
 

Parameters:

reducer - Use supplied Monoid to reduce values starting via foldRight

Returns:

Reduced result

foldRight

default T foldRight(T identity,
                    java.util.function.BinaryOperator<T> accumulator)

Immutable reduction from right to left

  
  assertTrue(ReactiveSeq.of("a","b","c").foldRight("", String::concat).equals("cba"));
 
 

Parameters:

identity - Identity value for the combiner function (leaves the input unchanged)

accumulator - Combining function

Returns:

Reduced value

foldRight

default <U> U foldRight(U identity,
                        java.util.function.BiFunction<? super T,? super U,? extends U> accumulator)

Immutable reduction from right to left

Parameters:

identity - Identity value for the combiner function (leaves the input unchanged)

accumulator - Combining function

Returns:

Reduced value

foldRightMapToType

default <T> T foldRightMapToType(Reducer<T> reducer)

Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values

                
 		ReactiveSeq.of(1,2,3).foldRightMapToType(Reducers.toString(""));
        
         // "321"
         
 

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

join

default java.lang.String join()

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

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

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

Returns:

Stream as concatenated String

print

default void print(java.io.PrintStream str)

Write each element within this Folds in turn to the supplied PrintStream

Parameters:

str - PrintStream to write to

print

default void print(java.io.PrintWriter writer)

Write each element within this Folds in turn to the supplied PrintWriter

Parameters:

writer - PrintWriter to write to

printOut

default void printOut()

Print each value in this Folds to the console in turn (left-to-right)

printErr

default void printErr()

Print each value in this Folds to the error console in turn (left-to-right)

groupBy

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

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

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

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.stream.Stream<T> stream)

  assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Stream.of(1,2,3))) 
 

Parameters:

stream - Stream to check if this Folds has the same elements in the same order, at the skip

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.

  
  
  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:

Lazy Collection

toConcurrentLazyCollection

default CollectionX<T> toConcurrentLazyCollection()

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

 
  
  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:

Concurrent Lazy Collection

toConcurrentLazyStreamable

default Streamable<T> toConcurrentLazyStreamable()

 
  
  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

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
  ReactiveSeq.generate(()->"next job:"+formatDate(new Date()))
             .map(this::processJob)
             .schedule("0 20 * * *",Executors.newScheduledThreadPool(1));
 
 

Connect to the Scheduled Stream

 
  
  HotStream<Data> dataStream = ReactiveSeq.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
  ReactiveSeq.generate(()->"next job:"+formatDate(new Date()))
             .map(this::processJob)
             .scheduleFixedDelay(60_000,Executors.newScheduledThreadPool(1));
 
 

Connect to the Scheduled Stream

  
  HotStream<Data> dataStream = ReactiveSeq.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

 
  
  HotStream<Data> dataStream = ReactiveSeq.generate(() -&gt; "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

xMatch

default boolean xMatch(int num,
                       java.util.function.Predicate<? super T> c)

Check that there are specified number of matches of predicate in the Stream

  
  assertTrue(ReactiveSeq.of(1,2,3,5,6,7).xMatch(3, i-> i>4 ));