奇怪的斯卡拉错误答案

【问题标题】：Strange Scala error奇怪的斯卡拉错误
【发布时间】：2010-06-14 17:08:04
【问题描述】：

我尝试创建抽象的回合制游戏和抽象的 AI：

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]                 ^

【问题讨论】：

应该是game.moves(player).next 还是game.moves(player.next)？ Scala 的语法是模棱两可的，允许两种解释，但解析器需要选择一个。
从错误消息中可以清楚地看出它被解析为第一个。

标签： scala types

【解决方案1】：

def moves (player : Player) 表示moves 接受玩家this Game。

Game#Player 是 any 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
}

【讨论】：

我明白了，但我仍然不明白我应该如何解决这个问题。任何想法
您是否使用了-Xexperimental 选项？ lampsvn.epfl.ch/trac/scala/ticket/128

【解决方案2】：

您可以通过在Ai 中引入抽象成员game 来解决您的问题，然后使用该成员指定路径相关类型：

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
  }
}

【讨论】：