¿Por qué las listas de Scala no tienen un pedido?

Question

¿Hay algún motivo por el que no haya un pedido implícito de listas en Scala?

val lists = List(List(2, 3, 1), List(2, 1, 3)) 
lists.sorted 

error: could not find implicit value for parameter ord: Ordering[List[Int]] 

EDITAR

Sí, mi pregunta es por qué no hay una función de pedidos que ya está implícita en su alcance. Para mí, parece obvio que la segunda lista debe ser "menor que" la primera lista ya que los elementos en 0 son iguales y la segunda lista tiene el elemento inferior en 1. Me preguntaba si tal vez es que no hay una buena respuesta cuando el Las listas son de dos tamaños diferentes.

Answer 1

Creo que es un descuido. El orden lexicográfico tiene sentido en Seqs. Deberíamos agregarlo a la biblioteca estándar.

Answer 2

Lo que tienes es una lista de listas, no una lista de enteros. Lo que se está perdiendo es un criterio para determinar si una lista es < = otra lista, o no.

Eso es lo que dice el mensaje de error: No puedo encontrar una manera de comparar una lista con otra, debe proporcionar una explícitamente.

Si su pregunta era "¿por qué no enumerar tiene un método de comparación incorporado contra otras listas?", Bueno, así es como es.

Answer 3

El único orden total realmente sensato sobre la clase de List [Int] sería lexicográfico (es decir, compara los primeros elementos de la lista, luego el segundo si son iguales, el tercero si los segundos son iguales, etc.) Esto no lo proporciona la biblioteca estándar, probablemente porque no hay muchos casos en los que realmente se necesite. Sería bastante fácil crear una conversión implícita de Lista [X] a Ordenar [Lista [X]] que implementaría eso, y luego simplemente podría importar esa conversión donde sea que la necesite.

Answer 4

Puede usar sortWith. Esto no tiene listas de diferentes tamaños en cuenta porque postal lanzará la diferencia, pero creo que hace algo como lo que está buscando:

lists.sortWith((a,b) => { 
    a.zip(b).filterNot(x => x._1 == x._2) match { 
    case Nil => true 
    case t => t._1 < t._2 
    } 
}) 

Answer 5

Por cierto, incluso antes me fijo que esto le podría hacer esto de otras maneras:

scala> List[Iterable[Int]](List(2, 3, 1), List(2, 1, 3)).sorted 
res0: List[Iterable[Int]] = List(List(2, 1, 3), List(2, 3, 1)) 

scala> List(List(2, 3, 1), List(2, 1, 3)).sorted(Ordering[Iterable[Int]]) 
res1: List[List[Int]] = List(List(2, 1, 3), List(2, 3, 1)) 

Pero ahora funciona como se esperaría.

Edición: debido a problemas de divergencia incompletos con el requisito implícito, lo saqué del alcance predeterminado. Tener una conversión implícita que actúa a través de un atado de esta manera:

implicit def SeqDerived[CC[X] <: collection.Seq[X], T](implicit ord: Ordering[T]): Ordering[CC[T]] 

... es una receta posibilidad de problemas. Estará disponible en 2.9, pero debes importarlo de la siguiente manera.

scala> val lists = List(List(2, 3, 1), List(2, 1, 3)) 
lists: List[List[Int]] = List(List(2, 3, 1), List(2, 1, 3)) 

scala> lists.sorted 
<console>:9: error: could not find implicit value for parameter ord: Ordering[List[Int]] 
     lists.sorted 
      ^

scala> import Ordering.Implicits._ 
import Ordering.Implicits._ 

scala> lists.sorted 
res1: List[List[Int]] = List(List(2, 1, 3), List(2, 3, 1))