构造函数与方法签名中的隐式参数

Question

编译器在BroFinder1 和BroFinder2 中看到导致第一个失败的哪些差异？我真的需要 BroFinder1 在不使用 Aux Pattern 等模式的情况下正常工作。

trait Brother[I] {
  type Bro
  def get: Bro
}

class Foo
object Foo {
  implicit object bro extends Brother[Foo] {
    override type Bro = Bar

    override def get = new Bar
  }
}

class Bar {
  def barSpecificAction(): Unit = ()
}

class BroFinder1[I](implicit val b: Brother[I]) {
  def brotherOf: b.Bro = b.get
}

class BroFinder2[I] {
  def brotherOf(implicit b: Brother[I]): b.Bro = b.get
}


new BroFinder1[Foo].brotherOf.barSpecificAction() // Doesn't compile
//error: Error:(73, 32) value barSpecificAction is not a member of _1.b.Bro
//new BroFinder1[Foo].brotherOf.barSpecificAction();
                          ^
new BroFinder2[Foo].brotherOf.barSpecificAction() // Ok

//scala version: 2.12.4

Answer 1

这不是一个完美的答案，但可能会提供一些见解。这个问题似乎与implicit 完全无关。它似乎与另一个相当先进的 Scala 特性有关：路径依赖类型。特别是问题似乎来自Scala类型系统不够强大，无法在以下代码中精确表达finder1和finder2之间的类型差异：

object Foo {

  implicit object bro extends Brother[Foo] {
    override type Bro = Bar

    override def get = new Bar
  }

  object bro2 extends Brother[Foo] {
    override type Bro = Foo

    override def get = new Foo
  }

}


val finder1 = new BroFinder1[Foo]
val finder2 = new BroFinder1[Foo]()(Foo.bro2)
val bof1 = finder1.brotherOf
val bof2 = finder2.brotherOf

旁注：某些参数是 implicit 的事实并不能使它成为“常数”，因为无论如何您始终可以显式传递参数，或者您可以不同上下文中不同的可见隐含值。

AFAIU 最精确的类型finder1 或finder2 在此示例中可能被分配只是BroFinder1[Foo]。特别是无法捕获 b 隐式变量的不同值，因此无法进一步准确地传递编码在该值内的路径相关类型的值。因此，最好的编译器知道bof1 和bof2 的类型是它们都具有_1.b.Bro 形式的类型，其中_1 表示BroFinder1[Foo] 的某些特定实例。所以编译器不能确定bof1实际上是Bar类型，而bof2是Foo类型。

第二个例子有效，因为隐式参数是在相同的上下文中捕获的，所以编译器确切地知道brotherOf 的结果类型是什么。

我知道的唯一解决方法并不完全适合您的情况：使用“Aux”类型。如果您的 BroFinder 还采用了 Foo 类型的显式参数，则解决方案可能如下所示：

type BrotherAux[I, B] = Brother[I] {type Bro = B}

class BroFinder3[I, B](val v: I)(implicit val b: BrotherAux[I, B]) {
  def brotherOf: B = b.get
}

new BroFinder3(new Foo).brotherOf.barSpecificAction()

但在你的情况下，它的帮助必须小得多

class BroFinder1[I, B](implicit val b: BrotherAux[I, B]) {
  def brotherOf: B = b.get
}

new BroFinder1[Foo, Bar].brotherOf.barSpecificAction()

Answer 2

因为new BroFinder2[Foo].brotherOf 属于Bar 类型，而Bar 有方法barSpecificAction 但new BroFinder1[Foo].brotherOf 属于存在类型

x.Bro forSome { val x: Brother[Foo] }

它没有方法barSpecificAction。