在子类型上获取 Rc<RefCell<dyn T>>>

Question

我有以下定义：

trait A {
    fn f(&self);
}

trait B: A {
// ...
}

我想实现这种功能：

fn convert(v: Rc<RefCell<dyn B>>) -> Rc<RefCell<dyn A>> {
}

我希望有一种方法可以返回共享同一对象的值，这意味着使用以下声明：

let x: Rc<RefCell<dyn B>> /* = ... */;
let y = convert(Rc::clone(&x));

调用x.f() 和y.f() 将调用应用于同一个对象。

我如何实现函数convert 或如何更改类型定义以具有那种行为和那种转换（到子对象的转换）。

Answer 1

Rust 不支持直接向上转换 trait 对象。由于 trait 对象的实现方式，如果没有运行时额外的工作，这是不可能的，因此 Rust 让你自己完成工作。

你可以这样做，例如

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

trait A {
  fn f(&self) -> i32;
}

trait B: A {
}

struct Wrapper(Rc<RefCell<dyn B>>);

impl A for Wrapper {
    fn f(&self) -> i32 {
        A::f(&*self.0.borrow())
    }
}

fn convert(v: Rc<RefCell<dyn B>>) -> Rc<RefCell<dyn A>> {
    Rc::new(RefCell::new(Wrapper(v)))
}

Answer 2

感谢您的想法，我决定通过避免使用 trait-object 作为函数 convert in 根据 Rust 规则的参数来进行折衷：

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

trait A {
    fn print(&self);
}

trait B: A {
}

trait Convert {
    fn convert(it: Rc<RefCell<Self>>) -> Rc<RefCell<dyn A>>;
}

struct MyType(u32);

impl Convert for MyType {
    fn convert(it: Rc<RefCell<Self>>) -> Rc<RefCell<dyn A>> {it}
}

impl A for MyType {
    fn print(&self) {
        println!("MyType({}) as A", self.0);
    }
}

impl B for MyType {}

fn main() {
    let a: Rc<RefCell<dyn A>>;
    {
        let b = Rc::new(RefCell::new(MyType(3)));
        a = Convert::convert(b.clone());
    }

    a.borrow().print();
}

Playground