Question

I’m trying to implement a distinctOn function for a sequence which will take a function f and return a sequence for which each item has a distinct result when the f is applied to it. EG:

case class Person(name:String, age:Int)

val people = Seq(Person("Al", 20), Person("Bob", 21), 
                 Person("Bob", 24)).distinctOn(_.name)

//people should be:

Seq(Person("Al", 20), Person("Bob", 21))

where the first duplicate (Al) is returned, and order is preserved. My current implementation contains a var, and my other attempts using Sets and GroupBy didn’t preserve order. Is there a better way to implement this without the var? For the record my current attempt is:

  def distinctOn[A](f: T => A):Seq[T]={
    var seen = Set[A]()

    seq.foldLeft(Seq[T]()) { (res, curr) => {
      if(!seen.contains(f(curr))){
        seen = seen ++ Set[A](f(curr))
        res ++ Seq(curr)
      }else{
        res
      }
    }}
  }

Answer 1

Here’s an implementation which preserves order where applicable and also works for other Traversables than Seqs. It is based on the implementation of distinct and uses the builder factories (a.k.a. CanBuildFroms) used in other collection methods.

class TraversableOnceExt[A, CC[A] <: TraversableOnce[A]](coll: CC[A]) {
  import collection.generic.CanBuildFrom
  def distinctBy[B, That](f: A => B)(implicit cbf: CanBuildFrom[CC[A], A, That]): That = {
    val b = cbf(coll)
    val seen = collection.mutable.HashSet[B]()
    for (x <- coll) {
      val v = f(x)
      if (!seen(v)) {
        b += x
        seen += v
      }
    }
    b.result
  }
}

implicit def commomExtendTraversable[A, C[A] <: TraversableOnce[A]](coll: C[A]): TraversableOnceExt[A, C] =
  new TraversableOnceExt[A, C](coll)