Question

假设我们有一个抽象类，其中包含一个抽象类型字段：

abstract class A {type T}

现在让我们假设，我们有一个方法，它返回A类型的对象，但类型字段T可能不同。我们如何区分这些对象？

我们可以尝试模式匹配：

object Test {
  def tryToDistinguish(a: A) = 
    a match {
      case b: A {type T = String} => println("String type")
      case b: A {type T = Int} => println("Int type")
      case b: A => println("Other type")
  }
}

但编译器会抱怨：

$>scalac -unchecked Test.scala
Test.scala:8: warning: refinement example.test.A{type T = String} in type patter
n example.test.A{type T = String} is unchecked since it is eliminated by erasure

      case b: A {type T = String} => println("String type")
          ^
Test.scala:9: warning: refinement example.test.A{type T = Int} in type pattern e
xample.test.A{type T = Int} is unchecked since it is eliminated by erasure
          case b: A {type T = Int} => println("Int type")
              ^
two warnings found

看起来类型字段的类型将被删除删除（方问题：因为类型字段被转换为Java中的参数类型？）

因此，这不起作用：

scala> Test.tryToDistinguish(new A {type T = Int})
String type

替代方法：我们可以替代创建枚举并在类A中添加其他字段以区分对象。但这有点味道，因为这意味着我们重新实现了类型系统。

问题：在类型字段的帮助下，有没有办法区分对象的类型？如果没有，那将是一个好的解决方法？

Answer 1

您可以使用<%<在编译时告诉您两种类型是否兼容。

scala> class A { type T }
defined class A

scala> implicitly[A { type T=String } <%< A { type T=Int } ]
<console>:9: error: could not find implicit value for parameter e: <%<[A{type T = String},A{type T = Int}]
              implicitly[A { type T=String } <%< A { type T=Int } ]
                        ^

scala> implicitly[A { type T=String } <%< A { type T=String } ]
res1: <%<[A{type T = String},A{type T = String}] = <function1>

scala> implicitly[A { type T=String } <%< A ]
res3: <%<[A{type T = String},A] = <function1>

Answer 2

正如您所猜测的，抽象类型成员是在类型擦除期间将被擦除的编译时信息。这是一个使用implicit参数的解决方法。发送是静态的。

scala> class A {
     |   type T
     | }
defined class A

scala> implicit def distString(a: A { type T = String }) = "String"
distString: (a: A{type T = String})java.lang.String

scala> implicit def distInt(a: A { type T = Int }) = "Int"
distInt: (a: A{type T = Int})java.lang.String

scala> implicit def distOther[O](a: A { type T = O }) = "Other"
distOther: [O](a: A{type T = O})java.lang.String

scala> def distinguish(a: A)(implicit ev: A { type T = a.T } => String) = ev(a)
distinguish: (a: A)(implicit ev: A{type T = a.T} => String)String

scala> distinguish(new A { type T = String })
res2: String = String

scala> distinguish(new A { type T = Int })
res3: String = Int

scala> distinguish(new A { type T = Float })
res4: String = Other

另一种方式：

scala> def dist(a: A)(implicit s: a.T =:= String = null, i: a.T =:= Int = null) =
     |   if (s != null) "String" else if (i != null) "Int" else "Other"
dist: (a: A)(implicit s: =:=[a.T,String], implicit i: =:=[a.T,Int])String

scala> dist(new A { type T = String })
res5: String = String

scala> dist(new A { type T = Int })
res6: String = Int

scala> dist(new A { type T = Float })
res7: String = Other

修改

如果上述解决方案不能满足您的要求，并且您希望在运行时对这种类型信息进行验证和反省，那么您也可以使用名为Manifest的东西来实现这一点。

scala> :paste // Entering paste mode (ctrl-D to finish) abstract class A { type T def man: Manifest[T] } object A { def apply[X](implicit m: Manifest[X]) = new A { type T = X; def man = m } } // Exiting paste mode, now interpreting. defined class A defined module A scala> def disti(a: A): String = a match { | case _ if a.man <:< manifest[String] => "String" | case _ if a.man <:< manifest[Int] => "Int" | case _ => "Other" | } disti: (a: A)String scala> disti(A.apply[String]) res14: String = String scala> disti(A.apply[Int]) res15: String = Int scala> disti(A.apply[Float]) res16: String = Other

Answer 3

附带问题：因为类型字段已转换为参数类型在Java？

字节码中没有类型参数，因此无法将类型字段转换为字段代码。类型字段仅在编译期间存在。

替代方案：我们可以替代创建一个枚举并放置一个 A类中的附加字段以区分对象。但这有点味道，因为它意味着我们重新实现了这种类型系统

在运行时只能提出一种类型问题：这是什么类？ Scala 2.10提供了更多信息，但它仍然归结为这个问题。

如果您实际上是A的子类，则可以通过反射获取该信息（在2.10上）。否则，我不这么认为 - 我已经在REPL上进行了测试，并且它不起作用，但编译到类文件的内容有更多关于它们的信息。

必须对价值观做任何其他问题。

问题：有没有办法区分对象的类型在类型字段的帮助下？如果没有，那将是一件好事解决方法？

不，除非Scala 2.10，反射和子类。好的解决方法？使用值。但是，处理它的常用方法不是枚举，而是Manifest，它可以隐式生成。

查找questions about how to get around type erasure in Scala。

如何区分具有不同抽象类型字段的对象？

3 个答案: