Packages

trait Aggregator[-A, B, +C] extends Serializable

This is a type that models map/reduce(map). First each item is mapped, then we reduce with a semigroup, then finally we present the results.

Unlike Fold, Aggregator keeps it's middle aggregation type externally visible. This is because Aggregators are useful in parallel map/reduce systems where there may be some additional types needed to cross the map/reduce boundary (such a serialization and intermediate storage). If you don't care about the middle type, an _ may be used and the main utility of the instance is still preserved (e.g. def operate[T](ag: Aggregator[T, _, Int]): Int)

Note, join is very useful to combine multiple aggregations with one pass. Also GeneratedTupleAggregator.fromN((agg1, agg2, ... aggN)) can glue these together well.

This type is the the Fold.M from Haskell's fold package: https://hackage.haskell.org/package/folds-0.6.2/docs/Data-Fold-M.html

Self Type
Aggregator[A, B, C]
Linear Supertypes
Serializable, AnyRef, Any
Known Subclasses
AbstractEventuallyAggregator, Averager, BloomFilterAggregator, CMSAggregator, EventuallyAggregator, EventuallyMonoidAggregator, FirstAggregator, GenHLLAggregator, HyperLogLogAggregator, LastAggregator, MapAggregator, MapMonoidAggregator, MaxAggregator, MinAggregator, MomentsAggregator, MonoidAggregator, QTreeAggregator, QTreeAggregatorLowerBound, RingAggregator, SetSizeAggregator, SetSizeAggregatorBase, SetSizeHashAggregator, SketchMapAggregator, TopCMSAggregator, TopKToListAggregator, TopNCMSAggregator, TopPctCMSAggregator, PriorityQueueAggregator, PriorityQueueToListAggregator
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Aggregator
  2. Serializable
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Abstract Value Members

  1. abstract def prepare(input: A): B
  2. abstract def present(reduction: B): C
  3. abstract def semigroup: Semigroup[B]

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def andThenPresent[D](present2: (C) ⇒ D): Aggregator[A, B, D]

    Like calling andThen on the present function

  5. def append(l: B, r: A): B
  6. def appendAll(old: B, items: TraversableOnce[A]): B
  7. def apply(inputs: TraversableOnce[A]): C

    This may error if inputs are empty (for Monoid Aggregators it never will, instead you see present(Monoid.zero[B])

  8. def applyCumulatively[In <: TraversableOnce[A], Out](inputs: In)(implicit bf: CanBuildFrom[In, C, Out]): Out

    This returns the cumulative sum of its inputs, in the same order.

    This returns the cumulative sum of its inputs, in the same order. If the inputs are empty, the result will be empty too.

  9. def applyOption(inputs: TraversableOnce[A]): Option[C]

    This returns None if the inputs are empty

  10. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  11. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  12. def composePrepare[A1](prepare2: (A1) ⇒ A): Aggregator[A1, B, C]

    Like calling compose on the prepare function

  13. def cumulativeIterator(inputs: Iterator[A]): Iterator[C]

    This returns the cumulative sum of its inputs, in the same order.

    This returns the cumulative sum of its inputs, in the same order. If the inputs are empty, the result will be empty too.

  14. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  15. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  16. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  17. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
  18. def hashCode(): Int
    Definition Classes
    AnyRef → Any
  19. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  20. def join[A2 <: A, B2, C2](that: Aggregator[A2, B2, C2]): Aggregator[A2, (B, B2), (C, C2)]

    This allows you to run two aggregators on the same data with a single pass

  21. def lift: MonoidAggregator[A, Option[B], Option[C]]
  22. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  23. final def notify(): Unit
    Definition Classes
    AnyRef
  24. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  25. def reduce(items: TraversableOnce[B]): B

    This may error if items is empty.

    This may error if items is empty. To be safe you might use reduceOption if you don't know that items is non-empty

  26. def reduce(l: B, r: B): B

    combine two inner values

  27. def reduceOption(items: TraversableOnce[B]): Option[B]

    This is the safe version of the above.

    This is the safe version of the above. If the input in empty, return None, else reduce the items

  28. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  29. def toFold: Fold[A, Option[C]]

    An Aggregator can be converted to a Fold, but not vice-versa Note, a Fold is more constrained so only do this if you require joining a Fold with an Aggregator to produce a Fold

  30. def toString(): String
    Definition Classes
    AnyRef → Any
  31. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  32. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  33. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  34. def zip[A2, B2, C2](ag2: Aggregator[A2, B2, C2]): Aggregator[(A, A2), (B, B2), (C, C2)]

    This allows you to join two aggregators into one that takes a tuple input, which in turn allows you to chain .composePrepare onto the result if you have an initial input that has to be prepared differently for each of the joined aggregators.

    This allows you to join two aggregators into one that takes a tuple input, which in turn allows you to chain .composePrepare onto the result if you have an initial input that has to be prepared differently for each of the joined aggregators.

    The law here is: ag1.zip(ag2).apply(as.zip(bs)) == (ag1(as), ag2(bs))

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped