Question

关于存在主义类型的一点混乱。

这对我有用：

def valueOf(c: Class[_], name: String) {
  type C = Class[T] forSome {type T <: Enum[T]}
  Enum.valueOf(c.asInstanceOf[C], name)
}

但这不是：

def valueOf(c: Class[_], name: String) {
  type T = T forSome {type T <: Enum[T]}
  Enum.valueOf(c.asInstanceOf[Class[T]], name)
}

在我看来，这两个表达式都等同于：

Enum.valueOf(z.asInstanceOf[Class[T] forSome {type T <: Enum[T]}], name)

但Scala说这只是我的想法：

inferred type arguments [T] do not conform to method valueOf's type parameter bounds [T <: Enum[T]]
         Enum.valueOf(c.asInstanceOf[Class[T]], name)
              ^

Answer 1

考虑以下两个表达式之间的区别：

Enum.valueOf(x.asInstanceOf[Class[X] forSome { type X <: Enum[X] }], name)

和

Enum.valueOf(x.asInstanceOf[Class[X forSome { type X <: Enum[X] }]], name)

现在考虑如何在每种情况下推断T的类型参数valueOf。在第一种情况下，我们得到的X我们知道的是Enum[X]的子类型，我们已全部设置完毕。另一方面，在第二种情况下，T必须是X forSome { type X <: Enum[X] }，而且至关重要的是此类型不是Enum[X forSome { type X <: Enum[X] }]的子类型，因此我们无法满足约束在T。

问题是你的第二个例子等同于后者。

作为一个脚注，如果Enum在其类型参数中是协变的，那么这将工作得很好。采用以下简化示例：

trait Foo[A]
trait Bar[A]

def foo[A <: Bar[A]](f: Foo[A]) = f

def x: Foo[X] forSome { type X <: Bar[X] } = ???
def y: Foo[Y forSome { type Y <: Bar[Y] }] = ???

现在foo(x)会编译，但foo(y)会赢，就像你的代码一样。但是稍微改变Bar：

trait Foo[A]
trait Bar[+A]

def foo[A <: Bar[A]](f: Foo[A]) = f

def x: Foo[X] forSome { type X <: Bar[X] } = ???
def y: Foo[Y forSome { type Y <: Bar[Y] }] = ???

现在他们都要编译。我猜这与我们对你的两个例子具有相同的强烈直觉的原因有关。

作为另一个脚注（回复gzmo＆＃39; comment below），请考虑以下事项：

scala> trait Foo[A <: Foo[A]]
defined trait Foo

scala> class MyFoo extends Foo[MyFoo]
defined class MyFoo

scala> val myFoo = new MyFoo
myFoo: MyFoo = MyFoo@3ee536d

scala> myFoo: (X forSome { type X <: Foo[X] })
res0: X forSome { type X <: Foo[X] } = MyFoo@3ee536d

scala> myFoo: Foo[MyFoo]
res1: Foo[MyFoo] = MyFoo@3ee536d

我们假设X forSome { type X <: Foo[X] } 是Foo[X forSome { type X <: Foo[X] }]的子类型（暂时忽略了后者甚至不是有效类型的事实）。然后我们就可以写下以下内容：

myFoo: Foo[X forSome { type X <: Foo[X] }]

但是Foo是不变的，所以如果我们有一些事情是Foo[A]和Foo[B]的实例，那么A =:= B就是这种情况。 }。但绝对不是MyFoo =:= (X forSome { type X <: Foo[X] })的情况。不确定所有这些都不会让人感到困惑，但这让我确信编译器知道它在这里做了什么。

Scala中的存在类型

1 个答案: