模棱两可的隐含值

Question

直到最近遇到奇怪的问题，我一直认为我理解 scala 的隐含。

在我的应用程序中，我有几个域类

case class Foo(baz: String)
case class Bar(baz: String)

以及一个能够从字符串构造域对象的类。它可以被子类化以进行真正的反序列化，这并不重要。

class Reads[A] {
  def read(s: String): A = throw new Exception("not implemented")
}

接下来是隐式反序列化器

implicit val fooReads = new Reads[Foo]
implicit val barReads = new Reads[Bar]

以及将字符串转换为域类之一的助手

def convert[A](s: String)(implicit reads: Reads[A]): A = reads.read(s)

不幸的是，在尝试使用它时

def f(s: String): Foo = convert(s)

我得到类似的编译器错误

error: ambiguous implicit values:
 both value fooReads of type => Reads[Foo]
 and value barReads of type => Reads[Bar]
 match expected type Reads[A]
       def f(s: String): Foo = convert(s)
                                      ^

对我来说，代码似乎简单而正确。 Reads[Foo]和Reads[Bar]是完全不同的类型，有什么歧义？

真正的代码要复杂得多，使用play.api.libs.json，但这个简化版足以重现错误。

Answer 1

您在示例中遇到的模棱两可之处在于您没有告诉 Scalac 您想使用哪一个。您需要将代码替换为

def f(s: String): Foo = convert[Foo](s)

为了让它找出使用哪一个。它无法从f 的返回类型推断。这里需要明确。

对评论的回应

让我在这里扮演魔鬼的拥护者。

trait Foo
case class Bar(s: String) extends Foo
case class Baz(s: String) extends Foo

def f(s: String): Foo = convert(s)

假设Bar 和Baz 都定义了一个，它使用哪个隐式？我敢肯定那里还有更多可怕的角落案例，但是这个跳出来给我。

Answer 2

问题是您正在使泛型类型 A 不变。相反，这应该是协变的。所以这应该如下实现

case class Foo(baz: String)
case class Bar(baz: String)

// This `+` ↓ is the only difference  
class Reads[+A] {
  def read(s: String): A = throw new Exception("not implemented")
}

implicit val fooReads = new Reads[Foo]
implicit val barReads = new Reads[Bar]

def convert[A](s: String)(implicit reads: Reads[A]): A = reads.read(s)

def f(s: String): Foo = convert(s)

更多信息请参考http://docs.scala-lang.org/tutorials/tour/variances.html。