Remove Vec product second mutable borrow occurs here - rust

Question

I have a list (sprites: Vec<RefCell<Sprite>>) in a structure
I have to add objects and remove them, no problem to add, but impossible to remove
add objects
pub fn _clean() {}
fn create_sprite(&mut self, x: f32, y: f32) {
let src_rect = Rect::new(0, 0, 9, 9);
let mut sprite = Sprite::new(0, x, y, src_rect);
self.sprites.push(RefCell::new(sprite));
println!("{}", self.sprites.len());
}
Delete objects
let mut pos: usize = 0;
for sprite in &mut self.sprites {
sprite.borrow_mut().x += 1.0;
// collision sprite shoot
if sprite.borrow_mut().x > (self.map.nbr_column as u32 * self.map.tile_wight) as f32 {
println!("shoot out {}", pos);
self.sprites.remove(pos);
//self.remove_sprite(pos);
}
pos += 1;
}
ditto if i do a pop instead of remove
I cleaned the code to produce an executable minumun code
use std::cell::RefCell;
pub struct Sprite {
pub index: usize,
pub x: f32,
pub y: f32,
pub vx: f32,
pub vy: f32,
}
impl Sprite {
pub fn new(index: usize, x: f32, y: f32) -> Sprite {
let mut sprite: Sprite = Sprite {
index: index,
x: x,
y: y,
vx: 0.0,
vy: 0.0,
};
sprite
}
}
pub struct Game {
sprites: Vec<RefCell<Sprite>>,
map: f32,
}
impl Game {
pub fn new() -> Game {
Game {
sprites: vec![],
map: 30.0,
}
}
pub fn update(&mut self) {
let mut pos: usize = 0;
self.sprites.retain(|s| {
// s is &RefCell<Sprite>
s.borrow_mut().x += 1.0;
s.borrow().x <= self.map
});
println!("{}", self.sprites.len());
}
fn create_sprite(&mut self, x: f32, y: f32) {
let mut sprite = Sprite::new(0, x, y);
self.sprites.push(RefCell::new(sprite));
println!("{}", self.sprites.len());
}
pub fn handle_event(&mut self) {
self.create_sprite(10.0, 10.0);
self.create_sprite(20.0, 10.0);
self.create_sprite(30.0, 10.0);
self.create_sprite(40.0, 10.0);
self.create_sprite(50.0, 10.0);
self.create_sprite(60.0, 10.0);
}
}
fn main() {
let mut the_game = Game::new();
the_game.handle_event();
the_game.update();
}

Answer 1

The line for sprite in &mut self.sprites creates a mutable borrow of the self.sprites collection that spans the entire loop body. This means that you cannot modify the collection itself inside the loop body, because doing so will cause the loop to become invalid.
When you attempt to call self.sprites.remove(pos), this call would cause all sprites after pos to move forward by one in memory. This is forbidden because you currently have a reference to the sprite that is about to be removed, and also because the sprite at pos + 1 would be skipped (the remove call moves it forward by one, but the iterator is going to move to the slot after it).
Rust provides a way to perform what your loop body is trying to do: the Vec::retain method.
self.sprites.retain(|s| { // s is &RefCell<Sprite>
s.borrow_mut().x += 1.0;
sprite.borrow_mut().x <= (self.map.nbr_column as u32 * self.map.tile_wight) as f32
});
This goes through each sprite in the list, updating it, and then returning a condition which, when true, tells the Vec to keep the sprite, and when false, tells the Vec to remove it.

Answer 2

Thank for you help, this code works
...
let map_width = (self.map.nbr_column as u32 * self.map.tile_wight) as f32;
self.sprites.retain(|s| {
// s is &RefCell<Sprite>
s.borrow_mut().x += 1.0;
s.borrow().x <= map_width
});
...