类型与抽象类型不匹配

Question

我正在使用抽象类型，但在让 Scala 编译器统一两种应该相同的类型时遇到问题。这些是我的定义：

trait Chromosome {
  type Gene

  val size : Int

  def apply(idx : Int) : Gene

  def update(idx : Int, g : Gene)

  def indices = Range(0, size-1)
}


trait Individual {
  type Fitness
  implicit protected val ord: Ordered[Fitness] = implicitly[Ordered[Fitness]]

  val chromosome : Chromosome

  def size : Int = chromosome.size

  def apply(idx : Int) : chromosome.Gene = chromosome.apply(idx)
  def update(idx : Int, g : chromosome.Gene ) = chromosome.update(idx, g)

  protected var _fitness : Fitness = _
  def fitness : Fitness = _fitness
  def fitness_=(f : Fitness):Unit = _fitness = f
}


case class ArrayChromosome(size : Int) extends Chromosome {
  implicit protected val tag : ClassTag[Gene] = implicitly[ClassTag[Gene]]

  protected val xs : Array[Gene] = new Array[Gene](size)

  def apply(idx : Int) = xs(idx)

  def update(idx : Int, g : Gene) = xs(idx) = g
}


abstract class ArrayIndividual(size : Int) extends Individual {
  val chromosome  = ArrayChromosome(size)
}


class MyIndividual(size : Int) extends ArrayIndividual(size) {
  type Gene = Int
  type Fitness = Double
}


object Test extends App {
  val i1 = new MyIndividual(10)

  i1.fitness = 10.5
  i1.chromosome(0) = 6
  print(i1)
}

即问题出在这一行：

i1.chromosome(0) = 6

类型错误是：

Error:(75, 22) type mismatch;
 found   : Int(6)
 required: abstractTypes.Test.i1.chromosome.Gene
  i1.chromosome(0) = 6

编译器似乎无法将i1.chromosome.Gene 与Int 统一起来。

我有两个问题：

1. 是否可以帮助编译器统一这两种类型？
2. 现在让我假设我已经删除了有问题的行并且我已经为Individuals 正确定义了toString。为什么我在运行Test 时会得到java.lang.NullPointerException。该错误似乎与GeneClassTag有关，但我不确定。

回复代码到@som-snytt：

abstract class ArrayIndividual(size : Int) extends Individual {
  type Gene
  implicit protected def tag2: ClassTag[Gene]

  val chromosome  = new ArrayChromosome(size) {
    type Gene = ArrayIndividual#Gene
    protected val tag : ClassTag[Gene] = tag2
  }
}

class MyIndividual(size : Int) extends ArrayIndividual(size) {
  type Fitness = Double
  type Gene = Int
  implicit protected val tag2 : ClassTag[Gene] = implicitly[ClassTag[Gene]]

  override def toString = s"${super.toString} $chromosome"
}

Answer 1

在 Scala 中，类型不是全局范围的。您已将Gene 编写为Chromosome 类型的成员，但您试图在Individual 的子类中定义它（“具有”Chromosome，而不是“是”Chromosome） .

您可以选择在哪里声明和定义它，但它必须在同一层次结构中，就像您覆盖诸如方法之类的术语成员时一样。

individual.Gene 与您的示例中的 chromosome.Gene 无关。

将类型定义移动到 ClassTag 所需的位置：

case class ArrayChromosome(size : Int) extends Chromosome {
  type Gene = Int
  implicit protected val tag : ClassTag[Gene] = implicitly[ClassTag[Gene]]

哦，我刚刚注意到您正在递归地定义您的隐式。 RHS 上的隐式使用您定义的隐式。所以不要那样做。编译器自己调用隐式。

但是，如果您确实需要在未修复别名类型的超类中提供隐式标记，则可以使用抽象方法来提供将在具体类中实现的类标记。

例如，让Individual 子类指定具体的Chromosome：

abstract class ArrayChromosome(val size : Int) extends Chromosome {
  //type Gene = Int
  //implicit protected val tag : ClassTag[Gene] = implicitly[ClassTag[Gene]]
  implicit protected def tag: ClassTag[Gene]

  protected lazy val xs : Array[Gene] = new Array[Gene](size)

  def apply(idx : Int) = xs(idx)

  def update(idx : Int, g : Gene) = xs(idx) = g
}


abstract class ArrayIndividual(size : Int) extends Individual {
  //val chromosome  = ArrayChromosome(size)
  val chromosome  = new ArrayChromosome(size) {
    type Gene = Int
    protected val tag = implicitly[ClassTag[Gene]]
  }
}


class MyIndividual(size : Int) extends ArrayIndividual(size) {
  type Fitness = Double

  override def toString = s"${super.toString} $chromosome"
}