类型别名函数类型的隐式转换类无法在 Scala 中编译

Question

在 scala 中，以下代码可以正确编译：

class a {}
class b {}

object Main {

  implicit class Conv[f, t](val v: f ⇒ t) extends AnyVal {
    def conv = v
  }

  def main(args: Array[String]) {
    val m = (a: a) ⇒ new b
    m.conv
  }
}

但由于某种原因，以下编译失败：

class a {}
class b {}

object Main {
  type V[f, t] = f ⇒ t

  implicit class Conv[f, t](val v: V[f, t]) extends AnyVal {
    def conv = v
  }

  def main(args: Array[String]) {
    val m = (a: a) ⇒ new b
    m.conv
  }
}

带有以下信息：

value conv is not a member of a => b
    m.conv

为什么会这样？

编辑：是的，即使使用

仍然有错误

  val m: V[a,b] = new V[a,b] { def apply(a: a) = new b }

Answer 1

在您的第一个示例中，val v: f => t 被推断为类型签名[-A, +B]，因为它是一个参数的函数的简写。 Function1 具有类型签名 Function1[-A, +B]。所以，在A 参数中是逆变的，在B 参数中是协变的。

然后代码后面的 lambda 函数 (a: a) => new b 将其类型推断为从 a 到 b 的函数。因此，类型签名是相同的，并且隐式解析有效。

在您的第二个示例中，键入 V[f, t] = f => t 和从中创建的参数：val v: V[f, t]，将它们的类型明确指定为 V[f, t]。函数f => t 仍将是[-A, +B]，但您明确限制您的类型在类型签名中保持不变，因此类型V 在两个类型参数中都是不变的。

稍后，当您声明：val m = (a: a) => new b 时， this 的类型签名仍然是 [-A, +B]，如第一个示例所示。隐式解析不起作用，因为 val 在其第一个类型参数中是逆变的，但类型 V 在其第一个类型参数中是不变的。

将 V 的类型签名更改为 V[-f, +t] 或 V[-f, t] 可解决此问题，并且隐式解析再次起作用。

这确实提出了一个问题，即为什么第二类型参数的协方差对于隐式解析来说不是问题，而第一类型参数的逆变是。我到处玩，做了一些研究。我遇到了一些有趣的链接，这表明隐式解析肯定存在一些限制/问题，特别是在逆变方面。

• A Scala Ticket related to Contravariance and implicit resolution.
• A long discussion on google groups related to the ticket
• Some workaround code for Contravariance and implicit resolutions in some scenarios.

我必须向了解 Scala 编译器内部结构和解析机制的人咨询更多细节，但这似乎违反了逆变上下文中隐式解析的一些限制。

对于您的第三个示例，我认为您的意思是：

class a {}
class b {}

object Main {
  type V[f, t] = f => t

  implicit class Conv[f, t](val v: V[f, t]) extends AnyVal {
    def conv = v
  }

  def main(args: Array[String]) {
    val m: V[a,b] = new V[a,b] { def apply(a: a) = new b }
    m.conv // does not compile
  }
}

这是一个有趣的问题，我认为这是一个稍微不同的原因。类型别名在变化时可以更改的内容受到限制，但允许更严格的变化。我不能确定这里发生了什么，但这里有一个interesting Stack Overflow question related to type aliases and variance。

考虑到隐式解析的复杂性，再加上类型声明差异与隐含 Function1 差异的额外因素，我怀疑编译器无法解决该特定场景中的任何问题。

改为：

implicit class Conv(val v: V[_, _]) extends AnyVal {
  def conv = v
}

意味着它适用于所有场景，因为您基本上是在对编译器说，出于 Conv 隐式类的目的，您不需要关心 V 上类型参数的变化。

例如：以下也有效

class a {}
class b {}

object Main {
  type V[f, t] = f ⇒ t

  implicit class Conv(val v: V[_, _]) extends AnyVal {
    def conv = v
  }

  def main(args: Array[String]) {
    val m = (a: a) ⇒ new b
    m.conv
  }
}