Get mutable reference to an item in trait objects collection - rust

Question

To play around with Rust, I'm trying to get the following code working (playground, please don't mind the commented blocks, they are for further investigations).
Basically I would like to store in a collection several items of several types implementing a common trait. I can't use an enum because I want the user to implement the trait for more types, so I use trait objects.
I want, after its insertion in the collection, to get a mutable reference to the item, so that the user can use it independently from the fact that it's stored in a collection.
The following code gives me two errors that I have no idea how to solve.
use std::any::Any;
// Trait needed to represent an Animal, with as_any() method to support downcasting
trait Animal {
fn as_any(&self) -> &dyn Any;
fn feed(&mut self);
fn is_fed(&self) -> bool;
}
// Realization of Animal for a dog
struct Dog {
is_fed: bool
}
impl Animal for Dog {
fn as_any(&self) -> &dyn Any {
self
}
fn feed(&mut self) {
self.is_fed = true;
}
fn is_fed(&self) -> bool {
self.is_fed
}
}
// Realization of Animal for a cat
struct Cat {
is_fed: bool
}
impl Animal for Cat {
fn as_any(&self) -> &dyn Any {
self
}
fn feed(&mut self) {
self.is_fed = true;
}
fn is_fed(&self) -> bool {
self.is_fed
}
}
// Struct to host a list of trait objects implementing the trait Animal
struct Zoo {
animals: Vec<Box<dyn Animal>>
}
impl Zoo {
fn new() -> Zoo {
Zoo{animals: Vec::new()}
}
// Method to append a new animal to the zoo and get a mutable reference to the newly created object
fn host<'a, A: Animal>(&mut self, a: A) -> &mut A {
self.animals.push(Box::new(a));
let pushed_box = self.animals.last_mut().expect("error");
pushed_box.as_any().downcast_mut::<A>().expect("error") // error: cannot borrow data in a `&` reference as mutable
}
}
fn main()
{
let mut zoo = Zoo::new();
zoo.host(Dog{is_fed:false});
let cat = zoo.host(Cat{is_fed:false});
zoo.host(Cat{is_fed:false});
zoo.host(Dog{is_fed:false});
zoo.host(Cat{is_fed:false});
let dog = zoo.host(Dog{is_fed:false});
zoo.host(Cat{is_fed:false}); // error : cannot borrow `zoo` as mutable more than once at a time
dog.feed();
}

Answer 1

You can use Rc<RefCell<dyn Animal>> for the collection.
struct Zoo {
animals: Vec<std::rc::Rc<RefCell<dyn Animal>>>,
}
impl Zoo {
fn new() -> Zoo {
Zoo{animals: Vec::new()}
}
fn host<A: Animal + 'static>(&mut self, a: A) -> std::rc::Rc<RefCell<dyn Animal>> {
self.animals.push(std::rc::Rc::new(RefCell::new(a)));
let pushed_box = self.animals.last_mut().expect("error");
pushed_box.clone()
}
}
and use borrow_mut() to get mutable reference to an animal. Or try_borrow_mut() to make sure that the code won't panic if another borrow exists for the same animal.
fn main()
{
let mut zoo = Zoo::new();
zoo.host(Dog{is_fed:false});
let cat = zoo.host(Cat{is_fed:false});
zoo.host(Cat{is_fed:false});
zoo.host(Dog{is_fed:false});
zoo.host(Cat{is_fed:false});
let dog = zoo.host(Dog{is_fed:false});
zoo.host(Cat{is_fed:false});
dog.borrow_mut().feed();
}

Answer 2

Using
fn host<A: Animal + 'static>(&mut self, a: A) -> &mut (dyn Animal + 'static) {
self.animals.push(Box::new(a));
let pushed_box = self.animals.last_mut().expect("error");
pushed_box.as_mut()
}
will fix the first error. You're basically telling the compiler that A will own all the data or only have static references.
You can't return an A because self.animals doesn't consist of only A which at this point is a concrete type.
The second error arises because you keep the reference to dog around till after you edited zoo again.
At that point the whole animals Vec could have moved somewhere else and thus dog is no longer valid.