Packages

trait FlatMapPreparer[A, T] extends Preparer[A, T]

A Preparer that has had one or more flatMap operations applied. It can only accept MonoidAggregators.

Linear Supertypes
Preparer[A, T], Serializable, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. FlatMapPreparer
  2. Preparer
  3. Serializable
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Abstract Value Members

  1. abstract def prepareFn: (A) => TraversableOnce[T]

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 aggregate[B, C](aggregator: MonoidAggregator[T, B, C]): MonoidAggregator[A, B, C]

    alias of monoidAggregate for convenience unlike MapPreparer's aggregate, can only take MonoidAggregator

  5. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  6. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  7. def collect[U](p: PartialFunction[T, U]): FlatMapPreparer[A, U]
    Definition Classes
    Preparer
  8. 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.

    Definition Classes
    Preparer
  9. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  10. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  11. def exists(pred: (T) => Boolean): MonoidAggregator[A, Boolean, Boolean]
    Definition Classes
    Preparer
  12. 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.

    Definition Classes
    Preparer
  13. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  14. 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.

    Definition Classes
    FlatMapPreparer → Preparer
  15. def flatten[U](implicit ev: <:<[T, TraversableOnce[U]]): FlatMapPreparer[A, U]

    Like flatMap using identity.

    Like flatMap using identity.

    Definition Classes
    Preparer
  16. def forall(pred: (T) => Boolean): MonoidAggregator[A, Boolean, Boolean]
    Definition Classes
    Preparer
  17. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  18. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  19. 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

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

    Definition Classes
    Preparer
  20. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  21. def lastOption: MonoidAggregator[A, Option[T], Option[T]]
    Definition Classes
    Preparer
  22. 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

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

    Definition Classes
    Preparer
  23. def map[U](fn: (T) => U): FlatMapPreparer[A, U]
  24. def maxOption(implicit ord: Ordering[T]): MonoidAggregator[A, Option[T], Option[T]]
    Definition Classes
    Preparer
  25. def maxOptionBy[U](fn: (T) => U)(implicit arg0: Ordering[U]): MonoidAggregator[A, Option[T], Option[T]]
    Definition Classes
    Preparer
  26. def minOption(implicit ord: Ordering[T]): MonoidAggregator[A, Option[T], Option[T]]
    Definition Classes
    Preparer
  27. def minOptionBy[U](fn: (T) => U)(implicit arg0: Ordering[U]): MonoidAggregator[A, Option[T], Option[T]]
    Definition Classes
    Preparer
  28. 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.

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

    Definition Classes
    FlatMapPreparer → Preparer
  29. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  30. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  31. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  32. def reduceOption(fn: (T, T) => T): MonoidAggregator[A, Option[T], Option[T]]
    Definition Classes
    Preparer
  33. def size: MonoidAggregator[A, Long, Long]
    Definition Classes
    Preparer
  34. def sortedReverseTake(count: Int)(implicit ord: Ordering[T]): MonoidAggregator[A, PriorityQueue[T], Seq[T]]
    Definition Classes
    Preparer
  35. def sortedTake(count: Int)(implicit ord: Ordering[T]): MonoidAggregator[A, PriorityQueue[T], Seq[T]]
    Definition Classes
    Preparer
  36. def split[B1, B2, C1, C2](fn: (FlatMapPreparer[TraversableOnce[T], T]) => (MonoidAggregator[TraversableOnce[T], B1, C1], MonoidAggregator[TraversableOnce[T], B2, C2])): Aggregator[A, (B1, B2), (C1, C2)]

    Split the processing into two parallel aggregations.

    Split the processing into two parallel aggregations. You provide a function which produces two different aggregators from this preparer, and it will return a single aggregator which does both aggregations in parallel. (See also Aggregator's join method.)

    We really need to generate N versions of this for 3-way, 4-way etc splits.

  37. def sum(implicit monoid: Monoid[T]): MonoidAggregator[A, T, T]

    Like monoidAggregate, but using an implicit Monoid to construct the Aggregator

  38. def sumOption(implicit sg: Semigroup[T]): MonoidAggregator[A, Option[T], Option[T]]
    Definition Classes
    Preparer
  39. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  40. def toList: MonoidAggregator[A, Option[Batched[T]], List[T]]
    Definition Classes
    Preparer
  41. def toSet: MonoidAggregator[A, Set[T], Set[T]]
    Definition Classes
    Preparer
  42. def toString(): String
    Definition Classes
    AnyRef → Any
  43. def uniqueCount: MonoidAggregator[A, Set[T], Int]
    Definition Classes
    Preparer
  44. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  45. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  46. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()

Inherited from Preparer[A, T]

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped