游戏循环的功能替代品

Question

我刚开始使用 Scala 并正在尝试一个小玩具程序 - 在本例中是基于文本的井字游戏。我根据我对 scala 的了解编写了一个工作版本，但注意到它主要是命令式的，而且我的类是可变的。

我正在尝试实现一些功能性惯用语，并设法至少使代表游戏状态的类不可变。但是，我剩下一个类负责执行依赖于可变状态和命令式循环的游戏循环，如下所示：

  var board: TicTacToeBoard = new TicTacToeBoard

  def start() {
    var gameState: GameState = new XMovesNext
    outputState(gameState)
    while (!gameState.isGameFinished) {
      val position: Int = getSelectionFromUser
      board = board.updated(position, gameState.nextTurn)
      gameState = getGameState(board)
      outputState(gameState)      
    }
  }

在这个循环中对我正在做的事情进行编程的更惯用的方法是什么？

完整的源代码在这里https://github.com/whaley/TicTacToe-in-Scala/tree/master/src/main/scala/com/jasonwhaley/tictactoe

Answer 1

恕我直言，对于 Scala，命令式循环很好。你总是可以编写一个递归函数来表现得像一个循环。我还加入了一些模式匹配。

def start() {
    def loop(board: TicTacToeBoard) = board.state match {
        case Finished => Unit
        case Unfinished(gameState) => {
             gameState.output()
             val position: Int = getSelectionFromUser()
             loop(board.updated(position))
        }
    }

    loop(new TicTacToeBoard)
}

假设我们有一个函数whileSome : (a -> Option[a]) a -> ()，它运行输入函数直到它的结果为None。这会去掉一些样板。

def start() {
    def step(board: TicTacToeBoard) = {
        board.gameState.output()
        val position: Int = getSelectionFromUser()
        board.updated(position) // returns either Some(nextBoard) or None
    }

    whileSome(step, new TicTacToeBoard)
}

whileSome 写起来应该很简单；它只是前一种模式的抽象。我不确定它是否在任何常见的 Scala 库中，但在 Haskell 中，您可以从 monad-loops 获取 whileJust_。

Answer 2

您可以将其实现为递归方法。这是一个不相关的例子：

object Guesser extends App {
  val MIN = 1
  val MAX = 100

  readLine("Think of a number between 1 and 100. Press enter when ready")

  def guess(max: Int, min: Int) {
    val cur = (max + min) / 2
    readLine("Is the number "+cur+"? (y/n) ") match {
      case "y" => println("I thought so")
      case "n" => {
        def smallerGreater() { 
          readLine("Is it smaller or greater? (s/g) ") match {
            case "s" => guess(cur - 1, min)
            case "g" => guess(max, cur + 1)
            case _   => smallerGreater()
          }
        }
        smallerGreater()
      }
      case _   => {
        println("Huh?")
        guess(max, min)
      } 
    }
  }

  guess(MAX, MIN)
}

Answer 3

比如：

Stream.continually(processMove).takeWhile(!_.isGameFinished)

其中processMove 是一个从用户那里获取选择、更新板并返回新状态的函数。

Answer 4

我会选择递归版本，但这是Stream 版本的正确实现：

var board: TicTacToeBoard = new TicTacToeBoard

def start() {
  def initialBoard: TicTacToeBoard = new TicTacToeBoard
  def initialGameState: GameState = new XMovesNext
  def gameIterator = Stream.iterate(initialBoard -> initialGameState) _
  def game: Stream[GameState] = {
    val (moves, end) = gameIterator {
      case (board, gameState) =>
        val position: Int = getSelectionFromUser
        val updatedBoard = board.updated(position, gameState.nextTurn)
        (updatedBoard, getGameState(board))
    }.span { case (_, gameState) => !gameState.isGameFinished }
    (moves ::: end.take(1)) map { case (_, gameState) => gameState }
  }
  game foreach outputState
}

这看起来比它应该的更奇怪。理想情况下，我会使用takeWhile，然后使用map，但它不会起作用，因为 last 的情况会被忽略！

如果游戏的移动可以被丢弃，那么dropWhile 后跟head 就可以了。如果我有副作用（outputState）而不是Stream，我可以走那条路，但是在Stream 中产生副作用比带有while 循环的var 更糟糕。

所以，我改为使用span，它给了我takeWhile 和dropWhile，但迫使我保存中间结果——如果内存是一个问题，这可能真的很糟糕，因为整个游戏将是保存在内存中，因为moves 指向Stream 的头部。所以我不得不将所有这些封装在另一个方法中，game。这样，当我foreach通过game的结果时，不会有任何指向Stream的head的东西。

另一种选择是摆脱您拥有的其他副作用：getSelectionFromUser。您可以使用 Iteratee 摆脱它，然后您可以保存最后一步并重新应用它。

或者...您可以为自己编写一个 takeTo 方法并使用它。