conversion - implicit def scala

¿Qué es un error de expansión implícito divergente?

Question

Al tratar de encontrar una solución a otra pregunta ( [1] ) encontré un error de expansión implícito divergente. Estoy buscando una explicación sobre lo que esto significa

Aquí está el caso de uso:

scala> implicit def ordering[T](implicit conv: T => Ordered[T], res: Ordering[Ordered[T]]) = Ordering.by(conv)
ordering: [T](implicit conv: (T) => Ordered[T],implicit res: Ordering[Ordered[T]])scala.math.Ordering[T]

scala> def foo[T <% Ordered[T]](s : Seq[T]) = s.sorted
<console>:6: error: diverging implicit expansion for type Ordering[T]
starting with method ordering in object $iw
       def foo[T <% Ordered[T]](s : Seq[T]) = s.sorted
                                                ^

Answer 1

Si ejecuta esto en scala con el argumento -Xlog-implicits pasado, obtendrá más información:

scala.this.Prefed.conforms no es un valor implícito válido para (T) => Pedido [T] porque:

tipo desajuste:

encontrado: <: <[T, T]

requerido: (T) => Pedido [T]

scala.this.predef.conforms no es un valor implícito válido para (Ordered [T]) => Ordered [Ordered [T]] porque:

tipo desajuste:

encontrado: <: <[ordenado [T], ordenado [T]]

requerido: (Ordered [T]) => Ordered [Ordered [T]]

math.this.Ordering.ordered no es un valor implícito válido para ordenar [T] porque:

Los argumentos de tipo [T] no se ajustan a los límites de parámetros de tipo del método ordenado [A <: scala.math.Ordered [A]]

Esto es principalmente especulación, pero parece tener algún sentido. Trataré de investigar más a fondo:

Esto parece sugerir que hay tres implicaciones que se están considerando aquí. En definitiva, la firma del sorted requiere que encuentre algo de tipo Ordering[T] . Entonces está tratando de construir su orden implícito de funciones. En primer lugar, está intentando rellenar conv mediante la búsqueda de un implícito de tipo (T) => Ordered[T] , donde está buscando en Predef, lo que parece una intromisión en el árbol equivocado. Está tratando de encontrar un implícito para (Ordered[T]) => Ordered[Ordered[T]] en el mismo lugar, ya que toma un parámetro implícito de tipo Ordering[S] , donde S es Ordered[T] en virtud de conv . Entonces no puede construir ordering .

Luego intenta usar el ordering en matemática. Hacer pedidos, pero esto tampoco encaja. Sin embargo, creo que esto es lo que está dando el confuso mensaje de "implícitas divergentes". El problema no es que estén divergiendo, es que no hay un alcance adecuado, pero se confunde por el hecho de que hay dos caminos para bajar. Si uno trata de definir def foo[T <% Ordered[T]](s : Seq[T]) = s.sorted sin la función implícita ordenada, entonces falla con solo un lindo mensaje que dice que no puede encontrar un adecuado implícito