NestedFoldable (cyclops-react 2.0.0-MI1 API)

All Superinterfaces:

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

All Known Subinterfaces:

FoldableTransformerSeq<W,T>

All Known Implementing Classes:

ListT
```
public interface NestedFoldable<W extends WitnessType<W>,T>
extends ToStream<T>
```

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default AnyM<W,java.lang.Boolean>`	`endsWith(java.util.stream.Stream<T> stream)` `assertTrue(ReactiveSeq.of(1,2,3,4,5,6) .endsWith(Stream.of(5,6)));`
`default AnyM<W,java.lang.Boolean>`	`endsWithIterable(java.lang.Iterable<T> iterable)` `assertTrue(ReactiveSeq.of(1,2,3,4,5,6) .endsWith(Arrays.asList(5,6)));`
`default AnyM<W,java.util.Optional<T>>`	`findFirst()`
`default AnyM<W,T>`	`firstValue()` `assertThat(ReactiveSeq.of(1,2,3,4) .map(u->{throw new RuntimeException();}) .recover(e->"hello") .firstValue(),equalTo("hello"));`
`default AnyM<W,T>`	`foldRight(Monoid<T> reducer)` `ReactiveSeq.of("a","b","c").foldRight(Reducers.toString("")); // "cab"`
`default AnyM<W,T>`	`foldRight(T identity, java.util.function.BinaryOperator<T> accumulator)` Immutable reduction from right to left
`default <U> AnyM<W,U>`	`foldRight(U identity, java.util.function.BiFunction<? super T,U,U> accumulator)` Immutable reduction from right to left
`default <T> AnyM<W,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 <X extends java.lang.Throwable> AnyM<W,? extends org.reactivestreams.Subscription>`	`forEachXEvents(long numberOfElements, java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.Throwable> consumerError, java.lang.Runnable onComplete)`
`default <X extends java.lang.Throwable> AnyM<W,? extends org.reactivestreams.Subscription>`	`forEachXWithError(long numberOfElements, java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.Throwable> consumerError)`
`default AnyM<W,java.util.Optional<T>>`	`get(long index)` Return the elementAt index or Optional.empty
`default <K> AnyM<W,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 AnyM<W,java.lang.String>`	`join()` `assertEquals("123".length(),ReactiveSeq.of(1, 2, 3).join().length());`
`default AnyM<W,java.lang.String>`	`join(java.lang.String sep)` `assertEquals("1, 2, 3".length(), ReactiveSeq.of(1, 2, 3).join(", ").length());`
`default AnyM<W,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> AnyM<W,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> AnyM<W,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
`AnyM<W,? extends CyclopsCollectable<T>>`	`nestedFoldables()`
`default void`	`print(java.io.PrintStream str)`
`default void`	`print(java.io.PrintWriter writer)`
`default void`	`printErr()`
`default void`	`printOut()`
`default AnyM<W,java.util.Optional<T>>`	`reduce(java.util.function.BinaryOperator<T> accumulator)`
`default ListT<W,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 AnyM<W,T>`	`reduce(Monoid<T> reducer)` `ReactiveSeq.of("hello","2","world","4").reduce(Reducers.toString(",")); //hello,2,world,4`
`default ListT<W,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 AnyM<W,T>`	`reduce(T identity, java.util.function.BinaryOperator<T> accumulator)`
`default <U> AnyM<W,U>`	`reduce(U identity, java.util.function.BiFunction<U,? super T,U> accumulator, java.util.function.BinaryOperator<U> combiner)`
`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 AnyM<W,T>`	`single()` `//1 ReactiveSeq.of(1).single(); //UnsupportedOperationException ReactiveSeq.of().single(); //UnsupportedOperationException ReactiveSeq.of(1,2,3).single();`
`default AnyM<W,T>`	`single(java.util.function.Predicate<? super T> predicate)`
`default AnyM<W,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 AnyM<W,java.lang.Boolean>`	`startsWith(java.util.stream.Stream<T> stream)` `assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Arrays.asList(1,2,3).iterator()))`
`default AnyM<W,java.lang.Boolean>`	`startsWithIterable(java.lang.Iterable<T> iterable)` `assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Arrays.asList(1,2,3)));`
`default AnyM<W,CollectionX<T>>`	`toConcurrentLazyCollection()` Lazily converts this SequenceM into a Collection.
`default AnyM<W,Streamable<T>>`	`toConcurrentLazyStreamable()` `Streamable<Integer> repeat = ReactiveSeq.of(1, 2, 3, 4, 5, 6) .map(i -> i + 2) .toConcurrentLazyStreamable(); assertThat(repeat.stream().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12))); assertThat(repeat.stream().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12)));`
`default AnyM<W,CollectionX<T>>`	`toLazyCollection()` Lazily converts this NestedFoldable into a Collection.

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

