为简单案例类定义订购的简单惯用方式

我有一个简单的scala案例类实例列表，我想使用list.sorted，以可预测的字典顺序打印它们，但是会收到“没有为...定义隐式排序”。

是否存在为案例类提供词典编排顺序的隐式？

是否有简单的惯用方式将词典顺序混合到案例类中？

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

我对“ hack”不满意：

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

我个人最喜欢的方法是使用提供的元组隐式排序，因为它是清晰，简洁和正确的：

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

之所以有效，是因为的伴随Ordered定义了从Ordering[T]到的隐式转换Ordered[T]任何实现的类都属于范围Ordered。隐的存在OrderingS表示TupleS启用从一个转换TupleN[...]到Ordered[TupleN[...]]提供的隐式Ordering[TN]存在的所有元素T1, ..., TN的元组的，这应始终是因为它是没有意义的排序上没有一个数据类型的情况下Ordering。

对于任何涉及复合排序键的排序方案，元组的隐式排序都是您的首选：

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

由于这个答案很受欢迎，因此我想对此进行扩展，并指出在某些情况下可以将类似于以下内容的解决方案视为企业级™：

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

给定es: SeqLike[Employee]，es.sorted()将按名称排序，并将es.sorted(Employee.orderingById)按ID排序。这有一些好处：

• 排序在单个位置定义为可见的代码工件。如果您在许多字段上进行复杂的排序，这将很有用。
• Scala库中实现的大多数排序功能都是使用的实例运行的Ordering，因此在大多数情况下，提供排序可以直接消除隐式转换。

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

这样的好处是，只要A更改，它就会自动更新。但是，A的字段需要按照顺序使用它们的顺序放置。

总结起来，有三种方法可以做到这一点：

1. 对于一次性排序，请使用.sortBy方法，如@Shadowlands所示
2. 为了重用排序，请扩展具有Ordered特性的case类，如@Keith所述。

3. 定义自定义顺序。该解决方案的好处在于，您可以重用顺序并具有多种方法来对同一类的实例进行排序：

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

回答您的问题Scala中是否包含任何可以执行魔术的标准函数，例如List（（2,1），（1,2，））。sorted

有一组预定义的顺序，例如，用于String，元组（最多9个arity）等等。

对于案例类，不存在这样的事情，因为要转换字段名并不是先验的（至少在没有使用魔术的情况下），并且您不能以除by之外的其他方式访问案例类字段，因此要滚降是不容易的事情名称/使用产品迭代器。

unapply伴随对象的方法提供了从您的case类到的转换Option[Tuple]，其中Tuple是与case类的第一个参数列表相对应的元组。换一种说法：

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

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

sortBy方法将是一种典型的方法，例如（按tag字段排序）：

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

由于使用了案例类，因此可以像这样扩展Ordered：

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