Allocating struct objects on heap inside loop in rust - rust

Question

I need to allocate structs with a drop trait inside a for loop and have a mutable reference for downstream processing. I have created this minimal example code that I can't compile with rust version 1.59. I have tried using the internal mutability with Rc and RefCell as well.
use std::cell::RefCell;
use std::rc::Rc;
// MyVec with Drop Trait
struct MyVec {
vec: Vec<i32>,
}
impl Drop for MyVec {
fn drop(&mut self) {
println!("Dropping MyVec with data `{:?}`!", self.vec);
}
}
impl MyVec {
// Get a mutable slice
fn mut_slice(&mut self) -> &mut [i32]{
return &mut self.vec[..]
}
}
pub fn test() {
// Needed for downstream purposes
let mut all_slices = Vec::new();
// Storing reference counter Rc and RefCell combo
// Hoping to prevent allocated MyVec objects from dropping and have one mutable reference
let mut all_refs = Vec::new();
for _i in 0..1 {
let my_vec = Rc::new(RefCell::new(MyVec {
vec: vec![1, 2, 3]
}));
// Make a clone of my_vec to prevent it from dropping
all_refs.push(Rc::clone(&my_vec));
let mut my_vec_mut = my_vec.borrow_mut();
let x = my_vec_mut.mut_slice();
all_slices.push(x);
}
println!("{:?}", all_slices);
}
The same code works when I unroll the loop and write the following code:
pub fn test() {
// Needed for downstream purposes
let mut all_slices = Vec::new();
// Storing reference counter Rc and RefCell combo
// Hoping to prevent allocated MyVec objects from dropping and have one mutable reference
let mut all_refs = Vec::new();
let my_vec = Rc::new(RefCell::new(MyVec {
vec: vec![1, 2, 3]
}));
// Make a clone of my_vec to prevent it from dropping
all_refs.push(Rc::clone(&my_vec));
let mut my_vec_mut = my_vec.borrow_mut();
let x = my_vec_mut.mut_slice();
all_slices.push(x);
println!("{:?}", all_slices);
}
Update: Thanks to Masklinn's comments, I fixed the code. I needed to create objects in the loop and required a mutable reference to its internal data field outside the scope of the loop. The rust compiler showed an error that the references outlive the object itself. Finally, I used a separate loop to allocate the objects and a second loop with iter_mut to create mutable references. Here is the final code:
pub fn test() {
// Needed for downstream purposes
let mut all_slices = Vec::new();
// Hoping to prevent allocated MyVec objects from dropping and have one mutable reference
let mut all_vecs = Vec::new();
for _i in 0..1 {
all_vecs.push(MyVec {
vec: vec![1, 2, 3]
});
}
for my_vec in all_vecs.iter_mut() {
all_slices.push(my_vec.mut_slice());
}
println!("{:?}", all_slices);
}