在隐含的上下文中，“比更具体”到底是什么意思？

Question

因此，隐式优先级基于两个因素：一个是关于声明本身具有优先级的范围（范围 A 扩展范围/特征 B，或范围 A 是从具有范围 B 的类型扩展的类型的伴生对象它的伴生对象）。另一个简单地提到 declaration A 比 declaration B 更具体。现在，当我第一次阅读它时，我想到了几种可能的解释，特别是考虑到隐式方法和类型参数的潜在参数（隐式和非隐式）。经验似乎告诉我，这意味着声明 A 的返回值的类型，毕竟类型推断/tapply，是声明 B 的返回类型的子类型。所以，这很好：

  class A
  class B extends A
  implicit val A = new A
  implicit val B = new B
  implicitly[A]

那为什么不编译呢？

    implicit class A(val toInt :Int) {
        def ! = (1 /: (2 to toInt))(_ * _)
    }
    implicit class B(i :Int) extends A(i)
    1.!

什么时候做？

    class A(val toInt :Int) {
        def ! = (1 /: (2 to toInt))(_ * _)
    }
    class B(i :Int) extends A(i)

    implicit val A = { i :Int => new A(i) }
    implicit val B = { i :Int => new B(i) }
    1.!

这是“编译器以神秘方式工作”的另一种情况吗？

Answer 1

基于SIP-13 - IMPLICIT CLASSES 提议您的声明：

implicit class A(val toInt :Int) {
    def ! = (1 /: (2 to toInt))(_ * _)
}

将被转换为：

class A(toInt: Int) {
 ...
}
implicit final def A(toInt: Int): A = new A(toInt);

而您的B 又将转换为：

class B(i: Int) extends A(i) {
 ...
}
implicit final def B(i: Int): B = new B(i);

因此，您基本上是在声明 2 个具有相同参数但不明确的隐式转换方法。虽然由于已经提到隐式参数解析的“最具体”规则，最后一个并不模棱两可。