scala - 意外的 "recursive value needs type"编译错误(由本地隐式触发)

Question

我刚刚遇到了一个意外的编译错误“递归值 xx 需要类型”。为了简化，我想出了以下不能用 Scala 2.12.3 编译的代码:

class Wrapped[A](val inner: A)(implicit val ctag: ClassTag[A]){
  type Inner = A
  def classInfo: String = ctag.toString
}
object Implicits {
  val W = new Wrapped(1234)
  implicit val InnerSeq: Seq[W.Inner] = Seq(1,2)
  implicit val InnerSet: Set[W.Inner] = Set(1,2) // Error: recursive value W needs type
}

我假设 W 的类型定义明确。但似乎由于 W 类型出现在局部隐式值的返回类型中，即使在 的创建中未使用隐式，W 也被视为递归>W.

奇怪的是，删除第二个值 InnerSet 会使代码编译通过。因此，一个引用 W.Inner 的隐式 val 是可以的，而两个或更多是不行的。

移除 Wrapper 的隐式 ClassTag 依赖项也会使代码编译。

通过将 W 移动到一个单独的特征很容易解决这个问题，但最好知道这里发生了什么。为什么代码编译时只有一个隐式作用域？

更新:

在 Dotty 的最新预览版中，编译器的行为更加一致，并且根本不允许在范围内引用 W.inner 的任何隐式:

[error] -- [E045] Syntax Error: 
[error] 9 |  implicit val InnerSeq: Seq[W.Inner] = Seq(1,2)
[error]   |                             ^
[error]   |                             cyclic reference involving value W
[error] one error found

Answer 1

发生这种情况是由于您定义的局部隐式的范围、类型推断的工作方式以及隐式解析的工作方式。如果我们查看 typer 阶段的输出(使用 Ytyper-debug )，我们会看到:

|-- new Wrapped(1234) EXPRmode (site: value W  in Implicits)
|    |-- new Wrapped BYVALmode-EXPRmode-FUNmode-POLYmode (silent: value W  in Implicits)
|    |    |-- new Wrapped EXPRmode-POLYmode-QUALmode (silent: value W  in Implicits)
|    |    |    |-- Wrapped FUNmode-TYPEmode (silent: value W  in Implicits)
|    |    |    |    \-> Wrapped
|    |    |    \-> Wrapped[A]
|    |    \-> (inner: A)(implicit ctag: scala.reflect.ClassTag[A])Wrapped[A]
|    |-- 1234 BYVALmode-EXPRmode-POLYmode (site: value W  in Implicits)
|    |    \-> Int(1234)
|    solving for (A: ?A)
|    [search #1] start `(inner: A)(implicit ctag: scala.reflect.ClassTag[A])Wrapped[A]`, searching for adaptation to pt=scala.reflect.ClassTag[Int] (silent: value W  in Implicits) implicits disabled
|    |-- Seq[W.Inner] TYPEmode (site: value InnerSeq  in Implicits)
|    |    |-- scala.`package` EXPRmode-POLYmode-QUALmode (site: value InnerSeq  in Implicits)
|    |    |    \-> scala.type
|    |    |-- W.Inner TYPEmode (site: value InnerSeq  in Implicits)
|    |    |    |-- W EXPRmode-POLYmode-QUALmode (site: value InnerSeq  in Implicits)
|    |    |    |    |-- new Wrapped(1234) EXPRmode (site: value W  in Implicits)
|    |    |    |    |    |-- new Wrapped BYVALmode-EXPRmode-FUNmode-POLYmode (silent: value W  in Implicits)
|    |    |    |    |    |    |-- new Wrapped EXPRmode-POLYmode-QUALmode (silent: value W  in Implicits)
|    |    |    |    |    |    |    \-> Wrapped[A]
|    |    |    |    |    |    \-> (inner: A)(implicit ctag: scala.reflect.ClassTag[A])Wrapped[A]
|    |    |    |    |    solving for (A: ?A)
|    |    |    |    |    [search #2] start `(inner: A)(implicit ctag: scala.reflect.ClassTag[A])Wrapped[A]`, searching for adaptation to pt=scala.reflect.ClassTag[Int] (silent: value W
isabled
|    |    |    |    |    |-- Set[W.Inner] TYPEmode (site: value InnerSet  in Implicits)
|    |    |    |    |    |    |-- W.Inner TYPEmode (site: value InnerSet  in Implicits)
|    |    |    |    |    |    |    |-- W EXPRmode-POLYmode-QUALmode (site: value InnerSet  in Implicits)
|    |    |    |    |    |    |    |    caught scala.reflect.internal.Symbols$CyclicReference: illegal cyclic reference involving value W: while typing W

typer 首先必须弄清楚 A 的类型参数的 Wrapper , 由于我们没有提供显式类型，编译器将其视为 Wrapper[A] .编译器发现您需要隐式 ClassTag[A]在范围内创建 Wrapper 的实例，所以隐式解析开始了。Scala 编译器将从局部作用域的隐式开始，即 InnerSeq。和 InnerSet ，正如您定义的那样。继续隐式搜索，编译器查看 InnerSeq并尝试查看它是否适合 A 类型的分辨率它对应的是ClassTag[A] ，但是 InnerSeq根据 W.Inner 定义，因此编译器必须查看 W并查看它的基础类型，当前定义为 Wrapper[A]正如我们一开始所看到的。由于隐式解析是递归的，它现在开始查找隐式范围，这可以帮助它推断 Wrapper[A] , 下一个隐式定义是 InnerSet ，但它也是根据`W.Inner!因此我们有一个循环引用并且编译器退出。

现在，当我们为 W 定义显式类型时:

val W: Wrapped[Int] = new Wrapped(1234)

类型检查器知道 W.type是Wrapped[Int]而不是 Wrapped[A] ，因此它不需要做任何递归隐式解析。我们可以在调试输出中再次看到这一点:

|-- Seq[W.Inner] TYPEmode (site: value InnerSeq  in Implicits)                                 
|    |-- scala.`package` EXPRmode-POLYmode-QUALmode (site: value InnerSeq  in Implicits)       
|    |    \-> scala.type                                                                       
|    |-- W.Inner TYPEmode (site: value InnerSeq  in Implicits)                                 
|    |    |-- W EXPRmode-POLYmode-QUALmode (site: value InnerSeq  in Implicits)                
|    |    |    \-> com.testing.SOTesting.Implicits.W.type (with underlying type Wrapped[Int])  <---- This is the difference
|    |    [adapt] A is now a TypeTree(com.testing.SOTesting.Implicits.W.Inner)                 
|    |    \-> com.testing.SOTesting.Implicits.W.Inner                                          
|    \-> Seq[com.testing.SOTesting.Implicits.W.Inner]      

因为我们现在知道底层 W.type ，打字机可以绑定(bind) W.Inner至 Int , 从而找到 A 的匹配项.