Question

I’ll start the ball rolling.

Given a sequence of elements, some of which can be contained multiple times, one typical requirement is to count them – in the form of a tally or histogram.

The oft-quoted solution is:

ss.groupBy(identity).mapValues(_.size)

So what other solutions exist for similar commonly encountered problems in Scala?

Answer 1

Using Monoids or Numerics to define sensible operations for rich classes, using implicits if necessary.

case class Money(ccy: Currency, amount : BigDecimal) {
  def +(that : Money) = { 
    require(this.currency == that.curency)
    copy(amount = this.amount + that.amount)
  }
  def abs = copy(amount = amount.abs)
}

So then let’s say I have a collection of Money‘s and I want to sum them:

val turnover = trades.map(_.usdValue.abs).∑ //no implicit monoid :-(

But in order to do this I need to have an implicit Monoid. But of course, a zero value for a Money only makes sense if I have some currency already!

implicit def CurrencyMonoid(implicit currency : Currency) = new Monoid[Currency] {
  def zero = Money(currency, 0)
  def append(m1 : Money, m2 : Money) = m1 + m2
}

So now Scala will use both of these implicits:

implicit val usd = Currency.USD
val turnover = trades.map(_.usdValue.abs).∑ //yay for monoids :-)