Что такое расплывчатая неявная ошибка расширения?

При попытке найти решение другого вопроса ([1]) я столкнулся с расплывающейся неявной ошибкой расширения. Я ищу объяснение о том, что это означает

Здесь используется прецедент:

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
                                                ^

Ответы

Ответ 1

Если вы запустите это в scala с переданным аргументом -Xlog-implicits, вы получите дополнительную информацию:

scala.this.Prefed.conforms не является допустимым неявным значением для (T) = > Ordered [T], потому что:

несоответствие типов:

найдено: <: < [T, T]

требуется: (T) = > Упорядочено [T]

scala.this.predef.conforms не является допустимым неявным значением для (Ordered [T]) = > Ordered [Ordered [T]], потому что:

несоответствие типов:

найдено: <: < [Заказ [T], Заказ [T]]

требуется: (Заказ [T]) = > Заказ [Заказ [T]]

math.this.Ordering.ordered не является допустимым неявным значением для Ordering [T], потому что:

аргументы типа [T] не соответствуют методам упорядоченного типа метода [A <: scala.math.Ordered [A]]

Это в основном спекуляция, но, похоже, имеет смысл. Я попытаюсь продолжить исследование:

Это, по-видимому, предполагает, что здесь рассматриваются три имплицита. В конечном итоге для подписи sorted требуется найти что-то типа Ordering[T]. Поэтому он пытается построить вашу неявную функцию ordering. Во-первых, он пытается заполнить conv, найдя неявный тип (T) => Ordered[T], где он ищет в Predef, который кажется лаем вверх по неправильному дереву. Затем он пытается найти неявный для (Ordered[T]) => Ordered[Ordered[T]] в том же месте, поскольку by принимает неявный параметр типа Ordering[S], где S - Ordered[T] в силу conv. Поэтому он не может построить ordering.

Затем он пытается использовать ordering в math.Ordering, но это также не подходит. Тем не менее, я думаю, что это то, что дает несколько запутанное сообщение о "расходящихся имплицитах". Проблема заключается не в том, что они расходятся, а в том, что нет подходящего в своем объеме, но это путает тот факт, что есть два пути, чтобы спуститься. Если кто-то пытается определить def foo[T <% Ordered[T]](s : Seq[T]) = s.sorted без неявной упорядоченной функции, то он сбой просто с хорошим сообщением, говорящим, что он не может найти подходящий неявный.