在 Scala 中避免使用 asInstanceOf

Question

我现在有这样的东西：

object Shared {
  trait Foo {
    type T <: Foo
    def +(other: T): T
  }

  case class IntFoo(value: Int) extends Foo {
    type T = IntFoo
    def +(other: IntFoo): IntFoo = IntFoo(this.value + other.value)
  }
}

object Current extends App {
  import Shared._

  case class Bar(foo: Foo) {
    def +(other: Bar): Bar = Bar(foo + other.foo.asInstanceOf[foo.T])
  }

  val bar1 = Bar(IntFoo(2))
  val bar2 = Bar(IntFoo(3))
  val expected = Bar(IntFoo(5))
  require(bar1 + bar2 == expected)
  println("All OK")
}

这可行，但需要一个 unsafeasInstanceOf，我想在尽可能少地干扰代码的情况下消除它。

我希望编译器能够捕获无效代码，例如：

  val otherBar = Bar(StringFoo("asdf"))
  val invalidSum = bar1 + otherBar // this throws ClassCastException in runtime

我尝试了以下方法：

  case class Bar[FooT <: Foo](foo: FooT) {
    def +(other: Bar[FooT]): Bar[FooT] = {
      Bar(foo + other.foo)
    }
  }  

但我得到了

Error:(35, 27) type mismatch;
 found   : other.foo.type (with underlying type FooT)
 required: Bar.this.foo.T
      Bar(foo + other.foo)
                ^

建议？

Answer 1

方法Foo.+ 采用Foo 的内部类型T 的值。所以你必须在你的Bar.+ 中指定other 具有相同的内部类型T。您可以使用依赖类型：

case class Bar[FooT <: Foo](foo: FooT) {
  def +(other: Bar[foo.T]): Bar[foo.T] = {
    Bar(foo + other.foo)
  }
}

结果也将是 Bar[foo.T]，因为 foo.T 是 Foo.+ 根据定义返回的内容。

无论如何，这适用于 IntFoo 示例，但会产生 StringFoo 示例的编译错误。

Answer 2

这应该是正确的，假设您对输入的方式感到满意：

object Shared {
  trait Foo[T <: Foo[T]] {
    def +(other: T): T
  }

  case class IntFoo(value: Int) extends Foo[IntFoo] {
    def +(other: IntFoo): IntFoo = IntFoo(this.value + other.value)
  }
}

object Current extends App {
  import Shared._

  case class Bar[T <: Foo[T]](foo: T) {
    def +(other: Bar[T]): Bar[T] = Bar(foo + other.foo)  
  }

  val bar1 = Bar(IntFoo(2))
  val bar2 = Bar(IntFoo(3))
  val expected = Bar(IntFoo(5))
  require(bar1 + bar2 == expected)
  println("All OK")
}

Answer 3

case class Bar[+F <: Foo](foo: F) {
  def +(other: Bar { type T = foo.T }): Bar =
    Bar(foo + other.foo)
}