Rust中结构体无法强制转换为已实现的dyn Trait类型返回问题

问题代码 #

use std::{
    cell::{Ref, RefCell},
    rc::Rc,
};

trait TraitA {
    fn data(&self) -> Ref<Vec<Rc<dyn TraitB>>>;
}

struct A {
    data: RefCell<Vec<Rc<B>>>,
}

impl TraitA for A {
    fn data(&self) -> Ref<Vec<Rc<dyn TraitB>>> {
        self.data.borrow()
    }
}

trait TraitB {}

struct B {}

impl TraitB for B {}

编译错误 #

error[E0308]: mismatched types
  --> src/lib.rs:16:9
   |
15 |     fn data(&self) -> Ref<Vec<Rc<dyn TraitB>>> {
   |                       ------------------------ expected `Ref<'_, Vec<Rc<(dyn TraitB + 'static)>>>` because of return type
16 |         self.data.borrow()
   |         ^^^^^^^^^^^^^^^^^^ expected trait object `dyn TraitB`, found struct `B`
   |
   = note: expected struct `Ref<'_, Vec<Rc<(dyn TraitB + 'static)>>>`
              found struct `Ref<'_, Vec<Rc<B>>>`

疑问背景 #

将结构体A的data字段改为RefCell<Vec<Rc<dyn TraitB>>>可以解决编译问题，但我希望该字段仅存储B类型，而非TraitB的任意实现。

我原本以为只要B实现了TraitB，Rust就能自动完成转换——就像下面的代码中Rc<B>可以成功转为Rc<dyn TraitB>：

use std::rc::{Rc, Weak};

trait TraitB {}

struct B {}

impl TraitB for B {}

struct C {
    weak_ref: Weak<B>,
}

impl C {
    fn upgrade_weak_ref(&self) -> Rc<dyn TraitB> {
        self.weak_ref.upgrade().unwrap()
    }
}

请问为什么第一个例子的转换无法生效？是因为被Ref包裹了吗？有没有无需修改A的data字段类型的解决方法？

问题原因 #

是的，核心问题在于Ref的封装导致协变转换无法自动生效：

1. 单个Rc<B>可以隐式转为Rc<dyn TraitB>，因为Rc是协变类型，且dyn TraitB是B的超类型，这种转换是针对单个实例的指针调整。
2. 但Vec<Rc<B>>和Vec<Rc<dyn TraitB>>是完全不同的类型：前者元素是指向具体类型B的瘦指针，后者元素是包含vtable的胖指针，内存布局差异导致无法直接转换。
3. Ref<T>是持有T引用的智能指针，Ref<Vec<Rc<B>>>和Ref<Vec<Rc<dyn TraitB>>>属于不同类型，Rust无法自动对Ref内部的整个Vec做批量类型转换。

无需修改A的data字段的解决方法 #

方法一：自定义包装类型实现零开销Deref #

通过自定义类型包裹Ref<Vec<Rc<B>>>，实现Deref trait来对外暴露[Rc<dyn TraitB>]的视图，无需额外内存分配：

use std::{
    cell::{Ref, RefCell},
    ops::Deref,
    rc::Rc,
};

trait TraitA {
    fn data(&self) -> RefDynB<'_>;
}

struct A {
    data: RefCell<Vec<Rc<B>>>,
}

// 自定义包装类型，持有原Ref并实现Deref
struct RefDynB<'a>(Ref<'a, Vec<Rc<B>>>);

impl<'a> Deref for RefDynB<'a> {
    type Target = [Rc<dyn TraitB>];

    fn deref(&self) -> &Self::Target {
        // 安全的unsafe转换：Rc<B>和Rc<dyn TraitB>的指针部分内存布局兼容
        unsafe {
            std::slice::from_raw_parts(
                self.0.as_ptr() as *const Rc<dyn TraitB>,
                self.0.len(),
            )
        }
    }
}

impl TraitA for A {
    fn data(&self) -> RefDynB<'_> {
        RefDynB(self.data.borrow())
    }
}

trait TraitB {}

struct B {}

impl TraitB for B {}

方法二：使用Ref::map配合元素克隆（有额外分配） #

如果可以接受临时内存分配，通过Ref::map将原Vec<Rc<B>>转换为新的Vec<Rc<dyn TraitB>>：

use std::{
    cell::{Ref, RefCell},
    ops::Deref,
    rc::Rc,
};

trait TraitA {
    fn data(&self) -> impl Deref<Target = [Rc<dyn TraitB>]> + '_;
}

struct A {
    data: RefCell<Vec<Rc<B>>>,
}

impl TraitA for A {
    fn data(&self) -> impl Deref<Target = [Rc<dyn TraitB>]> + '_ {
        Ref::map(self.data.borrow(), |vec| {
            vec.iter()
                .map(|rc| Rc::clone(rc) as Rc<dyn TraitB>)
                .collect::<Vec<_>>()
        })
    }
}

trait TraitB {}

struct B {}

impl TraitB for B {}

方法三：修改TraitA返回类型为impl Deref #

如果允许修改TraitA的返回类型，可以直接返回匿名包装类型，避免定义全局结构体：

use std::{
    cell::{Ref, RefCell},
    ops::Deref,
    rc::Rc,
};

trait TraitA {
    fn data(&self) -> impl Deref<Target = [Rc<dyn TraitB>]> + '_;
}

struct A {
    data: RefCell<Vec<Rc<B>>>,
}

impl TraitA for A {
    fn data(&self) -> impl Deref<Target = [Rc<dyn TraitB>]> + '_ {
        // 内部定义匿名包装类型
        struct Wrapper<'a>(Ref<'a, Vec<Rc<B>>>);

        impl<'a> Deref for Wrapper<'a> {
            type Target = [Rc<dyn TraitB>];

            fn deref(&self) -> &Self::Target {
                unsafe {
                    std::slice::from_raw_parts(
                        self.0.as_ptr() as *const Rc<dyn TraitB>,
                        self.0.len(),
                    )
                }
            }
        }

        Wrapper(self.data.borrow())
    }
}

trait TraitB {}

struct B {}

impl TraitB for B {}

内容的提问来源于stack exchange，提问作者apower