在 Scala 中检查涉及存在的类型的相等性

Question

我在写表单的函数

def test[A,B](a: A, b: B)(implicit eq: A =:= B): Unit = ...

我需要证明A 和B 类型相同的证据。

我希望test(a,a) 形式的调用可以编译为任何a，但当a 的类型涉及存在时，情况似乎并非如此，例如

case class Foo[T](c: T)
val l = List(Foo(1), Foo(1.0F), Foo(0.0)) // Inferred type: List[Foo[_ >: Double with Float with Int <: AnyVal]]

test(l.head, l.head) // Does not compile, error like: Cannot prove that Foo[_7] =:= Foo[_7].

所以我的问题是：我是否误用了=:=？或者它可能是一个错误？还是存在主义的基本限制？还是它们的实施有限制？

上下文

我正在测试涉及依赖类型的函数f 的返回类型。 我希望它在val a = f(...); val b = f(...) 中为a 和b 返回相同的类型，因此我调用test(a, b)。如果a 和b 的类型涉及existentials，即使test(a,a) 和test(b,b) 也不会编译，如上所述。

Answer 1

隐式 =:= 适用于存在类型

scala> implicitly[Foo[_ <: Int] =:= Foo[_ <: Int]]
res0: =:=[Foo[_ <: Int],Foo[_ <: Int]] = <function1>

scala> implicitly[Foo[_ <: Int] =:= Foo[_]]
<console>:10: error: Cannot prove that Foo[_ <: Int] =:= Foo[_].
              implicitly[Foo[_ <: Int] =:= Foo[_]]
                        ^

问题是 scala 在解析函数调用的隐式时会丢失存在类型 - 此处未推断出 A 和 B（这就是您看到 _7 表示且未找到隐式的原因）。

def test[A,B](a: A, b: B)(implicit eq: A =:= B)

可以用类型别名来解决：

scala> case class Foo[A](a: A) {type X = A}
defined class Foo

scala> val l = List(Foo(1), Foo(1.0F), Foo(0.0)) // Inferred type: List[Foo[_ >: Double with Float with Int <: AnyVal]]
l: List[Foo[_ >: Double with Float with Int <: AnyVal]] = List(Foo(1), Foo(1.0), Foo(0.0)) 

scala> val k = l.head
k: Foo[_ >: Double with Float with Int <: AnyVal] = Foo(1)

scala> implicitly[k.X =:= k.X]
res15: =:=[_ >: Double with Float with Int <: AnyVal, _ >: Double with Float with Int <: AnyVal] = <function1>

scala> implicitly[k.X =:= _ >: Double with Float with Int <: AnyVal]
res16: =:=[_ >: Double with Float with Int <: AnyVal, _ >: Double with Float with Int <: AnyVal] = <function1> 

但请记住，即使具有相似签名但来自不同 Foo 的类型也会有所不同（因为它是依赖于路径的类型） - 存在类型是如此存在！