Is this Sudoku board valid so far?

def is_valid_sudoku(board):
    rows = [set() for _ in range(9)]
    cols = [set() for _ in range(9)]
    boxes = [set() for _ in range(9)]
    for r in range(9):
        for c in range(9):
            d = board[r][c]
            if d == '.':
                continue
            b = 3 * (r // 3) + c // 3       # which of the nine boxes
            if d in rows[r] or d in cols[c] or d in boxes[b]:
                return False
            rows[r].add(d)
            cols[c].add(d)
            boxes[b].add(d)
    return True

#include <string>
#include <vector>
using namespace std;

bool solve(const vector<string>& board) {
    int rows[9] = {0}, cols[9] = {0}, boxes[9] = {0};   // bit d set when digit d has been seen
    for (int r = 0; r < 9; r++)
        for (int c = 0; c < 9; c++) {
            if (board[r][c] == '.') continue;
            int bit = 1 << (board[r][c] - '0');
            int b = 3 * (r / 3) + c / 3;                // which of the nine boxes
            if ((rows[r] | cols[c] | boxes[b]) & bit) return false;
            rows[r] |= bit; cols[c] |= bit; boxes[b] |= bit;
        }
    return true;
}

class Solution {
    public boolean isValidSudoku(String[] board) {
        int[] rows = new int[9], cols = new int[9], boxes = new int[9];   // bit d set when digit d has been seen
        for (int r = 0; r < 9; r++)
            for (int c = 0; c < 9; c++) {
                char ch = board[r].charAt(c);
                if (ch == '.') continue;
                int bit = 1 << (ch - '0');
                int b = 3 * (r / 3) + c / 3;                // which of the nine boxes
                if (((rows[r] | cols[c] | boxes[b]) & bit) != 0) return false;
                rows[r] |= bit; cols[c] |= bit; boxes[b] |= bit;
            }
        return true;
    }
}

function isValidSudoku(board) {
  const rows = Array.from({ length: 9 }, () => new Set());
  const cols = Array.from({ length: 9 }, () => new Set());
  const boxes = Array.from({ length: 9 }, () => new Set());
  for (let r = 0; r < 9; r++) {
    for (let c = 0; c < 9; c++) {
      const d = board[r][c];
      if (d === '.') continue;
      const b = 3 * Math.floor(r / 3) + Math.floor(c / 3); // which of the nine boxes
      if (rows[r].has(d) || cols[c].has(d) || boxes[b].has(d)) return false;
      rows[r].add(d); cols[c].add(d); boxes[b].add(d);
    }
  }
  return true;
}

fn solve(board: &[&str]) -> bool {
    let (mut rows, mut cols, mut boxes) = ([0u16; 9], [0u16; 9], [0u16; 9]); // bit d set when digit d has been seen
    for (r, line) in board.iter().enumerate() {
        for (c, ch) in line.bytes().enumerate() {
            if ch == b'.' {
                continue;
            }
            let bit = 1u16 << (ch - b'0');
            let b = 3 * (r / 3) + c / 3; // which of the nine boxes
            if (rows[r] | cols[c] | boxes[b]) & bit != 0 {
                return false;
            }
            rows[r] |= bit;
            cols[c] |= bit;
            boxes[b] |= bit;
        }
    }
    true
}

import Data.List (nub)

-- Every row, column and box, as the list of its filled digits, must have no repeats.
solve :: [String] -> Bool
solve board = all noRepeat (rows ++ cols ++ boxes)
  where
    cell r c = board !! r !! c
    rows = [[cell r c | c <- [0 .. 8]] | r <- [0 .. 8]]
    cols = [[cell r c | r <- [0 .. 8]] | c <- [0 .. 8]]
    boxes = [[cell r c | r <- [3 * br .. 3 * br + 2], c <- [3 * bc .. 3 * bc + 2]] | br <- [0 .. 2], bc <- [0 .. 2]]
    noRepeat xs = let ds = filter (/= '.') xs in length ds == length (nub ds)