Facile modo idiomatico per definire l'ordinamento per una semplice classe di casi

Ho un elenco di istanze di classe scala case semplici e desidero stamparle in un ordine lessicografico prevedibile utilizzando list.sorted, ma ricevo "Nessun ordine implicito definito per ...".

Esiste un implicito che fornisce un ordinamento lessicografico per le classi di casi?

C'è un modo semplice e idiomatico per mescolare l'ordinamento lessicografico nella classe dei casi?

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

Non sono soddisfatto di un "hack":

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

Il mio metodo preferito personale è quello di utilizzare l'ordinamento implicito fornito per le tuple, poiché è chiaro, conciso e corretto:

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

Questo funziona perché il compagno perOrdered definisce una conversione implicita da Ordering[T]a Ordered[T]che è nell'ambito di qualsiasi implementazione di classe Ordered. L'esistenza di implicit Orderings per Tuples consente una conversione da TupleN[...]a Ordered[TupleN[...]]purché Ordering[TN]esista un implicito per tutti gli elementi T1, ..., TNdella tupla, il che dovrebbe sempre essere il caso perché non ha senso ordinare su un tipo di dati con no Ordering.

L'ordinamento implicito per le tuple è il tuo punto di riferimento per qualsiasi scenario di ordinamento che coinvolga una chiave di ordinamento composta:

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

Poiché questa risposta si è dimostrata popolare, vorrei approfondirla, osservando che una soluzione simile alla seguente potrebbe in alcune circostanze essere considerata di livello aziendale ™:

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

Dato es: SeqLike[Employee], es.sorted()ordinerà per nome e es.sorted(Employee.orderingById)ordinerà per ID. Questo ha alcuni vantaggi:

• Gli ordinamenti vengono definiti in un'unica posizione come artefatti di codice visibili. Ciò è utile se disponi di ordinamenti complessi su molti campi.
• La maggior parte delle funzionalità di ordinamento implementate nella libreria scala opera utilizzando istanze di Ordering, quindi fornire un ordinamento direttamente elimina una conversione implicita nella maggior parte dei casi.

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

Ciò ha il vantaggio che viene aggiornato automaticamente ogni volta che A cambia. Tuttavia, i campi di A devono essere inseriti nell'ordine in cui verranno utilizzati dall'ordinamento.

Per riassumere, ci sono tre modi per farlo:

1. Per l'ordinamento una tantum usa il metodo .sortBy, come ha mostrato @Shadowlands
2. Per riutilizzare l'ordinamento estendi la classe case con il tratto Ordered, come ha detto @Keith.

3. Definisci un ordine personalizzato. Il vantaggio di questa soluzione è che puoi riutilizzare gli ordini e avere diversi modi per ordinare le istanze della stessa classe:

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

Rispondere alla tua domanda C'è qualche funzione standard inclusa in Scala che può fare magie come List ((2,1), (1,2)).

C'è una serie di ordinamenti predefiniti , ad esempio per String, tuple fino a 9 arity e così via.

Non esiste nulla di simile per le classi case, dal momento che non è facile da eseguire, dato che i nomi dei campi non sono noti a priori (almeno senza la magia delle macro) e non è possibile accedere ai campi delle classi case in un modo diverso da nome / utilizzando l'iteratore del prodotto.

Il unapplymetodo dell'oggetto associato fornisce una conversione dalla classe case in an Option[Tuple], dove Tupleè la tupla corrispondente al primo elenco di argomenti della classe case. In altre parole:

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

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

Il metodo sortBy sarebbe un modo tipico per farlo, ad esempio (ordina sul tagcampo):

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

Dato che hai usato una classe case puoi estenderla con Ordered in questo modo:

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