如何编写Rust的my_function，支持任意实现MyTrait的引用类型并可多次调用子函数？

问题分析 #

原代码的核心矛盾在于：

1. my_function原参数&'a T仅匹配不可变引用，可变引用&mut T是独立类型，无法满足约束；
2. 若直接用U: MyTrait<'a>作为参数，非Copy类型（如&mut MyType2）会因所有权移动，只能调用一次some_library_function。

方案1：辅助Trait统一逻辑（推荐） #

通过定义辅助Trait封装不同类型的传递逻辑，既支持多次调用，又兼容不可变/可变引用：

struct MyType1;
struct MyType2;

trait MyTrait<'a> {}

impl<'a> MyTrait<'a> for &MyType1 {}
impl<'a> MyTrait<'a> for &mut MyType2 {}

// 辅助Trait：定义如何生成可传递给库函数的实例
trait CanInvokeLibrary<'a> {
    fn get_instance(&mut self) -> impl MyTrait<'a>;
}

// 不可变引用实现：直接返回自身（Copy类型可多次复用）
impl<'a> CanInvokeLibrary<'a> for &'a MyType1 {
    fn get_instance(&mut self) -> impl MyTrait<'a> {
        *self
    }
}

// 可变引用实现：重新借用生成新的可变引用（规避所有权移动）
impl<'a> CanInvokeLibrary<'a> for &'a mut MyType2 {
    fn get_instance(&mut self) -> impl MyTrait<'a> {
        &mut **self
    }
}

fn my_function<'a, U: CanInvokeLibrary<'a>>(mut x: U) {
    some_library_function(x.get_instance());
    some_library_function(x.get_instance());
}

fn some_library_function<'a>(x: impl MyTrait<'a>) {}

fn main() {
    let foo = MyType1;
    let mut bar = MyType2;
    my_function(&foo);
    my_function(&mut bar); // 现在可正常调用
}

方案2：扩展Trait实现+重新借用 #

若愿意添加额外的MyTrait实现，可通过引用的引用实现多次传递：

struct MyType1;
struct MyType2;

trait MyTrait<'a> {}

impl<'a> MyTrait<'a> for &MyType1 {}
impl<'a> MyTrait<'a> for &mut MyType2 {}
// 添加额外的Trait实现，支持引用的引用
impl<'a> MyTrait<'a> for &&MyType1 {}
impl<'a> MyTrait<'a> for &&mut MyType2 {}

fn my_function<'a, U: 'a>(x: &'a U)
where
    for<'b> &'b U: MyTrait<'b>,
{
    some_library_function(&*x);
    some_library_function(&*x);
}

fn some_library_function<'a>(x: impl MyTrait<'a>) {}

fn main() {
    let foo = MyType1;
    let mut bar = MyType2;
    my_function(&&foo);
    my_function(&&mut bar); // 调用时需多一层引用
}

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