Einfache idiomatische Definition der Reihenfolge für eine einfache Fallklasse

Ich habe eine Liste einfacher Scala-Fallklasseninstanzen und möchte sie in vorhersehbarer, lexikografischer Reihenfolge mit drucken list.sorted, erhalte jedoch "Keine implizite Reihenfolge definiert für ...".

Gibt es ein Implizit, das eine lexikografische Reihenfolge für Fallklassen vorsieht?

Gibt es eine einfache idiomatische Möglichkeit, die lexikografische Reihenfolge in die Fallklasse einzumischen?

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

Ich bin nicht glücklich mit einem "Hack":

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

Meine persönliche Lieblingsmethode besteht darin, die bereitgestellte implizite Reihenfolge für Tupel zu verwenden, da diese klar, präzise und korrekt ist:

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

Das funktioniert , weil der BegleiterOrdered definiert eine implizite Konvertierung von Ordering[T]zu Ordered[T]denen in Rahmen für jede Klasse ist die Umsetzung Ordered. Das Vorhandensein von impliziten Orderings für Tuples ermöglicht eine Konvertierung von TupleN[...]zu, Ordered[TupleN[...]]sofern Ordering[TN]für alle Elemente T1, ..., TNdes Tupels ein implizites s vorhanden ist. Dies sollte immer der Fall sein, da es keinen Sinn macht, nach einem Datentyp mit no zu sortieren Ordering.

Die implizite Reihenfolge für Tupel ist Ihre Anlaufstelle für jedes Sortierszenario mit einem zusammengesetzten Sortierschlüssel:

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

Da sich diese Antwort als beliebt erwiesen hat, möchte ich darauf eingehen und darauf hinweisen, dass eine Lösung, die der folgenden ähnelt, unter bestimmten Umständen als Enterprise-Grade ™ angesehen werden kann:

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

Gegeben es: SeqLike[Employee], es.sorted()wird nach Namen und es.sorted(Employee.orderingById)nach ID sortiert. Dies hat einige Vorteile:

• Die Sortierungen werden an einer einzelnen Stelle als sichtbare Code-Artefakte definiert. Dies ist nützlich, wenn Sie in vielen Feldern komplexe Sortierungen haben.
• Die meisten in der Scala-Bibliothek implementierten Sortierfunktionen werden mit Instanzen von ausgeführt Ordering. Wenn Sie also eine Bestellung direkt bereitstellen, wird in den meisten Fällen eine implizite Konvertierung vermieden.

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

Dies hat den Vorteil, dass es automatisch aktualisiert wird, wenn sich A ändert. Die Felder von A müssen jedoch in der Reihenfolge platziert werden, in der die Bestellung sie verwendet.

Zusammenfassend gibt es drei Möglichkeiten, dies zu tun:

1. Verwenden Sie für die einmalige Sortierung die Methode .sortBy, wie @Shadowlands gezeigt hat
2. Erweitern Sie für die Wiederverwendung der Sortierung die Fallklasse mit dem Merkmal "Geordnet", wie @Keith sagte.

3. Definieren Sie eine benutzerdefinierte Bestellung. Der Vorteil dieser Lösung besteht darin, dass Sie Bestellungen wiederverwenden und Instanzen derselben Klasse auf mehrere Arten sortieren können:

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

Beantwortung Ihrer Frage Gibt es eine Standardfunktion in der Scala, die wie List ((2,1), (1,2)) zaubern kann? Sortiert

Es gibt eine Reihe vordefinierter Ordnungen , z. B. für String, Tupel bis zu 9 Arity und so weiter.

Für Fallklassen gibt es so etwas nicht, da das Abrollen nicht einfach ist, da Feldnamen nicht a priori bekannt sind (zumindest ohne Makromagie) und Sie nicht auf andere Weise als durch auf Fallklassenfelder zugreifen können Name / mit Produktiterator.

Die unapplyMethode des Begleitobjekts bietet eine Konvertierung von Ihrer Fallklasse in eine Option[Tuple], wobei das Tupledas Tupel ist, das der ersten Argumentliste der Fallklasse entspricht. Mit anderen Worten:

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

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

Die sortBy-Methode wäre eine typische Methode, z. B. (Sortieren nach tagFeld):

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

Da Sie eine Fallklasse verwendet haben, können Sie mit Ordered wie folgt erweitern:

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