trait Aggregator[-A, B, +C] extends Serializable
This is a type that models map/reduce(map). First each item is mapped, then we reduce with a semigroup, then finally we present the results.
Unlike Fold, Aggregator keeps it's middle aggregation type externally visible. This is because Aggregators are useful in parallel map/reduce systems where there may be some additional types needed to cross the map/reduce boundary (such a serialization and intermediate storage). If you don't care about the middle type, an _ may be used and the main utility of the instance is still preserved (e.g. def operate[T](ag: Aggregator[T, _, Int]): Int)
Note, join is very useful to combine multiple aggregations with one pass. Also GeneratedTupleAggregator.fromN((agg1, agg2, ... aggN)) can glue these together well.
This type is the the Fold.M from Haskell's fold package: https://hackage.haskell.org/package/folds-0.6.2/docs/Data-Fold-M.html
- Self Type
- Aggregator[A, B, C]
- Alphabetic
- By Inheritance
- Aggregator
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Abstract Value Members
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
- def andThenPresent[D](present2: (C) => D): Aggregator[A, B, D]
Like calling andThen on the present function
- def append(l: B, r: A): B
- def appendAll(old: B, items: TraversableOnce[A]): B
- 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.
This returns the cumulative sum of its inputs, in the same order. If the inputs are empty, the result will be empty too.
- def applyOption(inputs: TraversableOnce[A]): Option[C]
This returns None if the inputs are empty
- 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 composePrepare[A1](prepare2: (A1) => A): Aggregator[A1, B, 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.
This returns the cumulative sum of its inputs, in the same order. If the inputs are empty, the result will be empty too.
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def join[A2 <: A, B2, C2](that: Aggregator[A2, B2, C2]): Aggregator[A2, (B, B2), (C, C2)]
This allows you to run two aggregators on the same data with a single pass
- def lift: MonoidAggregator[A, Option[B], Option[C]]
- 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 reduce(items: TraversableOnce[B]): B
This may error if items is empty.
This may error if items is empty. To be safe you might use reduceOption if you don't know that items is non-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.
This is the safe version of the above. If the input in empty, return None, else reduce the items
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- 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
- Definition Classes
- AnyRef → Any
- 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()
- def zip[A2, B2, C2](ag2: Aggregator[A2, B2, C2]): Aggregator[(A, A2), (B, 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.
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.
The law here is: ag1.zip(ag2).apply(as.zip(bs)) == (ag1(as), ag2(bs))