trait MonoidAggregator[-A, B, +C] extends Aggregator[A, B, C]
- Alphabetic
- By Inheritance
- MonoidAggregator
- Aggregator
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Abstract Value Members
- abstract def monoid: Monoid[B]
-
abstract
def
prepare(input: A): B
- Definition Classes
- Aggregator
-
abstract
def
present(reduction: B): C
- Definition Classes
- Aggregator
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): MonoidAggregator[A, B, D]
Like calling andThen on the present function
Like calling andThen on the present function
- Definition Classes
- MonoidAggregator → Aggregator
-
def
append(l: B, r: A): B
- Definition Classes
- Aggregator
- def appendAll(items: TraversableOnce[A]): B
-
def
appendAll(old: B, items: TraversableOnce[A]): B
- Definition Classes
- Aggregator
-
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])
This may error if inputs are empty (for Monoid Aggregators it never will, instead you see present(Monoid.zero[B])
- Definition Classes
- Aggregator
-
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.
- Definition Classes
- Aggregator
-
def
applyOption(inputs: TraversableOnce[A]): Option[C]
This returns None if the inputs are empty
This returns None if the inputs are empty
- Definition Classes
- Aggregator
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
def
collectBefore[A2](fn: PartialFunction[A2, A]): MonoidAggregator[A2, B, C]
Only transform values where the function is defined, else discard
-
def
composePrepare[A2](prepare2: (A2) ⇒ A): MonoidAggregator[A2, B, C]
Like calling compose on the prepare function
Like calling compose on the prepare function
- Definition Classes
- MonoidAggregator → Aggregator
-
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.
- Definition Classes
- Aggregator
-
def
either[A2, B2, C2](that: MonoidAggregator[A2, B2, C2]): MonoidAggregator[Either[A, A2], (B, 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
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
filterBefore[A1 <: A](pred: (A1) ⇒ Boolean): MonoidAggregator[A1, B, C]
Only aggregate items that match a predicate
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
-
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
This allows you to run two aggregators on the same data with a single pass
- Definition Classes
- Aggregator
-
def
lift: MonoidAggregator[A, Option[B], Option[C]]
- Definition Classes
- Aggregator
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
-
final
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
- Definition Classes
- MonoidAggregator → Aggregator
-
def
reduce(l: B, r: B): B
combine two inner values
combine two inner values
- Definition Classes
- Aggregator
-
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
- Definition Classes
- Aggregator
-
def
semigroup: Monoid[B]
- Definition Classes
- MonoidAggregator → Aggregator
-
def
sumBefore: MonoidAggregator[TraversableOnce[A], B, C]
This maps the inputs to Bs, then sums them, effectively flattening the inputs to the MonoidAggregator
-
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
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
- Definition Classes
- Aggregator
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
def
zip[A2, B2, C2](ag2: MonoidAggregator[A2, B2, C2]): MonoidAggregator[(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))
-
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))
- Definition Classes
- Aggregator