如何将Fn(&mut A) -> _转换为Fn(&mut dyn Paint) -> _？

核心思路 #

要在不修改main中push调用的前提下，把接受&mut A的闭包转换成接受&mut dyn Paint的闭包，关键在于利用泛型方法接收具体类型闭包，再在内部通过类型向下转型（downcast_mut）将动态分发的trait对象转回具体类型，从而适配闭包的参数要求。

完整代码实现 #

trait Paint {
    fn nexta(&mut self);
}

struct A(());

impl Paint for A {
    fn nexta(&mut self) {
        println!("A's nexta");
    }
}

struct Anime {
    items: Vec<(Box<dyn Paint>, Box<dyn Fn(&mut dyn Paint)>)>,
}

impl Anime {
    fn new() -> Self {
        Anime { items: Vec::new() }
    }

    // 泛型方法接收具体类型的Paint实例和对应闭包
    fn push<P: Paint + 'static, F: Fn(&mut P) + 'static>(&mut self, paint: P, f: F) {
        // 包装闭包，适配&mut dyn Paint参数
        let wrapped_closure = move |dyn_paint: &mut dyn Paint| {
            // 向下转型为具体类型P，这里因为push时传入的是P类型实例，所以转型必然成功
            if let Some(concrete_paint) = dyn_paint.downcast_mut::<P>() {
                f(concrete_paint);
            } else {
                panic!("Unexpected type encountered during downcast");
            }
        };

        self.items.push((Box::new(paint), Box::new(wrapped_closure)));
    }

    // 执行所有闭包逻辑
    fn run(&mut self) {
        for (paint, closure) in self.items.iter_mut() {
            closure(paint);
        }
    }
}

fn main() {
    let mut anime = Anime::new();
    // 完全保留原调用方式，无需修改
    anime.push(A(()), move |a: &mut A| a.nexta());
    anime.run();
}

带返回值的闭包适配 #

如果闭包需要返回值，只需调整泛型参数和闭包包装逻辑：

trait Paint {
    fn nexta(&mut self) -> String {
        String::from("default")
    }
}

struct A(());

impl Paint for A {
    fn nexta(&mut self) -> String {
        String::from("A's nexta result")
    }
}

struct AnimeWithReturn<R> {
    items: Vec<(Box<dyn Paint>, Box<dyn Fn(&mut dyn Paint) -> R>)>,
}

impl<R> AnimeWithReturn<R> {
    fn new() -> Self {
        AnimeWithReturn { items: Vec::new() }
    }

    fn push<P: Paint + 'static, F: Fn(&mut P) -> R + 'static>(&mut self, paint: P, f: F) {
        let wrapped_closure = move |dyn_paint: &mut dyn Paint| -> R {
            let concrete_paint = dyn_paint.downcast_mut::<P>()
                .expect("Type mismatch: unexpected Paint implementation");
            f(concrete_paint)
        };

        self.items.push((Box::new(paint), Box::new(wrapped_closure)));
    }

    fn run(&mut self) -> Vec<R> {
        self.items.iter_mut().map(|(paint, closure)| closure(paint)).collect()
    }
}

fn main() {
    let mut anime = AnimeWithReturn::new();
    anime.push(A(()), move |a: &mut A| a.nexta());
    let results = anime.run();
    println!("{:?}", results); // 输出: ["A's nexta result"]
}

关键说明 #

• 泛型push方法自动推导传入的具体类型P（这里是A），无需显式指定。
• downcast_mut是安全的：因为我们存入的Paint实例就是P类型，所以转型不会失败，除非手动构造不符合逻辑的类型（这种情况属于编码错误）。
• 完全保留了原main函数的调用方式，满足题目要求。

内容的提问来源于stack exchange，提问作者o.O