PriorityQueueAggregator

abstract def present(reduction: PriorityQueue[A]): C

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def andThenPresent[D](present2: (C) ⇒ D): MonoidAggregator[A, PriorityQueue[A], D]

Like calling andThen on the present function

def append(l: PriorityQueue[A], r: A): PriorityQueue[A]

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

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

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])

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.

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

This returns None if the inputs are empty

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def composePrepare[A2](prepare2: (A2) ⇒ A): MonoidAggregator[A2, PriorityQueue[A], C]

Like calling compose on the prepare function

def cumulativeIterator(inputs: Iterator[A]): Iterator[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], (PriorityQueue[A], B2), (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, PriorityQueue[A], 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, (PriorityQueue[A], B2), (C, C2)]

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

def lift: MonoidAggregator[A, Option[PriorityQueue[A]], Option[C]]

val monoid: PriorityQueueMonoid[A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def prepare(a: A): PriorityQueue[A]

final def reduce(items: TraversableOnce[PriorityQueue[A]]): PriorityQueue[A]

This may error if items is empty.

def reduce(l: PriorityQueue[A], r: PriorityQueue[A]): PriorityQueue[A]

combine two inner values

def reduceOption(items: TraversableOnce[PriorityQueue[A]]): Option[PriorityQueue[A]]

This is the safe version of the above.

def semigroup: Monoid[PriorityQueue[A]]

def sumBefore: MonoidAggregator[TraversableOnce[A], PriorityQueue[A], 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[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), (PriorityQueue[A], 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.

def zip[A2, B2, C2](ag2: Aggregator[A2, B2, C2]): Aggregator[(A, A2), (PriorityQueue[A], 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.