com.aol.cyclops.types

Interface Foldable<T>

All Known Subinterfaces:

AnyM<T>, AnyMSeq<T>, AnyMValue<T>, Applicativable<T>, CollectionX<T>, ConvertableFunctor<T>, ConvertableSequentialFunctor<T>, DequeX<T>, Eval<T>, ExtendedTraversable<T>, FeatureToggle<F>, FluentCollectionX<T>, FluentSequenceX<T>, Ior<ST,PT>, IterableFunctor<T>, LazyFutureStream<U>, ListX<T>, MapX<K,V>, Matchable.ValueAndOptionalMatcher<T>, 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>, Sequential<T>, SetX<T>, SortedSetX<T>, Streamable<T>, Trampoline<T>, Traversable<T>, Try<T,X>, Value<T>, Xor<ST,PT>, ZippingApplicativable<T>

All Known Implementing Classes:

AnyMSeqImpl, AnyMValueImpl, CollectionXImpl, DequeXImpl, Eval.Always, Eval.Later, Eval.Now, FeatureToggle.Disabled, FeatureToggle.Enabled, FutureW, Ior.Both, Ior.Primary, Ior.Secondary, LazyFutureStreamImpl, LazyImmutable, ListXImpl, MapXImpl, MaterializedList, Maybe.Just, Maybe.Lazy, Maybe.Nothing, Mutable, MutableBoolean, MutableByte, MutableChar, MutableDouble, MutableFloat, MutableInt, MutableLong, MutableShort, PBagXImpl, PMapXImpl, POrderedSetXImpl, PQueueXImpl, PSetXImpl, PStackXImpl, PVectorXImpl, QueueXImpl, ReactiveSeqImpl, ReversedIterator, SetXImpl, SortedSetXImpl, StreamableImpl, Try.Failure, Try.Success, Value.ValueImpl, ValueSubscriber, Xor.Primary, Xor.Secondary

public interface Foldable<T>

Method Summary

Modifier and Type	Method and Description
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,U,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.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)
ReactiveSeq<T>	stream()

Method Detail

stream

ReactiveSeq<T> stream()

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).stream());
 
        assertThat(result, equalTo(Arrays.asList(10, 24)));
 
 }
 

Parameters:

reducers -

Returns:

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:

foldRight

default <U> U foldRight(U identity,
                        java.util.function.BiFunction<? super T,U,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()