如何让Rust结构体兼容持有MyTrait的所有权类型与可变引用？

问题背景 #

给定以下Rust trait与结构体定义：

// 简化版的实际数据结构与trait
trait MyTrait {
    fn blub(&mut self);
}
struct MyStruct;
impl MyTrait for MyStruct {
    fn blub(&mut self) {
        println!("Blub!");
    }
}

需求是创建结构体Foo，使其既能持有实现MyTrait的所有权实例，也能持有对应类型的可变引用。预期的调用方式如下：

fn main() {
    let t0 = MyStruct;
    let mut f0 = Foo::new(t0);
    f0.run();

    let mut t1 = MyStruct;
    let mut f1 = Foo::new(&mut t1);
    f1.run();
}

但上述代码无法运行，核心原因是&mut MyStruct并未实现MyTrait——尽管MyTrait::blub接收&mut self，理论上兼容所有权与可变引用，但Rust的trait实现不会自动继承给引用类型。

当前实现的问题 #

目前的可行实现存在两个冗余点：多余的第二个泛型参数、需要使用PhantomData占位符：

use std::{borrow::BorrowMut, marker::PhantomData};

// 简化版的实际数据结构与trait
trait MyTrait {
    fn blub(&mut self);
}
struct MyStruct;
impl MyTrait for MyStruct {
    fn blub(&mut self) {
        println!("Blub!");
    }
}

// 期望持有MyTrait实例或可变引用的结构体
struct Foo<T, U> {
    t: T,
    _p: PhantomData<U>,
}

impl<T, U> Foo<T, U>
where
    T: BorrowMut<U>,
    U: MyTrait,
{
    fn new(t: T) -> Self {
        Self { t, _p: PhantomData }
    }

    fn run(&mut self) {
        self.t.borrow_mut().blub();
    }
}

fn main() {
    let t0 = MyStruct;
    let mut f0 = Foo::new(t0);
    f0.run();

    let mut t1 = MyStruct;
    let mut f1: Foo<_, MyStruct> = Foo::new(&mut t1);
    f1.run();
}

输出：

Blub!
Blub!

更优雅的实现方案 #

可以通过**移除结构体的第二个泛型参数和PhantomData**来简化实现，利用Rust的泛型推导能力自动确定BorrowMut的目标类型：

use std::borrow::BorrowMut;

// 简化版的实际数据结构与trait
trait MyTrait {
    fn blub(&mut self);
}
struct MyStruct;
impl MyTrait for MyStruct {
    fn blub(&mut self) {
        println!("Blub!");
    }
}

struct Foo<T> {
    t: T,
}

impl<T, U> Foo<T>
where
    T: BorrowMut<U>,
    U: MyTrait,
{
    fn new(t: T) -> Self {
        Self { t }
    }

    fn run(&mut self) {
        self.t.borrow_mut().blub();
    }
}

fn main() {
    let t0 = MyStruct;
    let mut f0 = Foo::new(t0);
    f0.run();

    let mut t1 = MyStruct;
    let mut f1 = Foo::new(&mut t1); // 编译器自动推导U为MyStruct，无需显式指定
    f1.run();
}

这个实现的核心优化点：

• 结构体Foo仅保留一个泛型参数T，避免冗余
• 移除PhantomData，代码更简洁
• 编译器会自动推导BorrowMut的目标类型U，无需在调用时显式标注

另一种可选方案是利用DerefMut trait，逻辑类似但写法略有不同：

use std::ops::DerefMut;

// （trait与结构体定义同前）

struct Foo<T> {
    t: T,
}

impl<T> Foo<T>
where
    T: DerefMut,
    <T as DerefMut>::Target: MyTrait,
{
    fn new(t: T) -> Self {
        Self { t }
    }

    fn run(&mut self) {
        self.t.deref_mut().blub();
    }
}

// main函数同前

关于XY问题的讨论 #

你提到的“为&mut MyStruct实现MyTrait”的思路，受限于Rust的孤儿规则：如果trait和类型都不属于当前 crate，无法为该类型实现外部trait。如果MyTrait和MyStruct来自第三方库，确实无法自行添加这个实现。

这种情况下是否属于XY问题，取决于你的实际场景：

• 如果核心需求是“统一持有所有权实例和可变引用并调用trait方法”，上述优化后的实现已经足够解决问题
• 如果第三方库的设计确实应该支持通过可变引用调用trait方法，可以考虑向该库提交Feature Request，请求为&mut U（其中U: MyTrait）实现MyTrait——这是Rust生态中常见的扩展模式，很多库都会为引用类型实现对应trait以提升易用性。

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