Scala：隐式参数分辨率优先

trait CanFoo[A] {
  def foos(x: A): String
}

object Def {
  implicit object ImportIntFoo extends CanFoo[Int] {
    def foos(x: Int) = "ImportIntFoo:" + x.toString
  }
}

object Main {
  def test(): String = {
    implicit object LocalIntFoo extends CanFoo[Int] {
      def foos(x: Int) = "LocalIntFoo:" + x.toString
    }
    import Def._

    foo(1)
  }

  def foo[A:CanFoo](x: A): String = implicitly[CanFoo[A]].foos(x)
}

在上面的代码中,LocalIntFoo胜过ImportedIntFoo.
有人可以使用“静态重载分辨率规则(§6.26.3)”来解释它是如何被更具体化的？

编辑：

名称绑定优先级是一个引人注目的论据,但有几个问题尚未解决.
首先,Scala语言参考指出：

If there are several eligible arguments which match the implicit parameter’s type,a most specific one will be chosen using the rules of static overloading resolution (§6.26.3).

第二,名称绑定优先级是关于将一??个已知的标识符x解析为特定成员pkg.A.B.x,以防在范围中有几个名为x的变量/方法/对象. ImportIntFoo和LocalIntFoo没有命名相同.

第三,我可以看出,这个名字绑定的优先级并不如下：

trait CanFoo[A] {
  def foos(x: A): String
}

object Def {
  implicit object ImportIntFoo extends CanFoo[Int] {
    def foos(x: Int) = "ImportIntFoo:" + x.toString
  }
}

object Main {
  def test(): String = {
    implicit object LocalAnyFoo extends CanFoo[Any] {
      def foos(x: Any) = "LocalAnyFoo:" + x.toString
    }

    // implicit object LocalIntFoo extends CanFoo[Int] {
    //   def foos(x: Int) = "LocalIntFoo:" + x.toString
    // }
    import Def._

    foo(1)
  }

  def foo[A:CanFoo](x: A): String = implicitly[CanFoo[A]].foos(x)
}

println(Main.test)

将其放在test.scala中并运行scala test.scala,并打印出ImportIntFoo：1.
这是因为静态重载分辨率(§6.26.3)表示更具体的类型获胜.
如果我们假装所有符合条件的隐含值都是相同的,那么LocalAnyFoo应该已经被掩码了ImportIntFoo.

有关：

> Where does Scala look for implicits?

这是隐式参数解析的一个很好的总结,但它引用了Josh的nescala演示文稿而不是规范.他的演讲是促使我研究的.

编译器实现

> rankImplicits