AbstractEventuallyAggregator

abstract def convert(o: O): E

abstract def leftSemigroup: Semigroup[E]

abstract def mustConvert(o: O): Boolean

abstract def presentLeft(e: E): C

abstract def rightAggregator: Aggregator[A, O, C]

abstract def semigroup: Semigroup[Either[E, O]]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def andThenPresent[D](present2: (C) ⇒ D): Aggregator[A, Either[E, O], D]

Like calling andThen on the present function

def append(l: Either[E, O], r: A): Either[E, O]

def appendAll(old: Either[E, O], items: TraversableOnce[A]): Either[E, O]

def apply(inputs: TraversableOnce[A]): C

This may error if inputs are empty (for Monoid Aggregators it never will, instead you see present(Monoid.

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.

def applyOption(inputs: TraversableOnce[A]): Option[C]

This returns None if the inputs are empty

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def composePrepare[A1](prepare2: (A1) ⇒ A): Aggregator[A1, Either[E, O], 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.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def join[A2 <: A, B2, C2](that: Aggregator[A2, B2, C2]): Aggregator[A2, (Either[E, O], B2), (C, C2)]

This allows you to run two aggregators on the same data with a single pass

def lift: MonoidAggregator[A, Option[Either[E, O]], Option[C]]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def prepare(a: A): Right[Nothing, O]

def present(b: Either[E, O]): C

def reduce(items: TraversableOnce[Either[E, O]]): Either[E, O]

This may error if items is empty.

def reduce(l: Either[E, O], r: Either[E, O]): Either[E, O]

combine two inner values

def reduceOption(items: TraversableOnce[Either[E, O]]): Option[Either[E, O]]

This is the safe version of the above.

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

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zip[A2, B2, C2](ag2: Aggregator[A2, B2, C2]): Aggregator[(A, A2), (Either[E, O], B2), (C, C2)]

This allows you to join two aggregators into one that takes a tuple input, which in turn allows you to chain .