com.aol.cyclops.types

Interface Foldable<T>

All Known Subinterfaces:

AnyM<T>, AnyMSeq<T>, AnyMValue<T>, ApplicativeFunctor<T>, CollectionX<T>, ConvertableFunctor<T>, ConvertableSequentialFunctor<T>, DequeX<T>, Eval<T>, ExtendedTraversable<T>, FeatureToggle<F>, FluentCollectionX<T>, FluentSequenceX<T>, Ior<ST,PT>, IterableFoldable<T>, IterableFunctor<T>, LazyFutureStream<U>, ListX<T>, MapX<K,V>, Matchable.ValueAndOptionalMatcher<T>, Maybe<T>, MonadicValue<T>, MonadicValue1<T>, MonadicValue2<T1,T2>, 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>, TransformerValue<T>, Try<T,X>, Value<T>, Xor<ST,PT>, ZippingApplicativable<T>

All Known Implementing Classes:

AnyMSeqImpl, AnyMValueImpl, CollectionXImpl, CompletableFutureTSeq, CompletableFutureTValue, DequeXImpl, Eval.Module.Always, Eval.Module.Later, EvalTSeq, EvalTValue, FeatureToggle.Disabled, FeatureToggle.Enabled, FutureW, FutureWTSeq, FutureWTValue, Ior.Both, Ior.Primary, Ior.Secondary, LazyFutureStreamImpl, LazyImmutable, ListXImpl, MapXImpl, MaterializedList, Maybe.Just, Maybe.Lazy, Maybe.Nothing, MaybeTSeq, MaybeTValue, Mutable, MutableBoolean, MutableByte, MutableChar, MutableDouble, MutableFloat, MutableInt, MutableLong, MutableShort, OptionalTSeq, OptionalTValue, PBagXImpl, PMapXImpl, POrderedSetXImpl, PQueueXImpl, PSetXImpl, PStackXImpl, PVectorXImpl, QueueXImpl, ReactiveSeqImpl, ReversedIterator, SetXImpl, SortedSetXImpl, StreamableImpl, Try.Failure, Try.Success, TryTSeq, TryTValue, Value.ValueImpl, ValueSubscriber, Xor.Primary, Xor.Secondary, XorTSeq, XorTValue

public interface Foldable<T>

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 Foldable<T>	foldable()
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)
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,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 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)
default void	print(java.io.PrintWriter writer)
default void	printErr()
default void	printOut()
default java.util.Optional<T>	reduce(java.util.function.BinaryOperator<T> accumulator)
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) ReactiveSeq.of("hello","2","world","4").reduce(Reducers.toString(",")); //hello,2,world,4
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)
default <U> U	reduce(U identity, java.util.function.BiFunction<U,? super T,U> accumulator)
default <U> 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 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)));
ReactiveSeq<T>	stream()
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 boolean	xMatch(int num, java.util.function.Predicate<? super T> c) Check that there are specified number of matches of predicate in the Stream

Method Detail

stream

ReactiveSeq<T> stream()

foldable

default Foldable<T> foldable()

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)

  
 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)

reduce

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

reduce

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

reduce

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

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)

 {
        @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).foldable());
 
        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 -

accumulator -

Returns:

Reduced value

foldRight

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

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)

print

default void print(java.io.PrintWriter writer)

printOut

default void printOut()

printErr

default void printErr()

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

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 Foldable has the same elements in the same order, at the start

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:

Lazy Collection

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:

Concurrent Lazy Collection

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

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> Ior<ReactiveSeq<F>,ReactiveSeq<S>> validate(Validator<T,S,F> validator)

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