当B可Deref为A时，如何从WrapB Deref至WrapA？

方案1：提取公共逻辑到Trait #

把WrapA里的核心方法抽象成Trait，让WrapA和WrapB都实现这个Trait，彻底避免重复代码。

// 定义包含所有公共API的Trait
trait WrapAApi {
    fn do_something(&self);
    fn modify_something(&mut self);
    // 其他大量公共方法...
}

// 让WrapA实现Trait，复用原有逻辑
impl WrapAApi for WrapA {
    fn do_something(&self) {
        // 原WrapA的业务逻辑
        println!("操作A实例: {:?}", self.a);
    }

    fn modify_something(&mut self) {
        // 原WrapA的可变操作逻辑
        self.a.some_field = 42;
    }
}

// 直接为WrapB实现Trait，通过B的Deref拿到A，构造临时WrapA调用方法
impl WrapAApi for WrapB {
    fn do_something(&self) {
        // 用WrapB里的B解引用得到A，构造临时WrapA实例
        WrapA { a: &self.b, ..WrapA::default() }.do_something()
    }

    fn modify_something(&mut self) {
        // 可变版本同理，注意这里需要&mut A，而B的DerefMut可以提供
        WrapA { a: &mut self.b, ..WrapA::default() }.modify_something()
    }
}

处理后，持有WrapB实例时可以直接调用do_something()等方法，完全复用WrapA的逻辑，不用重复写任何方法体。如果WrapA有额外字段，可以在构造临时实例时用WrapB里对应的字段填充，或者设置合理的默认值。

方案2：使用宏批量生成包装方法 #

如果不想引入Trait，也可以用宏自动为WrapB生成所有WrapA方法的包装函数，减少手写重复代码的工作量。

// 定义宏，批量生成委托方法
macro_rules! delegate_wrap_a {
    ($wrapper:ident, $inner_field:ident, $wrap_a_ctor:expr) => {
        impl $wrapper {
            pub fn do_something(&self) {
                $wrap_a_ctor.do_something()
            }

            pub fn modify_something(&mut self) {
                $wrap_a_ctor.modify_something()
            }

            // 继续添加其他需要委托的方法...
        }
    };
}

// 为WrapB生成所有WrapA的方法
delegate_wrap_a!(WrapB, b, WrapA { a: &self.b, ..WrapA::default() });

这个方案适合不想改动原有结构的场景，只需要维护宏里的方法列表，就能自动生成WrapB的对应方法。

方案3：基于引用类型的便捷访问 #

如果坚持要用类似Deref的自动访问特性，可以定义一个引用类型WrapARef，让它实现WrapAApi（基于方案1的Trait），然后让WrapB实现AsRef<WrapARef>来快速获取引用类型：

struct WrapARef<'a> {
    a: &'a A,
    // WrapA的其他字段引用或默认值
}

// 让WrapARef实现WrapAApi
impl<'a> WrapAApi for WrapARef<'a> {
    fn do_something(&self) {
        WrapA { a: self.a, ..WrapA::default() }.do_something()
    }

    fn modify_something(&mut self) {
        // 如果需要可变操作，定义对应的WrapAMutRef
        // WrapAMutRef { a: self.a, .. }.modify_something()
    }
}

// 为WrapB实现AsRef，快速获取WrapARef
impl<'a> AsRef<WrapARef<'a>> for WrapB {
    fn as_ref(&'a self) -> &WrapARef<'a> {
        // 实际使用中可以把WrapARef作为WrapB的内部字段缓存，避免重复创建
        &WrapARef { a: &self.b }
    }
}

这种方式可以通过wrap_b.as_ref().do_something()调用API，虽然需要显式调用as_ref()，但比手动写所有方法要简洁。

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