cyclops.companion

Class Reducers

java.lang.Object

cyclops.companion.Reducers

public class Reducers
extends java.lang.Object

Class that holds Reducers, Monoids with a type conversion for reducing a dataset to a singleUnsafe value. Primary use case is the reduction of Streams to persistent collections e.g.

  
 PersistentQueueX<Integer> q = Reducers.<Integer>toPersistentQueueX()
                                .mapReduce(Stream.of(1,2,3,4));
 
 
 

Use with care, as the mapReduce method is not type safe

Constructor Summary

Constructors

Constructor and Description
Reducers()

Method Summary

Modifier and Type	Method and Description
static <T> Reducer<BagX<T>>	toBagX() BagX<Integer> q = Reducers.<Integer>toBagX() .mapReduce(Stream.of(1,2,3,4));
static Reducer<java.lang.Double>	toCountDouble()
static Reducer<java.lang.Integer>	toCountInt()
static <T> Reducer<LinkedListX<T>>	toLinkedListX() LinkedListX<Integer> q = Reducers.<Integer>toLinkedListX() .mapReduce(Stream.of(1,2,3,4));
static <T> Reducer<OrderedSetX<T>>	toOrderedSetX() OrderedSetX<Integer> q = Reducers.<Integer>toOrderedSetX() .mapReduce(Stream.of(1,2,3,4));
static <T> Reducer<org.pcollections.PBag<T>>	toPBag() PBag<Integer> q = Reducers.<Integer>toPBag() .mapReduce(Stream.of(1,2,3,4));
static <T> Reducer<PersistentQueueX<T>>	toPersistentQueueX() PersistentQueueX<Integer> q = Reducers.<Integer>toPersistentQueueX() .mapReduce(Stream.of(1,2,3,4));
static <T> Reducer<PersistentSetX<T>>	toPersistentSetX() PersistentSetX<Integer> q = Reducers.<Integer>toPersistentSetX() .mapReduce(Stream.of(1,2,3,4));
static <K,V> Reducer<org.pcollections.PMap<K,V>>	toPMap() PMap<Integer,String> q = Reducers.<Integer,String>toPMap() .mapReduce(Stream.of(Arrays.asList("hello",1),Arrays.asList("world",2)));
static <K,V> Reducer<PersistentMapX<K,V>>	toPMapX() PersistentMapX<Integer,String> q = Reducers.<Integer,String>toPMapX() .mapReduce(Stream.of(Arrays.asList("hello",1),Arrays.asList("world",2)));
static <T> Reducer<org.pcollections.POrderedSet<T>>	toPOrderedSet() POrderedSet<Integer> q = Reducers.<Integer>toPOrderedSet() .mapReduce(Stream.of(1,2,3,4));
static <T> Reducer<org.pcollections.PQueue<T>>	toPQueue() PQueue<Integer> q = Reducers.<Integer>toPQueue() .mapReduce(Stream.of(1,2,3,4));
static <T> Reducer<org.pcollections.PSet<T>>	toPSet() PSet<Integer> q = Reducers.<Integer>toPSet() .mapReduce(Stream.of(1,2,3,4));
static <T> Reducer<org.pcollections.PStack<T>>	toPStack() PStack<Integer> q = Reducers.<Integer>toPStack() .mapReduce(Stream.of(1,2,3,4));
static <T> Reducer<org.pcollections.PStack<T>>	toPStackReversed() PStack<Integer> q = Reducers.<Integer>toPStackReversed() .mapReduce(Stream.of(1,2,3,4));
static <T> Reducer<org.pcollections.PVector<T>>	toPVector() PVector<Integer> q = Reducers.<Integer>toPVector() .mapReduce(Stream.of(1,2,3,4));
static Monoid<java.lang.String>	toString(java.lang.String joiner) Monoid for String concatonation
static Monoid<java.lang.Double>	toTotalDouble()
static Monoid<java.lang.Integer>	toTotalInt()
static <T> Reducer<VectorX<T>>	toVectorX() VectorX<Integer> q = Reducers.<Integer>toVectorX() .mapReduce(Stream.of(1,2,3,4));

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Reducers

public Reducers()

Method Detail

toPersistentQueueX

public static <T> Reducer<PersistentQueueX<T>> toPersistentQueueX()

  
 PersistentQueueX<Integer> q = Reducers.<Integer>toPersistentQueueX()
                                .mapReduce(Stream.of(1,2,3,4));
 
 
 

Returns:

Reducer to PersistentQueueX types

toOrderedSetX

public static <T> Reducer<OrderedSetX<T>> toOrderedSetX()

  
 OrderedSetX<Integer> q = Reducers.<Integer>toOrderedSetX()
                                .mapReduce(Stream.of(1,2,3,4));
 
 
 

