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))
    }
}

You're doing a LOT of cloning that seems unnecessary here. Let's fix that:

--- old.rs      2019-01-08 13:26:59.201134000 -0700
+++ new.rs      2019-01-08 13:26:44.644846000 -0700
@@ -34,8 +34,12 @@
     }
 }

-fn robot_paths(n: i32, board: Option<Board>, i: Option<i32>, j: Option<i32>) -> i32 {
-    let mut board = board.unwrap_or(Board::new(n));
+fn robot_paths(n: i32, board: Option<&mut Board>, i: Option<i32>, j: Option<i32>) -> i32 {
+    let board = match board {
+        None => return robot_paths(n, Some(&mut Board::new(n)), i, j),
+        Some(b) => b,
+    };
+
     let i = i.unwrap_or(0);
     let j = j.unwrap_or(0);
     if !(i >= 0 && i < n && j >= 0 && j < n) || board.has_been_visited(i, j) {
@@ -45,10 +49,10 @@
         return 1;
     }
     board.toggle_piece(i, j);
-    let result = robot_paths(n, Some(board.clone()), Some(i), Some(j + 1))
-        + robot_paths(n, Some(board.clone()), Some(i), Some(j - 1))
-        + robot_paths(n, Some(board.clone()), Some(i + 1), Some(j))
-        + robot_paths(n, Some(board.clone()), Some(i - 1), Some(j));
+    let result = robot_paths(n, Some(board), Some(i), Some(j + 1))
+        + robot_paths(n, Some(board), Some(i), Some(j - 1))
+        + robot_paths(n, Some(board), Some(i + 1), Some(j))
+        + robot_paths(n, Some(board), Some(i - 1), Some(j));
     // Return the board to its original state
     board.toggle_piece(i, j);
     result

i and j being Options seems completly unnecessary, I believe that could be slowing it down.

Some dumb little things:

• Board no longer needs to derive Clone. In general, don't unless you need it: it will ensure that you don't put expensive clones in without thinking about it.

• has_been_visited() can borrow self immutably.

• If you make the inner robot_paths function a method of Board it will clean up the code a bit.

@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.