AveragedValue aggregator for Optional type?

[Vincent Grosbois]

hi !
is there an average aggregator (as in, com.twitter.algebird.AveragedValue) that works for scala Option types, much like Hive works by default?
For instance in Hive, averaging 1, 3 and NULL, will return 2. Averaging NULL, NULL and NULL will return NULL.
Is there a class to do this with Algebird or should I roll my own aggregator, based on the AveragedValue aggregator?

Thanks!

[P. Oscar Boykin]

you can geek out a bit here. Let's assume you have Int as you seem to above:

val intAve = AveragedValue.numericAggregator[Int]

// Now we actually have Option[Int], so we add a second aggregator

val unitAggregator = Aggregator.fromMoniod[Unit]

// now combine:

val opt: MonoidAggregator[Option[Int], _, Option[Double]] = unitAggregator.either(intAve)

  .composePrepare { opt: Option[Int] =>

    opt match {

      case None => Left(()) // unit

      case Some(i) => Right(i)

    }

  }

  .andThenPresent { case (_, av) =>

    if (av.count == 0L) None else Some(av.value)

  }

something like that should work.

--
You received this message because you are subscribed to the Google Groups "algebird" group.
To unsubscribe from this group and stop receiving emails from it, send an email to algebird+u...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

--

P. Oscar Boykin, Ph.D. | http://twitter.com/posco | http://pobox.com/~boykin

[Danielle Sucher]

Hm, I was thinking:

val agg = AveragedValue.numericAggregator[Int].lift

val optionAgg = new MonoidAggregator[Option[Int], Option[AveragedValue], Option[Double]] {

  def prepare(input: Option[Int]): Option[AveragedValue] = input.flatMap(agg.prepare(_))

  def present(reduction: Option[AveragedValue]): Option[Double] = agg.present(reduction)

  def monoid = agg.monoid

}

@DanielleSucher
http://daniellesucher.com

[P. Oscar Boykin]

yeah, that is nicer. I was trying to do it all with combinators, but it is clumsy.

I prefer yours.

[Avi Bryant]

If we're playing golf, isn't this just

val agg = AveragedValue.numericAggregator[Int].lift.sumBefore ?

[P. Oscar Boykin]

I thought he wanted to preserve the Option on the result if all were None. But maybe that was just how Hive did it and not important.

The type of hive's average function seems something like: Iterable[Option[Number]] => Option[Number]

[P. Oscar Boykin]

My mental type checker was off. Avi's is right.