Scala从隐式类方法中选择了错误的隐式转换
当隐式类声明中发生转换时，编译器未能选择正确的隐式转换方法。在下面的示例中，我有一个Foo[T]类和一个隐式Helper类，它采用 aFoo并提供一个print方法。该 print 方法调用show，它本身是一个由 on 隐式转换提供的方法Foo。
问题是有两种可能的转换提供show：一种转换Foo[T]为 a Bar[T]，另一种转换Foo[Array[T]]为 a BarArray[T]。这个想法是，当我们有一个Foo包含数组的时候，我们想要应用更具体的BarArray转换。据我了解，编译器首先选择具有最具体类型的转换。
这在正常上下文中起作用，如下例所示，但print在隐式Helper类中的方法的上下文中中断。在那里，show调用了相同的方法，因此我希望应该应用相同的转换。然而，在这种情况下，编译器总是选择Bar转换，即使它有Foo[Array[T]]并且应该选择BarArray转换。
出了什么问题？
最小失败代码示例：
package scratch
import scala.language.implicitConversions
class Foo[T](val value: T) {}
object Foo {
implicit def fooToBar[T](foo: Foo[T]): Bar[T] = {
new Bar(foo.value)
}
implicit def fooArrayToBarArray[T](foo: Foo[Array[T]]): BarArray[T] = {
new BarArray(foo.value)
}
}
class Bar[T](val value: T) {
def show(): String = {
s"Bar($value)"
}
}
class BarArray[T](val value: Array[T]) {
def show(): String = {
value.map(v => s"Bar($v)").mkString(", ")
}
}
object Scratch extends App {
implicit class Helper[T](foo: Foo[T]) {
def print(): Unit = {
println(foo.show())
}
}
val foo0 = new Foo(123)
val foo1 = new Foo(Array(123, 456))
// conversions to Bar and BarArray work correctly here
println(foo0.show()) // Bar(123)
println(foo1.show()) // Bar(123), Bar(456)
// conversions called from within the implicit Helper class
// always choose the Bar conversion
foo0.print // Bar(123)
foo1.print // Bar([I@xxxxxxxx) <- should be Bar(123), Bar(456)
}
版本：
- 斯卡拉 2.12.10
- SBT 1.4.3
- JDK 1.8.0_241
回答
隐式解析是在编译时“调度”的，因此它只能在特定位置访问编译器可用的（类型）信息。
这里
val foo0 = new Foo(123)
val foo1 = new Foo(Array(123, 456))
// conversions to Bar and BarArray work correctly here
println(foo0.show()) // Bar(123)
println(foo1.show()) // Bar(123), Bar(456)
编译器以这种方式推断类型并隐式：
val foo0: Foo[Int] = new Foo(123)
val foo1: Foo[Array[Int]] = new Foo(Array(123, 456))
println(fooToBar(foo0).show()) // Bar(123)
// fooArrayToBarArray instead fooToBar because
// compiler knows that foo1: Foo[Array[Int]]
println(fooArrayToBarArray(foo1).show()) // Bar(123), Bar(456)
然而这里：
implicit class Helper[T](foo: Foo[T]) {
def print(): Unit = {
println(foo.show())
}
}
所有编译器都知道 foo: Foo[T]. 现在必须解决相同的代码，没有作为参数传入的隐式，解决方案必须编译一次，然后键入擦除踢，留下最适合这里的任何隐式的硬编码值。fooToBar完美地工作。fooArrayToBarArray期望证明 Foo 的参数是Array[T]为 some 的T，但无处可寻。通过在此处传递数组，您将忘记它，从而使编译器无法使用特定于数组的实现。
这就是@LuisMiguelMejíaSuárez 建议类型类的原因：
// type class
trait FooPrinter[A] {
def show[A](foo: Foo[A]): String
def print[A](foo: Foo[A]): Unit = println(show(foo))
}
object FooPrinter {
// convenient summon method
def apply[A](implicit printer: FooPrinter[A]): FooPrinter[A] = printer
}
class Foo[T](val value: T)
// making sure that arrayPrinter takes precedence over tPrinter
// if both match requirements
object Foo extends FooLowPriorityImplicits {
implicit def arrayPrinter[T]: FooPrinter[Array[T]] =
_.map(v => s"Bar($v)").mkString(", ")
}
trait FooLowPriorityImplicits {
implicit def tPrinter[T]: FooPrinter[T] = v => s"Bar($v)"
}
implicit class Helper[T](private val foo: Foo[T]) extends AnyVal {
// requiring type class and summoning it using summon method
def print(implicit fp: FooPrinter[T]): Unit = FooPrinter[T].print(foo)
}
val foo0 = new Foo(123)
val foo1 = new Foo(Array(123, 456))
foo0.print
foo1.print
这种方式Helper不必选择一个隐式并“硬编码”它，因为它将作为参数传递给 at：
new Helper(foo0).print(tPrinter)
new Helper(foo1).print(arrayPrinter)
尽管对我们来说很方便，但它将由编译器完成。在您的示例中，外部Helper和内部之间没有发生这种通信，因此无论那里解决了什么，都适用于传递的所有内容。
- Everyone agrees. Which is why in Scala 3 `implicit` still works but is deprecated in favor of separate constructs for type classes (`given`, `using` keywords), extension methods (`extension` keyword) and conversions (extends `scala.Conversion`).