nestedFoldables

AnyM<W,? extends CyclopsCollectable<T>> nestedFoldables()

forEachXWithError

default <X extends java.lang.Throwable> AnyM<W,? extends org.reactivestreams.Subscription> forEachXWithError(long numberOfElements,
                                                                                                             java.util.function.Consumer<? super T> consumer,
                                                                                                             java.util.function.Consumer<? super java.lang.Throwable> consumerError)

forEachXEvents

default <X extends java.lang.Throwable> AnyM<W,? extends org.reactivestreams.Subscription> forEachXEvents(long numberOfElements,
                                                                                                          java.util.function.Consumer<? super T> consumer,
                                                                                                          java.util.function.Consumer<? super java.lang.Throwable> consumerError,
                                                                                                          java.lang.Runnable onComplete)

mapReduce
```
default <R> AnyM<W,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> AnyM<W,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 AnyM<W,T> reduce(Monoid<T> reducer)

  
 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 AnyM<W,java.util.Optional<T>> reduce(java.util.function.BinaryOperator<T> accumulator)

reduce

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

reduce

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

reduce

default ListT<W,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) -> 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).transformerStream());
 
  assertThat(result, equalTo(Arrays.asList(10, 24)));

Parameters:: reducers -
Returns:

reduce

default ListT<W,T> reduce(java.lang.Iterable<? extends Monoid<T>> reducers)

  
      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 AnyM<W,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 AnyM<W,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 - value that results in the input parameter to the accumulator function being returned. E.g. for multiplication 1 is the identity value, for addition 0 is the identity value

accumulator - function that combines the accumulated value and the next one

Returns:

AnyM containing the results of the nested fold right

foldRight
```
default <U> AnyM<W,U> foldRight(U identity,
                                java.util.function.BiFunction<? super T,U,U> accumulator)
```
Immutable reduction from right to left
```
  
  assertTrue(ReactiveSeq.of("a","b","c").foldRight("", (a,b)->a+b).equals("cba"));
 
 
```
*
Parameters:

identity - value that results in the input parameter to the accumulator function being returned. E.g. for multiplication 1 is the identity value, for addition 0 is the identity value

accumulator - function that combines the accumulated value and the next one

Returns:

AnyM containing the results of the nested fold right

foldRightMapToType
```
default <T> AnyM<W,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 AnyM<W,java.lang.String> join()

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

Returns:: Stream as concatenated String

join

default AnyM<W,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 AnyM<W,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)

print

default void print(java.io.PrintWriter writer)

printOut
```
default void printOut()
```

printErr
```
default void printErr()
```

groupBy

default <K> AnyM<W,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 -> i % 2);
  assertEquals(asList(2, 4), map1.get(0));
  assertEquals(asList(1, 3), map1.get(1));
  assertEquals(2, map1.size());

findFirst

default AnyM<W,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)

startsWithIterable

default AnyM<W,java.lang.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 AnyM<W,java.lang.Boolean> startsWith(java.util.stream.Stream<T> stream)

  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 AnyM<W,java.lang.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 AnyM<W,java.lang.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 AnyM<W,CollectionX<T>> toLazyCollection()

Lazily converts this NestedFoldable 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:

toConcurrentLazyCollection

default AnyM<W,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:

toConcurrentLazyStreamable

default AnyM<W,Streamable<T>> toConcurrentLazyStreamable()

 
  Streamable<Integer> repeat = ReactiveSeq.of(1, 2, 3, 4, 5, 6)
                                          .map(i -> i + 2)
                                          .toConcurrentLazyStreamable();
 
  assertThat(repeat.stream().toList(), equalTo(Arrays.asList(2, 4, 6, 8, 10, 12)));
  assertThat(repeat.stream().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 AnyM<W,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 AnyM<W,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 AnyM<W,T> single(java.util.function.Predicate<? super T> predicate)

singleOptional

default AnyM<W,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 AnyM<W,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
  ReactiveSeq.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(() -> "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

Interface NestedFoldable<W extends WitnessType<W>,T>

Method Summary

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

Methods inherited from interface java.lang.Iterable

Method Detail

nestedFoldables

forEachXWithError

forEachXEvents

mapReduce

mapReduce

reduce

reduce

reduce

reduce

reduce

reduce

foldRight

foldRight

foldRight

foldRightMapToType

join

join

join

print

print

printOut

printErr

groupBy

findFirst

startsWithIterable

startsWith

endsWithIterable

endsWith

toLazyCollection

toConcurrentLazyCollection

toConcurrentLazyStreamable

firstValue

single

single

singleOptional

get

schedule

scheduleFixedDelay

scheduleFixedRate