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

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));

调用xf()和yf()将调用应用于同一对象。

我如何实现函数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 作为函数的参数来根据 Rust 规则进行convert ：

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();
}

操场