com.aol.cyclops.types.anyM

Interface NestedFoldable<T>

All Known Subinterfaces:

FoldableTransformerSeq<T>, ListT<T>, SetT<T>, StreamableT<T>, StreamT<T>

All Known Implementing Classes:

ListTSeq, ListTValue, SetTSeq, SetTValue, StreamableTSeq, StreamableTValue, StreamTSeq, StreamTValue

public interface NestedFoldable<T>

Method Summary

Modifier and Type	Method and Description
default AnyM<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<java.lang.Boolean>	endsWithIterable(java.lang.Iterable<T> iterable) assertTrue(ReactiveSeq.of(1,2,3,4,5,6) .endsWith(Arrays.asList(5,6)));
default OptionalT<T>	findFirst()
default AnyM<T>	firstValue() assertThat(ReactiveSeq.of(1,2,3,4) .map(u->{throw new RuntimeException();}) .recover(e->"hello") .firstValue(),equalTo("hello"));
default AnyM<T>	foldRight(Monoid<T> reducer) ReactiveSeq.of("a","b","c").foldRight(Reducers.toString("")); // "cab"
default AnyM<T>	foldRight(T identity, java.util.function.BinaryOperator<T> accumulator) Immutable reduction from right to left
default <U> AnyM<U>	foldRight(U identity, java.util.function.BiFunction<? super T,U,U> accumulator)
default <T> AnyM<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 OptionalT<T>	get(long index) Return the elementAt index or Optional.empty
default <K> AnyM<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 AnyM<HeadAndTail<T>>	headAndTail() extract head and tail together, where head is expected to be present
default AnyM<java.lang.String>	join() assertEquals("123".length(),ReactiveSeq.of(1, 2, 3).join().length());
default AnyM<java.lang.String>	join(java.lang.String sep) assertEquals("1, 2, 3".length(), ReactiveSeq.of(1, 2, 3).join(", ").length());
default AnyM<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<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<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<? extends IterableFoldable<T>>	nestedFoldables()
default void	print(java.io.PrintStream str)
default void	print(java.io.PrintWriter writer)
default void	printErr()
default void	printOut()
default OptionalT<T>	reduce(java.util.function.BinaryOperator<T> accumulator)
default ListT<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<T>	reduce(Monoid<T> reducer) ReactiveSeq.of("hello","2","world","4").reduce(Reducers.toString(",")); //hello,2,world,4
default ListT<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<T>	reduce(T identity, java.util.function.BinaryOperator<T> accumulator)
default <U> AnyM<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<T>	single() //1 ReactiveSeq.of(1).single(); //UnsupportedOperationException ReactiveSeq.of().single(); //UnsupportedOperationException ReactiveSeq.of(1,2,3).single();
default AnyM<T>	single(java.util.function.Predicate<? super T> predicate)
default OptionalT<T>	singleOptional() //Optional[1] ReactiveSeq.of(1).singleOptional(); //Optional.empty ReactiveSeq.of().singleOpional(); //Optional.empty ReactiveSeq.of(1,2,3).singleOptional();
default AnyM<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<java.lang.Boolean>	startsWithIterable(java.lang.Iterable<T> iterable) assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Arrays.asList(1,2,3)));
ReactiveSeq<T>	stream()
default AnyM<CollectionX<T>>	toConcurrentLazyCollection() Lazily converts this SequenceM into a Collection.
default StreamableT<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 AnyM<CollectionX<T>>	toLazyCollection() Lazily converts this SequenceM into a Collection.
default <S,F> AnyM<Ior<ReactiveSeq<F>,ReactiveSeq<S>>>	validate(Validator<T,S,F> validator)
default <R> AnyM<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.

Method Detail

nestedFoldables

AnyM<? extends IterableFoldable<T>> nestedFoldables()

visit

default <R> AnyM<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:

mapReduce

default <R> AnyM<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<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<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 OptionalT<T> reduce(java.util.function.BinaryOperator<T> accumulator)

reduce

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

reduce

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

reduce

default ListT<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)

 {
  @code
  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<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 AnyM<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<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 -

accumulator -

Returns:

foldRight

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

foldRightMapToType

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

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

Returns:

Stream as concatenated String

join

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

stream

ReactiveSeq<T> stream()

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

headAndTail

default AnyM<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 OptionalT<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<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<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<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<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<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 AnyM<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 StreamableT<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 AnyM<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<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<T> single(java.util.function.Predicate<? super T> predicate)

singleOptional

default OptionalT<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 OptionalT<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
  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 = 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
  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

validate

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