MapPreparer

abstract def prepareFn: (A) ⇒ T

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def aggregate[B, C](aggregator: Aggregator[T, B, C]): Aggregator[A, B, C]

Produce a new Aggregator which includes the Preparer's transformation chain in its prepare stage.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collect[U](p: PartialFunction[T, U]): FlatMapPreparer[A, U]

def count(pred: (T) ⇒ Boolean): MonoidAggregator[A, Long, Long]

count and following methods all just call monoidAggregate with one of the standard Aggregators.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(pred: (T) ⇒ Boolean): MonoidAggregator[A, Boolean, Boolean]

def filter(fn: (T) ⇒ Boolean): FlatMapPreparer[A, T]

Filter out values that do not meet the predicate.

def finalize(): Unit

def flatMap[U](fn: (T) ⇒ TraversableOnce[U]): FlatMapPreparer[A, U] { val prepareFn: A => TraversableOnce[U] }

Produce a new Preparer that chains this one-to-many transformation.

def flatten[U](implicit ev: <:<[T, TraversableOnce[U]]): FlatMapPreparer[A, U]

Like flatMap using identity.

def forall(pred: (T) ⇒ Boolean): MonoidAggregator[A, Boolean, Boolean]

final def getClass(): Class[_]

def hashCode(): Int

def head: Aggregator[A, T, T]

head and following methods all just call aggregate with one of the standard Aggregators.

def headOption: MonoidAggregator[A, Option[T], Option[T]]

headOption and following methods are all just calling lift with standard Aggregators see the Aggregator object for more docs

final def isInstanceOf[T0]: Boolean

def last: Aggregator[A, T, T]

def lastOption: MonoidAggregator[A, Option[T], Option[T]]

def lift[B, C](aggregator: Aggregator[T, B, C]): MonoidAggregator[A, Option[B], Option[C]]

transform a given Aggregator into a MonoidAggregator by lifting the reduce and present stages into Option space

def map[U](fn: (T) ⇒ U): MapPreparer[A, U]

def max(implicit ord: Ordering[T]): Aggregator[A, T, T]

def maxBy[U](fn: (T) ⇒ U)(implicit arg0: Ordering[U]): Aggregator[A, T, T]

def maxOption(implicit ord: Ordering[T]): MonoidAggregator[A, Option[T], Option[T]]

def maxOptionBy[U](fn: (T) ⇒ U)(implicit arg0: Ordering[U]): MonoidAggregator[A, Option[T], Option[T]]

def min(implicit ord: Ordering[T]): Aggregator[A, T, T]

def minBy[U](fn: (T) ⇒ U)(implicit arg0: Ordering[U]): Aggregator[A, T, T]

def minOption(implicit ord: Ordering[T]): MonoidAggregator[A, Option[T], Option[T]]

def minOptionBy[U](fn: (T) ⇒ U)(implicit arg0: Ordering[U]): MonoidAggregator[A, Option[T], Option[T]]

def monoidAggregate[B, C](aggregator: MonoidAggregator[T, B, C]): MonoidAggregator[A, B, C]

Produce a new MonoidAggregator which includes the Preparer's transformation chain in its prepare stage.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def reduce(fn: (T, T) ⇒ T): Aggregator[A, T, T]

def reduceOption(fn: (T, T) ⇒ T): MonoidAggregator[A, Option[T], Option[T]]

def size: MonoidAggregator[A, Long, Long]

def sortedReverseTake(count: Int)(implicit ord: Ordering[T]): MonoidAggregator[A, PriorityQueue[T], Seq[T]]

def sortedTake(count: Int)(implicit ord: Ordering[T]): MonoidAggregator[A, PriorityQueue[T], Seq[T]]

def split[B1, B2, C1, C2](fn: (MapPreparer[T, T]) ⇒ (Aggregator[T, B1, C1], Aggregator[T, B2, C2])): Aggregator[A, (B1, B2), (C1, C2)]

Split the processing into two parallel aggregations.

def sum(implicit sg: Semigroup[T]): Aggregator[A, T, T]

def sumOption(implicit sg: Semigroup[T]): MonoidAggregator[A, Option[T], Option[T]]

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

def toList: MonoidAggregator[A, Option[Batched[T]], List[T]]

def toSet: MonoidAggregator[A, Set[T], Set[T]]

def toString(): String

def uniqueCount: MonoidAggregator[A, Set[T], Int]

final def wait(): Unit

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

final def wait(arg0: Long): Unit