使用隐式绑定在泛型类上的上下文

Question

我正在学习 Scala 以便将其用于项目。

我想更深入了解的一件事是类型系统，因为它是我以前在其他项目中从未使用过的东西。

假设我设置了以下代码：

// priority implicits
sealed trait Stringifier[T] {
  def stringify(lst: List[T]): String
}

trait Int_Stringifier {
  implicit object IntStringifier extends  Stringifier[Int] {
    def stringify(lst: List[Int]): String = lst.toString()
  }
}

object Double_Stringifier extends Int_Stringifier {
  implicit object DoubleStringifier extends Stringifier[Double] {
    def stringify(lst: List[Double]): String = lst.toString()
  }
}

import Double_Stringifier._

object Example extends App {

  trait Animal[T0] {
    def incrementAge(): Animal[T0]
  }

  case class Food[T0: Stringifier]() {
    def getCalories  = 100
  }

  case class Dog[T0: Stringifier]
  (age: Int = 0, food: Food[T0] = Food()) extends Animal[String] {
    def incrementAge(): Dog[T0] = this.copy(age = age + 1)
  }
}

所以在示例中，存在类型错误：

ambiguous implicit values:
[error]  both object DoubleStringifier in object Double_Stringifier of type Double_Stringifier.DoubleStringifier.type
[error]  and value evidence$2 of type Stringifier[T0]
[error]  match expected type Stringifier[T0]
[error]   (age: Int = 0, food: Food[T0] = Food()) extends Animal[String] 

好吧，很公平。但是如果我删除上下文绑定，这段代码就会编译。 IE。如果我将 '''Dog''' 的代码更改为：

case class Dog[T0]
  (age: Int = 0, food: Food[T0] = Food()) extends Animal[String] {
    def incrementAge(): Dog[T0] = this.copy(age = age + 1)
  }

现在我假设这也不会编译，因为这种类型更通用，更模棱两可，但确实如此。

这里发生了什么？我知道当我将上下文绑定时，编译器不知道它是 double 还是 int。但是为什么还要编译一个更通用的类型呢？当然，如果没有上下文绑定，我可能有一个 Dog[String] 等，这也会混淆编译器。

来自answer：“上下文绑定描述了一个隐式值，而不是视图绑定的隐式转换。它用于声明对于某些类型 A，有一个 B[A] 类型的隐式值可用”

Answer 1

现在我假设这也不会编译，因为这种类型更通用，更模棱两可，但确实如此。

歧义在隐含之间。两者都有

Double_Stringifier.DoubleStringifier

和Dog[T0: Stringifier] 的匿名证据（因为class Dog[T0: Stringifier](...) 与class Dog[T0](...)(implicit ev: Stringifier[T0]) 脱糖）是候选人。

（Int_Stringifier#IntStringifier 无关紧要，因为它的优先级较低）。

现在您删除了上下文绑定，Food() 中只剩下一个隐式参数候选者，因此没有歧义。我看不出更通用的类型是如何相关的。更通用并不意味着更模糊。要么你在隐含之间有歧义。

---

实际上，如果您删除导入但保持上下文绑定，则默认值中看不到匿名证据。所以它会考虑歧义，但不会计算孤独:)

Scala 2.13.2、2.13.3。

Answer 2

在我看来（如果我错了，我希望@DmytroMitin 能纠正我），理解这一点的关键是为food 参数提供的默认值，这使得class Dog 两者都是定义站点，要求一个隐式在调用站点可用，以及一个调用站点，要求一个隐式必须在编译时范围内。

代码中前面的import 提供了Food() 调用站点所需的隐式函数，但Dog 构造函数需要从其调用站点放置在ev 中的隐式函数。因此模棱两可。