In Rust can you have an immutable vector of mutable vectors?

Question

Probably not the right question but trying to learn rust and wondering if there's a way to do this without having to copy out first.

old example

Updated example link

I have a Vec<Vec> where the inner vectors are used as stacks. I want to pop N from vector and push to another but in reverse order

let mut stacks: Vec<Vec<i32>>;
....
let end = stacks[from].iter().take(count);
stacks[to].extend(end);  // <-- fails to compile

Now I understand why this can't happen - end uses an immutable borrow and extend needs a mutable one. I know that the 2 stacks are independent but obviously you couldn't take and push to the same stack. So instead I have to "collect" the 2 off the end (e.g. with split_off but that means creating a new Vec and wondering if there's a way to avoid that?

(This is a simplified example to show the compile error. The original is when I was trying to solve Advent of Code 2022 in Rust , Q5b - The push and pops happen in a loop and can be from and to any one of N stacks, but never to and from the same one.

Edited question to reflect this. Link to full code )

Answer 1

You can use split_at_mut to make Rust understand that you are reading and writing two different slots of the vector:

fn main() {
    
    let mut stacks = vec![vec![]; 2];
    stacks[0].push(1);
    stacks[0].push(2);
    stacks[1].push(3);
    stacks[1].push(4);
    
    let n = stacks[0].pop().unwrap();
    stacks[1].push(n);
    
    println!("{:?}", stacks);
    let (left, right) = stacks.split_at_mut(1);
    let end = right[0].iter().take(2);
    left[0].extend(end);
    
    println!("{:?}", stacks);
}

It takes an index, and returns two non overlapping slices, that correspond to the original slice cut at that index.

See the playground.

Alternatively, for more complex use cases, you can use the temporary shared mutation pattern explained in this article. In this specific case, though, the other approach is simpler.

use std::cell::Cell;

fn main() {
    
    let mut stacks = vec![vec![]; 2];
    stacks[0].push(1);
    stacks[0].push(2);
    stacks[1].push(3);
    stacks[1].push(4);
    
    let n = stacks[0].pop().unwrap();
    stacks[1].push(n);
    
    println!("{:?}", stacks);
    let slice = Cell::from_mut(&mut stacks[..]).as_slice_of_cells();
    let second = slice[1].take();
    let end = second.iter().take(2);
    let mut first = slice[0].take();
    first.extend(end);
    slice[0].set(first);
    slice[1].set(second);
    
    println!("{:?}", stacks);
}

See the playground.