Hi everyone, I have a code with a mix of recursion...

# coroutines

[ar-g]

Hi everyone, I have a code with a mix of recursion and coroutines, I'm wondering how valid and idiomatic it is:
• each step when the board is changed I want to emit it with flow and show on UI
• when the coroutine is canceled partiallySolve function expected to stop working

typealias OnSudokuBoardChanged = suspend (board: List<List<Int>>) -> Unit

class SudokuSolver {

    fun solve(board: List<List<Int>>) = flow {
        partiallySolve(0, 0, board) {
            emit(it)
        }
    }

    private suspend fun partiallySolve(
        curI: Int,
        curJ: Int,
        board: MutableList<MutableList<Int>>,
        callback: OnSudokuBoardChanged
    ): Boolean {
        if (curI > board.lastIndex) {
            return true
        }

        val curNum = board[curI][curJ]

        val nextI = if (curJ == board.lastIndex) curI + 1 else curI
        val nextJ = if (curJ == board.lastIndex) 0 else curJ + 1

        if (curNum != 0) {
            return partiallySolve(nextI, nextJ, board, callback)
        }

        if (curNum == 0) {
            for (guess in 1..9) {
                if (validate(guess, curI, curJ, board)) {

                    board[curI][curJ] = guess

                    callback.invoke(board)

                    if (partiallySolve(nextI, nextJ, board, callback)) {
                        return true
                    }
                }
            }
        }

        board[curI][curJ] = 0

        return false
    }

[zak.taccardi]

with code this big, should attach as a code snippet

[uli]

Could not read it either. But where does partiallySolve suspend?