Demonstration of upper bounds with an Ordered mixin and merge sort implementation in Scala

object Example {
  class Person(val firstName: String, val lastName: String) extends Ordered[Person] {
    def compare(that: Person) = {
      val lastNameComparison = lastName.compareToIgnoreCase(that.lastName)
      if(lastNameComparison != 0) lastNameComparison else {
        firstName.compareToIgnoreCase(that.firstName)
      }
    }
    override def toString = lastName + " - " + firstName
  }

  def orderedMergeSort[T <: Ordered[T]](xs: List[T]): List[T] = {
    def merge(xs: List[T], ys: List[T]): List[T] = (xs, ys) match {
      case (Nil, bs) => bs
      case (as, Nil) => as
      case (a :: as, b :: bs) => {
        if(a < b) a :: merge(as, ys)
        else b :: merge(xs, bs)
      }
    }
    val n = xs.length / 2
    if (n == 0) xs else {
      val (ys, zs) = xs splitAt(n)
      merge(orderedMergeSort(ys), orderedMergeSort(zs))
    }
  }
}

object Test {

  import Example._
  {
    val people = List(
      new Person("Larry", "Wall"),
      new Person("Anders", "Hejlsberg")
    )
    orderedMergeSort(people)
  }
}