Returns:

Reducer to OrderedSetX

toPersistentSetX

public static <T> Reducer<PersistentSetX<T>> toPersistentSetX()

  
 PersistentSetX<Integer> q = Reducers.<Integer>toPersistentSetX()
                                .mapReduce(Stream.of(1,2,3,4));
 
 
 

Returns:

Reducer for PersistentSetX

toLinkedListX

public static <T> Reducer<LinkedListX<T>> toLinkedListX()

  
 LinkedListX<Integer> q = Reducers.<Integer>toLinkedListX()
                                .mapReduce(Stream.of(1,2,3,4));
 
 
 

Returns:

Reducer for LinkedListX

toVectorX

public static <T> Reducer<VectorX<T>> toVectorX()

  
 VectorX<Integer> q = Reducers.<Integer>toVectorX()
                                .mapReduce(Stream.of(1,2,3,4));
 
 
 

Returns:

Reducer for VectorX

toBagX

public static <T> Reducer<BagX<T>> toBagX()

  
 BagX<Integer> q = Reducers.<Integer>toBagX()
                                .mapReduce(Stream.of(1,2,3,4));
 
 
 

Returns:

Reducer for BagX

toPQueue

public static <T> Reducer<org.pcollections.PQueue<T>> toPQueue()

  
 PQueue<Integer> q = Reducers.<Integer>toPQueue()
                                .mapReduce(Stream.of(1,2,3,4));
 
 
 

Returns:

Reducer to PQueue types

toPOrderedSet

public static <T> Reducer<org.pcollections.POrderedSet<T>> toPOrderedSet()

  
 POrderedSet<Integer> q = Reducers.<Integer>toPOrderedSet()
                                .mapReduce(Stream.of(1,2,3,4));
 
 
 

Returns:

Reducer to POrderedSet

toPBag

public static <T> Reducer<org.pcollections.PBag<T>> toPBag()

  
 PBag<Integer> q = Reducers.<Integer>toPBag()
                                .mapReduce(Stream.of(1,2,3,4));
 
 
 

Returns:

Reducer for PBag

toPSet

public static <T> Reducer<org.pcollections.PSet<T>> toPSet()

  
 PSet<Integer> q = Reducers.<Integer>toPSet()
                                .mapReduce(Stream.of(1,2,3,4));
 
 
 

Returns:

Reducer for PSet

toPVector

public static <T> Reducer<org.pcollections.PVector<T>> toPVector()

  
 PVector<Integer> q = Reducers.<Integer>toPVector()
                                .mapReduce(Stream.of(1,2,3,4));
 
 
 

Returns:

Reducer for PVector

toPStack

public static <T> Reducer<org.pcollections.PStack<T>> toPStack()

  
 PStack<Integer> q = Reducers.<Integer>toPStack()
                                .mapReduce(Stream.of(1,2,3,4));
 
 
 

Returns:

Reducer for PStack

toPStackReversed

public static <T> Reducer<org.pcollections.PStack<T>> toPStackReversed()

  
 PStack<Integer> q = Reducers.<Integer>toPStackReversed()
                                .mapReduce(Stream.of(1,2,3,4));
 
 
 

Returns:

Reducer for PStack in reveresed order

toPMap

public static <K,V> Reducer<org.pcollections.PMap<K,V>> toPMap()

  
 PMap<Integer,String> q = Reducers.<Integer,String>toPMap()
                                .mapReduce(Stream.of(Arrays.asList("hello",1),Arrays.asList("world",2)));
 
 
 

Returns:

Reducer for PMap

toPMapX

public static <K,V> Reducer<PersistentMapX<K,V>> toPMapX()

  
 PersistentMapX<Integer,String> q = Reducers.<Integer,String>toPMapX()
                                        .mapReduce(Stream.of(Arrays.asList("hello",1),Arrays.asList("world",2)));
 
 
 

Returns:

Reducer for PersistentMapX

toString

public static Monoid<java.lang.String> toString(java.lang.String joiner)

Monoid for String concatonation

Parameters:

joiner - String combiner

Returns:

toTotalInt

public static Monoid<java.lang.Integer> toTotalInt()

Returns:

Monoid for summing Ints

toCountInt

public static Reducer<java.lang.Integer> toCountInt()

Returns:

Reducer for counting number of values

toTotalDouble

public static Monoid<java.lang.Double> toTotalDouble()

Returns:

Monoid for summing doubles

toCountDouble

public static Reducer<java.lang.Double> toCountDouble()

Returns:

Reducer for counting doubles by converting toString to Double.valueOf( )