Trying to modify a Vec of futures inside a Rc<RefCell<...>> - vector

Question

I try to wait and remove one-by-one future from a Vec of futures. It does not work. I understand why it does not work: Pin is not copyable. But how to correct this error?
extern crate futures;
use std::cell::{RefCell};
use std::rc::Rc;
use std::pin::Pin;
use std::future::Future;
use futures::channel::oneshot::Canceled;
use futures::executor::block_on;
use futures::future::select_all;
fn run_queries_body() {
let _futures: Vec<Pin<Box<dyn Future<Output=Result<(), Canceled>>>>> = Vec::new();
let futuresRc = Rc::new(RefCell::new(_futures)); // TODO: Cell instead
// This in actual could be called inside another future, so we need Rc<RefCell<...>>
let mut futures = futuresRc.borrow_mut();
let f3 = futures.iter().map(|x| *x);
let (_res, _idx, remaining_futures) = block_on(select_all(f3));
*futures = remaining_futures;
}
error[E0507]: cannot move out of `*x` which is behind a shared reference
--> src/lib.rs:16:37
|
16 | let f3 = futures.iter().map(|x| *x);
| ^^ move occurs because `*x` has type `std::pin::Pin<std::boxed::Box<dyn futures::Future<Output = std::result::Result<(), futures::channel::oneshot::Canceled>>>>`, which does not implement the `Copy` trait

Answer 1

The problem is not in the pin - a boxed future is safe to move along with its pin because box means the future is heap-allocated, so moving the box doesn't move the future. The pin serves to forbid moving the future out of its box, but you don't attempt that. Your code fails to compile because Vec::iter() iterates over references to elements, and you can't move an object out of a reference because it would leave the original value in an undefined state. This kind of move is only allowed for types that can be trivially copied such as numbers or bools, which is marked by the Copy trait. The compiler's message is confusing because it mentions Pin<...>, but it only does so because that's the literal type behind the reference, and the compiler reports that the type in question isn't Copy, without implying anything about Pin semantics.
A straightforward fix is to make futures a vector of options. That allows you to extract an element out of the vector just by possessing a mutable iterator to the element by calling Option::take on the &mut Option<T>. This is well-defined because it extracts the value, but also leaves None in the old place in the vector.
In your case you would iterate over the vector using iter_mut() (playground):
pub fn run_queries_body() {
let futures: Vec<Option<Pin<Box<dyn Future<Output = Result<(), Canceled>>>>>> = vec![];
let futures_rc = Rc::new(RefCell::new(futures));
let mut futures = futures_rc.borrow_mut();
let f3 = futures.iter_mut().map(|f| f.take().unwrap());
let (_res, _idx, remaining_futures) = block_on(select_all(f3));
*futures = remaining_futures.into_iter().map(Some).collect();
}
As pointed out by #Jmb, an even simpler approach is to use Vec::drain, which removes the elements from the vector and gives you an iterator over the removed elements (playground):
pub fn run_queries_body() {
let futures: Vec<Pin<Box<dyn Future<Output = Result<(), Canceled>>>>> = vec![];
let futures_rc = Rc::new(RefCell::new(futures));
let mut futures = futures_rc.borrow_mut();
let f3 = futures.drain(..);
let (_res, _idx, remaining_futures) = block_on(select_all(f3));
*futures = remaining_futures;
}