Was ist ein divergierender impliziter Expansionsfehler?

Question

Beim Versuch, eine Lösung für eine andere Frage zu finden ( [1] ) Ich bin auf einen divergierenden impliziten Erweiterungsfehler gestoßen.Ich suche nach einer Erklärung, was dies bedeutet

Hier ist der Anwendungsfall:

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

Wenn Sie dies in scala mit dem übergebenen -Xlog-implicits-Argument ausführen, erhalten Sie weitere Informationen:

scala.this.Prefed.conforms ist kein gültiger impliziter Wert für (T)=> Bestellt [T], weil:

Typkonflikt:

gefunden: <: <[T, T]

erforderlich: (T)=> Bestellt [T]

scala.this.predef.conforms ist kein gültiger impliziter Wert für (Ordered [T])=> Ordered [Ordered [T]], weil:

Typkonflikt:

gefunden: <: <[Bestellt [T], Bestellt [T]]

erforderlich: (bestellt [T])=> bestellt [bestellt [T]]

math.this.Ordering.ordered ist kein gültiger impliziter Wert für Ordering [T], weil:

Typargumente [T] entsprechen nicht den Typparametergrenzen der bestellten Methode [A <: scala.math.Ordered [A]]

Dies ist hauptsächlich Spekulation, scheint aber sinnvoll zu sein. Ich werde versuchen, weitere Untersuchungen durchzuführen:

Dies scheint darauf hinzudeuten, dass hier drei Implikationen berücksichtigt werden. Letztendlich erfordert die Signatur von sorted, dass etwas vom Typ Ordering[T] gefunden wird. Es wird also versucht, Ihre implizite Funktion ordering zu erstellen. Erstens wird versucht, conv einzugeben, indem ein Implizit vom Typ (T) => Ordered[T] gefunden wird, in dem in Predef gesucht wird - was so aussieht, als würde der falsche Baum angebellt. Es wird dann versucht, ein implizites für (Ordered[T]) => Ordered[Ordered[T]] an derselben Stelle zu finden, da by einen impliziten Parameter vom Typ Ordering[S] verwendet, wobei S aufgrund von Ordered[T] conv ist. Es kann also keinen ordering erstellen.

Es wird dann versucht, ordering in math.Ordering zu verwenden, aber dies passt auch nicht. Ich denke jedoch, dass dies die etwas verwirrende Botschaft der "divergierenden Implikationen" vermittelt. Das Problem ist nicht, dass sie voneinander abweichen, sondern dass es keinen geeigneten gibt, aber es wird durch die Tatsache verwirrt, dass es zwei Wege gibt, die man beschreiten kann. Wenn man versucht, def foo[T <% Ordered[T]](s : Seq[T]) = s.sorted ohne die implizit geordnete Funktion zu definieren, schlägt dies mit einer netten Meldung fehl, die besagt, dass kein geeignetes implizites gefunden werden kann.