com.aol.cyclops.lambda.monads

Interface Foldable<T>

All Known Subinterfaces:

SequenceM<T>

All Known Implementing Classes:

SequenceMImpl

public interface Foldable<T>

Method Summary

Modifier and Type	Method and Description
default T	foldLeft(Monoid<T> reducer) SequenceM.of("a","b","c").foldLeft(Reducers.toString("")); // "abc"
default T	foldLeft(T identity, java.util.function.BinaryOperator<T> accumulator) foldLeft : immutable reduction from left to right
default <T> T	foldLeftMapToType(Monoid<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 T	foldRight(Monoid<T> reducer) SequenceM.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 <T> T	foldRightMapToType(Monoid<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 <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(Monoid<R> reducer) Attempt to map this Sequence to the same type as the supplied Monoid (Reducer) Then use Monoid to reduce values
default java.util.Optional<T>	reduce(java.util.function.BinaryOperator<T> accumulator)
default java.util.List<T>	reduce(java.lang.Iterable<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) SequenceM.of("hello","2","world","4").reduce(Reducers.toString(",")); //hello,2,world,4
default java.util.List<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, java.util.function.BinaryOperator<U> combiner)
SequenceM<T>	stream()

Method Detail

stream

SequenceM<T> stream()

mapReduce

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

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

  
 SequenceM.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

  
  SequenceM.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)

  
 SequenceM.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,
                     java.util.function.BinaryOperator<U> combiner)

reduce

default java.util.List<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 = SequenceM.of(1, 2, 3, 4).reduce(Arrays.asList(sum, mult).stream());
 
        assertThat(result, equalTo(Arrays.asList(10, 24)));
 
 }
 

Parameters:

reducers -

Returns:

reduce

default java.util.List<T> reduce(java.lang.Iterable<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 = SequenceM.of(1,2,3,4))
 										.reduce(Arrays.asList(sum,mult) );
 				
 		 
 		assertThat(result,equalTo(Arrays.asList(10,24)));
 
 

Parameters:

reducers -

Returns:

foldLeft

default T foldLeft(Monoid<T> reducer)

                
 		SequenceM.of("a","b","c").foldLeft(Reducers.toString(""));
        
         // "abc"
         
 

Parameters:

reducer - Use supplied Monoid to reduce values starting via foldLeft

Returns:

Reduced result

foldLeft

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

foldLeft : immutable reduction from left to right

  
 
 assertTrue(SequenceM.of("a", "b", "c").foldLeft("", String::concat).equals("abc"));
 
 

foldLeftMapToType

default <T> T foldLeftMapToType(Monoid<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

                
 		SequenceM.of(1,2,3).foldLeftMapToType(Reducers.toString(""));
        
         // "123"
         
 

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

foldRight

default T foldRight(Monoid<T> reducer)

                
 		SequenceM.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(SequenceM.of("a","b","c").foldRight("", String::concat).equals("cba"));
 
 

Parameters:

identity -

accumulator -

Returns:

foldRightMapToType

default <T> T foldRightMapToType(Monoid<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

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

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result