Manera idiomática fácil de definir Ordering para una clase de caso simple

Tengo una lista de instancias simples de clases de casos de Scala y quiero imprimirlas en un orden lexicográfico predecible usando list.sorted, pero recibo "Sin orden implícito definido para ...".

¿Existe un implícito que proporcione un orden lexicográfico para las clases de casos?

¿Existe una forma idiomática simple de mezclar el orden lexicográfico en la clase de caso?

scala> case class A(tag:String, load:Int)
scala> val l = List(A("words",50),A("article",2),A("lines",7))

scala> l.sorted.foreach(println)
<console>:11: error: No implicit Ordering defined for A.
          l.sorted.foreach(println)
            ^

No estoy contento con un 'truco':

scala> l.map(_.toString).sorted.foreach(println)
A(article,2)
A(lines,7)
A(words,50)

Mi método favorito personal es hacer uso del orden implícito proporcionado para Tuples, ya que es claro, conciso y correcto:

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)
}

Esto funciona porque el compañero deOrdered define una conversión implícita de Ordering[T]a Ordered[T]que está dentro del alcance de la implementación de cualquier clase Ordered. La existencia de Orderings implícitos para Tuples permite una conversión deTupleN[...] a Ordered[TupleN[...]]siempre que Ordering[TN]exista un implícito para todos los elementos T1, ..., TNde la tupla, lo que siempre debería ser el caso porque no tiene sentido ordenar un tipo de datos con no Ordering.

El orden implícito para Tuples es su opción para cualquier escenario de clasificación que involucre una clave de clasificación compuesta:

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

Como esta respuesta ha demostrado ser popular, me gustaría ampliarla, señalando que una solución similar a la siguiente podría, en algunas circunstancias, considerarse de nivel empresarial ™:

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)
}

Dado es: SeqLike[Employee],es.sorted() ordenará por nombre y es.sorted(Employee.orderingById)ordenará por id. Esto tiene algunos beneficios:

• Las clases se definen en una única ubicación como artefactos de código visibles. Esto es útil si tiene ordenaciones complejas en muchos campos.
• La mayoría de las funciones de ordenación implementadas en la biblioteca scala operan utilizando instancias de Ordering, por lo que proporcionar una ordenación directamente elimina una conversión implícita en la mayoría de los casos.

object A {
  implicit val ord = Ordering.by(unapply)
}

Esto tiene la ventaja de que se actualiza automáticamente cada vez que A cambia. Sin embargo, los campos de A deben colocarse en el orden en que los utilizará el pedido.

Para resumir, hay tres formas de hacer esto:

1. Para una clasificación única, use el método .sortBy, como lo ha demostrado @Shadowlands
2. Para reutilizar la clasificación, extienda la clase de caso con el rasgo Ordered, como dijo @Keith.

3. Defina un pedido personalizado. El beneficio de esta solución es que puede reutilizar los pedidos y tener varias formas de ordenar instancias de la misma clase:

   case class A(tag:String, load:Int)
   
   object A {
     val lexicographicalOrdering = Ordering.by { foo: A => 
       foo.tag 
     }
   
     val loadOrdering = Ordering.by { foo: A => 
       foo.load 
     }
   }
   
   implicit val ord = A.lexicographicalOrdering 
   val l = List(A("words",1), A("article",2), A("lines",3)).sorted
   // List(A(article,2), A(lines,3), A(words,1))
   
   // now in some other scope
   implicit val ord = A.loadOrdering
   val l = List(A("words",1), A("article",2), A("lines",3)).sorted
   // List(A(words,1), A(article,2), A(lines,3))

Respondiendo tu pregunta ¿Existe alguna función estándar incluida en Scala que pueda hacer magia como List ((2,1), (1,2)). Sorted

Hay un conjunto de ordenamientos predefinidos , por ejemplo, para String, tuplas hasta 9 arity y así sucesivamente.

No existe tal cosa para las clases de casos, ya que no es fácil de rodar, dado que los nombres de campo no se conocen a priori (al menos sin la magia de macros) y no puede acceder a los campos de clases de casos de otra manera que no sea por nombre / usando iterador de producto.

El unapplymétodo del objeto complementario proporciona una conversión de su clase de caso a an Option[Tuple], donde Tuplees la tupla correspondiente a la primera lista de argumentos de la clase de caso. En otras palabras:

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

def sortPeople(people : List[Person]) = 
    people.sortBy(Person.unapply)

El método sortBy sería una forma típica de hacer esto, por ejemplo (ordenar por tagcampo):

scala> l.sortBy(_.tag)foreach(println)
A(article,2)
A(lines,7)
A(words,50)

Como usó una clase de caso, puede extender con Ordered como tal:

case class A(tag:String, load:Int) extends Ordered[A] { 
  def compare( a:A ) = tag.compareTo(a.tag) 
}

val ls = List( A("words",50), A("article",2), A("lines",7) )

ls.sorted