I find sorting stuff with Scala quite cumbersome in the sense that there's no general rule on how it's done. For example, to sort a List there's List.sort :: (A, A) => Boolean. To sort an Array we've got scala.util.Sorting which needs elements to be "comparable" (inherit Ordered[A]). To provide an ordering to a PriorityQueue[A] there's a parameter taking: A => Ordered[A].

Is there a plan to unify this?

In the meantime, here's some code I found useful to cope with it:

I stumbled into this mess trying to use a custom ordering for a PriorityQueue[(Int, Stream[Int])]. I wanted to sort the elements based on the first item in the tuple. I came up with this (inspired by Haskell's `compare `on` f`

):

def compareOn[A, B <% Ordered[B]](f: A => B)(x: A): Ordered[A] = new Ordered[A] {
def compare(y: A) = f(x) compare f(y)
}
This lets me do stuff like:

new PriorityQueue[(Int, Stream[Int])()(compareOn(_._1))
... or sorting an array of strings, as, by length (longest first):

scala.util.Sorting.quickSort(as)(compareOn(-_.length))
... which is quite neat.

To sort a List of strings, it's possible to use the Ordering trait like this:

def orderingOn[A, B <% Ordered[B]](f: A => B): Ordering[A] = new Ordering[A] {
def compare(x: A, y: A) = f(x) compare f(y)
}
List[String](...).sort(orderingOn((_: String).length).lt)
One can redefine compareOn to use orderedOn:

def compareOn[A, B <% Ordered[B]](f: A => B)(x: A): Ordered[A] = new Ordered[A] {
def compare(y: A) = orderingOn(f).compare(x, y)
}
Hope someone finds this useful.