A rust implementation of a simple exercise

robot_paths.rs

fn main() {
    println!("{:?}", robot_paths(6));
}

#[derive(Clone)]
struct Board {
    squares: Vec<Vec<bool>>,
}

impl Board {
    fn new(n: usize) -> Board {
        Board {
            squares: vec![vec![false; n]; n],
        }
    }

    fn toggle_piece(&mut self, i: usize, j: usize) {
        self.squares[i][j] = !self.squares[i][j];
    }

    fn has_been_visited(&mut self, i: usize, j: usize) -> bool {
        self.squares[i][j]
    }
}

fn robot_paths(n: usize) -> usize {
    fn robot_paths(n: usize, board: &mut Board, i: usize, j: usize) -> usize {
        if i == n - 1 && j == n - 1 {
            return 1;
        }
        board.toggle_piece(i, j);
        let mut result = 0;
        for x in [(0, 1), (1, 0), (-1, 0), (0, -1)].iter() {
            let i = i as isize + x.0;
            let j = j as isize + x.1;
            if i >= 0
                && j >= 0
                && i < n as isize
                && j < n as isize
                && !board.has_been_visited(i as usize, j as usize)
            {
                result += robot_paths(n, board, i as usize, j as usize);
            }
        }
        board.toggle_piece(i, j);
        result
    }
    robot_paths(n, &mut Board::new(n), 0, 0)
}

#[cfg(test)]
mod test {
    use super::*;
    #[test]
    fn it_works() {
        assert_eq!(8512, robot_paths(5))
    }
}

@BartMassey

In general, don't unless you need it: it will ensure that you don't put expensive clones in without thinking about it.

I'm really not sure about this. The API guidelines recommend the opposite.