在scala中，如何使抽象类型的内部类型对不同的实例不变？

Question

在某些情况下，我想使用内部类型作为泛型类型的替代，例如在下面的例子中，我不是定义Dependent[T <: BaseType]，而是像这样定义它：

abstract class BaseType {

  type N
  def create(v: Int): N

  class Dependent(val n: N) {

    def +(other: Dependent) = new Dependent(create(n.hashCode() + n.hashCode()))
  }
}

object BaseType {

  class Aggregator[T <: BaseType](val seq: Seq[T#Dependent]) {

    def result() = seq.reduce(_ + _)
  }
}

显然这不会编译，因为Dependent现在是一个Inner类，并且在不同BaseType实例下创建的不同Dependent彼此不可互操作。 （BTW将抛出以下编译错误）

Error:(15, 35) type mismatch;
 found   : T#Inner
 required: _33.Inner where val _33: T
    def result() = seq.reduce(_ + _)

但是这个问题应该在scala中有一个简单的解决方案，因为在java中这样的任务可以通过以下方式轻松完成：

static class Dependent { ...

在scala中使用比java更长的代码是没有意义的。 scala中的一个直接类比是在BaseType中添加强制规则，这要求其所有实现都是object / singleton而不是class。但是我还没有看到这样的功能。

所以问题是，最简单的方法是做一些可以在java中轻松完成的事情吗？

更新显然我不太清楚我的意图，我想要的不是使用类Dependent，而是扩展BaseType使得BaseType用作Dependent的类型参数，例如如果我定义2个对象：

  object Sub1 extends BaseType {
    override type N = Long
    override def create(v: Int): N = v.toLong
  }
  object Sub2 extends BaseType {
    override type N = Double
    override def create(v: Int): N = v.toDouble
  }

然后只有来自同一个对象的+符号和Aggregator才可以在2 Dependent上使用，这意味着这将成功：

  assert(
    new Aggregator(
      Seq(
        new Sub1.Dependent(1),
        new Sub1.Dependent(2)
      )).result() == new Sub1.Dependent(1) +
      new Sub1.Dependent(2)
  )

但这会失败：

  assert(
    new Aggregator(
      Seq(
        new Sub1.Dependent(1),
        new Sub2.Dependent(2)
      )).result() == new Sub1.Dependent(1) +
      new Sub2.Dependent(2)
  )

因为2个从属实例具有不同的类型，但是对于最新的scala编译器，即使第一个实例也会失败，因为在定义聚合器时它不知道T <: BaseType是单例。

Answer 1

因为在java这样的任务可以通过以下方式轻松完成：

static class Dependent { ...

不，它没有完成任务，因为这个Dependent不能使用N（即使它是BaseType的类型参数）。你需要static class Dependent<N>，Scala等价物

object BaseType {
  class Dependent[N]
}

如果您还没有配套对象，那么这比Java稍微长一点，但Scala设计中并不要求它可以用更短的代码（或者根本就是真的）执行Java所能做的任何事情。

如果你想

然后只有来自同一个对象的+ Sign和Aggregator才能在2 Dependent上使用，这意味着这将成功

这可以做到：

class Aggregator[T <: BaseType with Singleton](val seq: Seq[T#Dependent]) {
  def result() = seq.reduce(_ + _)
}

Answer 2

我不确定这是你想要的，可能你过度简化了你的真实问题。 但是，如果没有，这不会解决你的问题吗？

sealed trait BaseType[N] {
  def create(v: Int): N
}

object BaseType {
  final implicit val LongBase: BaseType[Long] = new BaseType[Long] {
    override def create(v: Int): Long = v.toLong
  }

  final implicit val DoubleBase: BaseType[Double] = new BaseType[Double] {
    override def create(v: Int): Double = v.toDouble
  }

  final class Aggregator[N : BaseType](val seq: Seq[Depedent[N]]) {
    def result: Depedent[N] = seq.reduce(_ + _)
  }
}

final class Depedent[N](val n: N)(implicit base: BaseType[N]) {
  def + (that: Depedent[N]): Depedent[N] =
    new Depedent(base.create(this.n.hashCode + that.n.hashCode))
}

如果这不能解决您的问题，请发表评论澄清其原因。