Простой идиоматический способ определения порядка для простого класса case

У меня есть список простых экземпляров класса case scala, и я хочу напечатать их в предсказуемом, лексикографическом порядке, используя list.sorted, но получаю сообщение «Неявный порядок определен для ...».

Существует ли неявный, обеспечивающий лексикографический порядок для классов case?

Есть ли простой идиоматический способ смешать лексикографический порядок с классом case?

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

Меня не устраивает "хакерство":

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)сортировка по идентификатору. У этого есть несколько преимуществ:

• Сортировка определяется в одном месте как видимые артефакты кода. Это полезно, если у вас есть сложные сортировки по многим полям.
• Большинство функций сортировки, реализованных в библиотеке scala, работают с использованием экземпляров Ordering, поэтому упорядочивание напрямую исключает неявное преобразование в большинстве случаев.

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

Преимущество этого заключается в том, что он обновляется автоматически при изменении A. Но поля A должны быть размещены в том порядке, в котором они будут использоваться при упорядочении.

Подводя итог, есть три способа сделать это:

1. Для одноразовой сортировки используйте метод .sortBy, как показал @Shadowlands
2. Для повторного использования сортировки расширьте класс case с чертой Ordered, как сказал @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 арностей и так далее.

Такой вещи не существует для классов case, так как это непросто откатить, учитывая, что имена полей неизвестны априори (по крайней мере, без магии макросов), и вы не можете получить доступ к полям класса case другим способом, кроме имя / использование итератора продукта.

unapplyМетод объекта - компаньон обеспечивает преобразование из вашего случая класса к Option[Tuple], где Tupleесть кортеж , соответствующий первого список аргументов класса дела. Другими словами:

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)

Поскольку вы использовали класс case, вы можете расширить его с помощью 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