MapMonoidAggregator

abstract def keys: Set[K]

abstract def monoid: Monoid[B]

abstract def prepare(input: A): B

abstract def present(reduction: B): Map[K, C]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def andThenPresent[D](present2: (Map[K, C]) ⇒ D): MonoidAggregator[A, B, D]

Like calling andThen on the present function

def append(l: B, r: A): B

def appendAll(items: TraversableOnce[A]): B

def appendAll(old: B, items: TraversableOnce[A]): B

def apply(inputs: TraversableOnce[A]): Map[K, C]

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

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

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

def applyOption(inputs: TraversableOnce[A]): Option[Map[K, C]]

This returns None if the inputs are empty

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collectBefore[A2](fn: PartialFunction[A2, A]): MonoidAggregator[A2, B, Map[K, C]]

Only transform values where the function is defined, else discard

def composePrepare[A2](prepare2: (A2) ⇒ A): MonoidAggregator[A2, B, Map[K, C]]

Like calling compose on the prepare function

def cumulativeIterator(inputs: Iterator[A]): Iterator[Map[K, C]]

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

def either[A2, B2, C2](that: MonoidAggregator[A2, B2, C2]): MonoidAggregator[Either[A, A2], (B, B2), (Map[K, C], C2)]

Build a MonoidAggregator that either takes left or right input and outputs the pair from both

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filterBefore[A1 <: A](pred: (A1) ⇒ Boolean): MonoidAggregator[A1, B, Map[K, C]]

Only aggregate items that match a predicate

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def join[A2 <: A, B2, C2](that: Aggregator[A2, B2, C2]): Aggregator[A2, (B, B2), (Map[K, C], C2)]

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

def lift: MonoidAggregator[A, Option[B], Option[Map[K, C]]]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def reduce(items: TraversableOnce[B]): B

This may error if items is empty.

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

combine two inner values

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

This is the safe version of the above.

def semigroup: Monoid[B]

def sumBefore: MonoidAggregator[TraversableOnce[A], B, Map[K, C]]

This maps the inputs to Bs, then sums them, effectively flattening the inputs to the MonoidAggregator

final def synchronized[T0](arg0: ⇒ T0): T0

def toFold: Fold[A, Option[Map[K, 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

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def zip[A2, B2, C2](ag2: MonoidAggregator[A2, B2, C2]): MonoidAggregator[(A, A2), (B, B2), (Map[K, C], C2)]

This allows you to join two aggregators into one that takes a tuple input, which in turn allows you to chain .

def zip[A2, B2, C2](ag2: Aggregator[A2, B2, C2]): Aggregator[(A, A2), (B, B2), (Map[K, C], C2)]

This allows you to join two aggregators into one that takes a tuple input, which in turn allows you to chain .