1

当转换发生在隐式类声明中时，编译器无法选择正确的隐式转换方法。在下面的示例中，我有一个Foo[T]类和一个隐式Helper类，它接受Foo并提供一个print方法。该 print 方法调用show，它本身就是一个隐式转换提供的方法 on Foo。

问题是提供了两种可能的转换show：一种转换Foo[T]为 a Bar[T]，另一种转换Foo[Array[T]]为 a BarArray[T]。这个想法是，当我们有一个Foo包含数组的 a 时，我们希望应用更具体的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
4

1 回答 1

5

隐式解析在编译时“分派”，因此它只能访问特定位置的编译器可用的（类型）信息。

这里

  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和内部之间没有发生这种通信，因此无论在那里解决什么都将应用于传递的所有内容。

于 2021-01-10T03:01:08.523 回答