从Scala中的类型检查中删除路径依赖

德比尔斯基

假设我们有这些嵌套的类和的实例化A：

class A {
  case object B
  case class C(c: Int)
}
val a1 = new A()

现在，我可以检查到这a1.B是的实例，a1.B.type但是由于编译器将不接受该语法，因此如何检查到它的类型是否a1.B是any 的实例A#B.type。

a1.B.isInstanceOf[a1.B.type]
res: Boolean = true

a1.B.isInstanceOf[A#B.type]
<console>:1: error: ']' expected but '.' found.
a1.B.isInstanceOf[A#B.type]
                     ^

对于案例类，它似乎可以正常工作：

a1.C(0).isInstanceOf[a1.C]
res: Boolean = true

a1.C(0).isInstanceOf[A#C]
res: Boolean = true

后续问题：当我有

val a1 = new A()
val a2 = new A()

有没有不考虑路径依赖而进行相等性检查的功能？例如。true比较a1.B和时，它应该返回a2.B。例如：

a1.B =#= a2.B
true

a1.C(0) =#= a2.C(0)
true

a1.C(0) =#= a2.C(1)
false

编辑：为澄清起见：仅介绍一个共同的特征B是不够的，因为我想打赌能够区分案例对象：

class A {
    trait BB
    case object B1 extends BB
    case object B2 extends BB
}
val a1 = new A
val a2 = new A

a1.B1 =#= a2.B1 // should be true
a1.B2 =#= a2.B2 // should be true
a1.B1 =#= a1.B2 // should be false
a1.B1 =#= a2.B2 // should be false

现在，.hashCode（或.##）方法似乎可以解决问题：

a1.B1.## == a2.B1.## // true
a1.B1.## == a2.B2.## // false

但是也许有一个更优雅的解决方案（例如，我也希望能够a1.B1在模式匹配中使用）。

桲

只需使用完整形式来表达存在类型。

这是你的例子：

class A {
  case object B1
  case object B2
  case class C(c: Int)
}
val a1 = new A()

我添加了另一个case对象来演示可以区分它们，因此我没有为它写一个晦涩的等价物。 AnyRef

type AB1 = a.B1.type forSome {val a : A}
type AB2 = a.B2.type forSome {val a : A}

scala> a1.B1.isInstanceOf[AB1]
res0: Boolean = true

scala> a1.B1.isInstanceOf[AB2]
res1: Boolean = false

我已经介绍了类型别名AB1，并AB2提供方便。但是，isInstanceOf如果需要，可以内联该类型。

本文收集自互联网，转载请注明来源。

如有侵权，请联系 [email protected] 删除。