Apply some functions on a struct owning those functions - iterator

Question

I want to apply some functions on a struct owning those functions.
First try:
struct VM {
buffer: Vec<fn(&mut VM)>,
stack: Vec<isize>,
}
impl VM {
fn new() -> VM {
VM {
buffer: vec![VM::op_zero, VM::op_drop],
stack: vec![],
}
}
fn op_zero(&mut self) { self.stack.push(0); }
fn op_drop(&mut self) {
match self.stack.pop() {
Some(i) => println!("drop {}", i),
None => println!("stack underflow!")
}
}
fn evaluate(&mut self) {
for op in self.buffer {
op(self);
}
}
}
fn main() {
let mut vm = VM::new();
vm.evaluate();
}
This doesn't work because of moving out of borrowed content. I added an & before self.buffer, but it still doesn't work because self.buffer is also borrowed as immutable.
fn evaluate(&mut self) {
for op in &self.buffer {
op(self);
}
}
Third try works, but has the overhead of runtime bounds checking on array indexing:
fn evaluate(&mut self) {
let len = self.buffer.len();
for i in 0..len {
let op = self.buffer[i];
op(self);
}
}
Is there a better way to work around the borrow checker?

Answer 1

You shouldn't really be trying to "work around the borrow checker". It's preventing you from doing this because there's no guarantee that the ops you invoke won't mess with the buffer you're trying to iterate over. In fact, your final code has the same problem: an op could truncate the buffer, leading to a panic when you try to read past the end of the vector.
One way to do it safely would be to swap out the buffer when you evaluate it. Assuming you don't intend to evaluate the same sequence of instructions more than once:
fn evaluate(&mut self) {
use std::mem;
for op in mem::replace(&mut self.buffer, vec![]) {
op(self);
}
}
In this case, the new buffer can be modified by the invoked ops without interfering with evaluate.