如何引用特征并仍然使用原始结构？

Question

My goal is to have a reference counted struct which is referred as a trait in one context and by its concrete type in another. Best explained in code:

#![feature(box_syntax)]

use std::rc::Rc;
use std::cell::RefCell;

trait Employee {
    fn be_managed(&mut self);
}

struct Human;

impl Human {
    fn be_human(&mut self) {
        println!("I'm just a human who needs a mutable self sometimes");
    }
}

impl Employee for Human {
    fn be_managed(&mut self) {
        println!("Off to the salt mines");
    }
}

struct Manager {
    my_employee: Rc<RefCell<Box<Employee + 'static>>>, //'
}

fn main() {
    let mut human1 = Rc::new(RefCell::new(box Human as Box<Employee>));

    let manager1 = Manager {
        my_employee: human1.clone(), // This works due to cast above
    };

    manager1.my_employee.borrow_mut().be_managed();

    human1.borrow_mut().be_human(); // But we can't be human anymore



    let mut human2 = Rc::new(RefCell::new(box Human));

    let manager2 = Manager {
        my_employee: human2.clone(), // This doesn't work
    };

    manager2.my_employee.borrow_mut().be_managed();

    human2.borrow_mut().be_human();
}

I want the Manager to be able to have any struct implementing the Employee trait as my_employee , but other references should still be able to call other methods on the original object, ie be_human .

Right now I'm getting the following errors from the above code:

src/main.rs:37:25: 37:35 error: type `core::cell::RefMut<'_, Box<Employee>>` does not implement any method in scope named `be_human`
src/main.rs:37     human1.borrow_mut().be_human(); // But we can't be human anymore
                                       ^~~~~~~~~~
src/main.rs:44:22: 44:36 error: mismatched types:
 expected `alloc::rc::Rc<core::cell::RefCell<Box<Employee + 'static>>>`,
    found `alloc::rc::Rc<core::cell::RefCell<Box<Human>>>`
(expected trait Employee,
    found struct `Human`) [E0308]
src/main.rs:44         my_employee: human2.clone(), // This doesn't work
                                    ^~~~~~~~~~~~~~

What's the right approach in this situation?

Answer 1

Disclaimer: in this answer I will assume that you are willingly NOT using an enum because you want Employee to be open.

This issue comes up in about every single language that uses dynamic polymorphism, and the traditional answer is the Visitor Pattern .

It is not exactly ideal, though, because of the dependencies it introduces, so if necessary you can use the Acyclic Visitor Pattern ; however I advise that you start with a bare bone visitor before delving further.

trait EmployeeVisitor {
    fn visit_employee(&self, e: &Employee);
    fn visit_human(&self, h: &Human);
}

trait Employee {
    fn accept(&self, v: &EmployeeVisitor) {
        v.visit_employee(self);
    }
}

impl Employee for Human {
    fn accept(&self, v: &EmployeeVisitor) {
        v.visit_human(self);
    }
 }

This is the traditional "every problem can be solved with a layer of indirection", and it incurs the traditional issue of bringing another layer of indirection.