sealed trait Preparer[A, T] extends Serializable
Preparer is a way to build up an Aggregator through composition using a more natural API: it allows you to start with the input type and describe a series of transformations and aggregations from there, rather than starting from the aggregation and composing "outwards" in both directions.
Uses of Preparer will always start with a call to Preparer[A], and end with a call to monoidAggregate or a related method, to produce an Aggregator instance.
- Alphabetic
- By Inheritance
- Preparer
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Abstract Value Members
- abstract def flatMap[U](fn: (T) => TraversableOnce[U]): FlatMapPreparer[A, U]
Produce a new Preparer that chains this one-to-many transformation.
Produce a new Preparer that chains this one-to-many transformation. Because "many" could include "none", this limits future aggregations to those done using monoids.
- abstract 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.
Concrete Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- 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.
count and following methods all just call monoidAggregate with one of the standard Aggregators. see the Aggregator object for more docs.
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- 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.
Filter out values that do not meet the predicate. Like flatMap, this limits future aggregations to MonoidAggregator.
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- 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[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- 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
- Definition Classes
- Any
- 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 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 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]]
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- 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 sumOption(implicit sg: Semigroup[T]): MonoidAggregator[A, Option[T], Option[T]]
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toList: MonoidAggregator[A, Option[Batched[T]], List[T]]
- def toSet: MonoidAggregator[A, Set[T], Set[T]]
- def toString(): String
- Definition Classes
- AnyRef → Any
- def uniqueCount: MonoidAggregator[A, Set[T], Int]
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()