Странная ошибка Scala

Question

Я пытался создать абстрактную пошаговую игру и абстрактный ИИ:

abstract class AGame {
  type Player
  type Move     // Player inside

  def actPlayer : Player
  def moves (player : Player) : Iterator[Move]
  def play (move : Move)
  def undo ()
  def isFinished : Boolean
  def result (player : Player) : Double
}

abstract class Ai[Game <: AGame] {
  def genMove (player : Game#Player) : Game#Move
}

class DummyGame extends AGame {
  type Player = Unit
  type Move = Unit

  def moves (player : Player) = new Iterator[Move] {
    def hasNext = false
    def next = throw new Exception ("asd")
  }

  def actPlayer = ()

  def play (move : Move) {
  }

  def undo () {
  }

  def isFinished = true

  def result (player : Player) = 0
}

class DummyAi[Game <: AGame] (game : Game) extends Ai[Game] {
  override def genMove (player : Game#Player) : Game#Move = {
    game.moves (player).next
  }
}

Я подумал, что должен использовать такие странные средства доступа, как Game # Player. Я получаю очень загадочную ошибку. Я хотел бы понять это:

[error] /home/lew/Devel/CGSearch/src/main/scala/Main.scala:41: type mismatch;
[error]  found   : Game#Player
[error]  required: DummyAi.this.game.Player
[error]     game.moves (player).next
[error]                 ^

Answer 1

def moves (player : Player) означает, что moves принимает игрока за , это Game.

Game#Player - это тип для игрока любой Game.Итак, moves (player) является несовпадением типов.

Вот простой пример, который показывает, почему должно быть несовпадением.Предположим, что это не так, и посмотрим, что будет дальше:

class Game2 extends DummyGame {
  override type Player = Boolean
  override type Move = Boolean

  override def moves(player : Boolean) = new Iterator[Boolean] {...}
}

val game2: DummyGame = new Game2
// game2.Player is Boolean

val dummyGameAi = new DummyAi[DummyGame](game2)
// DummyGame#Player == Unit, so the type of genMove for Ai[DummyGame] is
// def genMove (player : Unit) : Unit

dummyGameAi.genMove(())
// this calls game2.moves(()), which doesn't typecheck

Чтобы заставить это работать, мы можем изменить тип genMove.Если мы передадим игру в качестве аргумента (и в любом случае это имеет смысл), мы можем использовать зависимые от пути типы:

abstract class Ai[Game <: AGame] {
  def genMove (game : Game)(player : game.Player) : game.Move
  // now game.moves (player) typechecks
}

Answer 2

Вы можете решить вашу проблему, введя абстрактный член game в Ai и затем указав тип, зависящий от пути, используя этот член:

abstract class Ai[Game <: AGame] {
  val game : Game
  def genMove (player : game.Player) : game.Move
}

class DummyAi[Game <: AGame] (val game : Game) extends Ai[Game] {
  override def genMove (player : game.Player) : game.Move = {
    game.moves (player).next
  }
}