这种命令式编码风格的等效 Scala 代码是什么？

Question

Find below the imperative style code:

private boolean placePieceOnBoard(Results results, 
                                  ChessLayout chessLayout,
                                  List<ChessPiece> piecesToPlace, 
                                  int pieceIndex, 
                                  int startOffset) {
    if(pieceIndex == piecesToPlace.size()) {
        results.addLayout(chessLayout);
        return true;
    }
    else {
        ChessPiece chessPiece = piecesToPlace.get(pieceIndex);
        int offset = startOffset;
        while(offset < chessLayout.getBoardLength()) {

            int placedOffset = chessLayout.placePieceInNextAvailablePosition(chessPiece, offset);
            if( placedOffset == ChessLayout.NULL_OFFSET ) 
                break;
            else {
                logger.debug("piece {} ({}) moved", pieceIndex, chessPiece);

                placePieceOnBoard(results, chessLayout.clone(), piecesToPlace, pieceIndex + 1, placedOffset + 1);

                chessLayout.removeChessPiece(chessPiece);
                offset = placedOffset + 1;
            }
        }
        return false;
    }
}

Here I am interested in knowing how to convert changes made to offset within the loop in a functional way, how to do early break from the loop etc.

Answer 1

This is a nice demonstration of one of Scala's great strengths - gradual, easy migration from imperative Java code to functional code.

To convert to Scala, you don't need to go 100% functional straight away. You can easily convert what you have to Scala as follows:

def placePieceOnBoard(results: Results, 
                      chessLayout: ChessLayout,
                      piecesToPlace: List[ChessPiece], 
                      pieceIndex: Int, 
                      startOffset: Int) {
    if (pieceIndex == piecesToPlace.size()) {
        results.addLayout(chessLayout)
        true
    }
    else {
        val chessPiece = piecesToPlace.get(pieceIndex)
        var offset = startOffset
        while(offset < chessLayout.getBoardLength) {

            val placedOffset = chessLayout.placePieceInNextAvailablePosition(chessPiece, offset)
            if( placedOffset == ChessLayout.NULL_OFFSET ) 
                break
            else {
                logger.debug("piece {} ({}) moved", pieceIndex, chessPiece)

                placePieceOnBoard(results, chessLayout.clone(), piecesToPlace, pieceIndex + 1, placedOffset + 1)

                chessLayout.removeChessPiece(chessPiece)
                offset = placedOffset + 1
            }
        }
        false
    }
}

Note we already have some small improvements in verbosity: no more ; s, no redundant type signatures, mutable variables converted to constants where possible, eliminated return statements and function brackets. Note I changed the argument type of piecesToPlace to a scala list, you'll need to use the scala-java converters at the call site to make this compile.

Next, we can start making this more functional... however, this function probably isn't the place you should start, as you are calling state-mutating functions in several places. For example, you could start with ChessLayout:

chessLayout.removeChessPiece(chessPiece)

val placedOffset = chessLayout.placePieceInNextAvailablePosition(chessPiece, offset)

These methods mutate ChessLayout, which is not functional style. You could modify removeChessPiece to return a new ChessLayout with the piece removed, and placePieceInNextAvailablePosition could return a tuple of (ChessLayout, Int) . Once you have stopped any functions called from placePieceOnBoard from mutating state, you can then convert it to functional style.