Easy idiomatic way to define Ordering for a simple case class

by

My personal favorite method is to make use of the provided implicit ordering for Tuples, as it is clear, concise, and correct:

case class A(tag: String, load: Int) extends Ordered[A] {
  // Required as of Scala 2.11 for reasons unknown - the companion to Ordered
  // should already be in implicit scope
  import scala.math.Ordered.orderingToOrdered

  def compare(that: A): Int = (this.tag, this.load) compare (that.tag, that.load)
}

This works because the companion to Ordered defines an implicit conversion from Ordering[T] to Ordered[T] which is in scope for any class implementing Ordered. The existence of implicit Orderings for Tuples enables a conversion from TupleN[...] to Ordered[TupleN[...]] provided an implicit Ordering[TN] exists for all elements T1, ..., TN of the tuple, which should always be the case because it makes no sense to sort on a data type with no Ordering.

The implicit ordering for Tuples is your go-to for any sorting scenario involving a composite sort key:

as.sortBy(a => (a.tag, a.load))

As this answer has proven popular I would like to expand on it, noting that a solution resembling the following could under some circumstances be considered enterprise-grade™:

case class Employee(id: Int, firstName: String, lastName: String)

object Employee {
  // Note that because `Ordering[A]` is not contravariant, the declaration
  // must be type-parametrized in the event that you want the implicit
  // ordering to apply to subclasses of `Employee`.
  implicit def orderingByName[A <: Employee]: Ordering[A] =
    Ordering.by(e => (e.lastName, e.firstName))

  val orderingById: Ordering[Employee] = Ordering.by(e => e.id)
}

Given es: SeqLike[Employee], es.sorted() will sort by name, and es.sorted(Employee.orderingById) will sort by id. This has a few benefits:

  • The sorts are defined in a single location as visible code artifacts. This is useful if you have complex sorts on many fields.
  • Most sorting functionality implemented in the scala library operates using instances of Ordering, so providing an ordering directly eliminates an implicit conversion in most cases.

More Related Contents:

  1. To check whether my list fulfils the parameters set out in nested loop in scala function
  2. Case objects vs Enumerations in Scala
  3. Cleaner way to update nested structures
  4. Case class equality in Apache Spark
  5. What is the difference between Scala’s case class and class?
  6. How to define schema for custom type in Spark SQL?
  7. How to override apply in a case class companion
  8. How to get around the Scala case class limit of 22 fields?
  9. Case class to map in Scala
  10. Mixing in a trait dynamically
  11. Scala Macros: Making a Map out of fields of a class in Scala
  12. What is *so* wrong with case class inheritance?
  13. Scala case class inheritance
  14. Overload constructor for Scala’s Case Classes?
  15. How to sort a list in Scala by two fields?
  16. Why is parameter in contravariant position?
  17. Should I use the final modifier when declaring case classes?
  18. Scala 2.10 reflection, how do I extract the field values from a case class, i.e. field list from case class
  19. “dynamically” creating case classes with macros
  20. How is this case class match pattern working?
  21. Spark extracting values from a Row
  22. Scala: Merge map
  23. Spark / Scala: forward fill with last observation
  24. Pattern matching on generic type in Scala
  25. What good are right-associative methods in Scala?
  26. Getting the index of the current loop in Play! 2 Scala template
  27. How to get keys and values from MapType column in SparkSQL DataFrame
  28. Addition of two RDD[mllib.linalg.Vector]’s
  29. ScalaTest in sbt: is there a way to run a single test without tags?
  30. How to vectorize DataFrame columns for ML algorithms?

Leave a Comment