如何在Rust中表示可克隆的动态闭包类型？

在Rust中，直接给动态闭包添加Clone约束的写法Box<dyn (Fn() -> i32) + Clone>无效，核心原因是Clone trait的clone方法签名fn clone(&self) -> Self不适用于动态大小类型（DST）——dyn trait对象属于DST，无法直接返回Self。要实现可克隆的动态闭包，你可以通过自定义trait + 自动实现的方式解决：

步骤1：定义包含克隆方法的自定义trait #

我们需要创建新trait，既包含闭包的调用逻辑，又提供返回Box<dyn 对应闭包类型>的克隆方法，避免直接返回DST：

// 针对返回i32的闭包定义可克隆trait
trait CloneFnI32: Fn() -> i32 {
    fn clone_box(&self) -> Box<dyn CloneFnI32>;
}

// 为所有实现Fn() -> i32和Clone的类型自动实现CloneFnI32
impl<F: Fn() -> i32 + Clone + 'static> CloneFnI32 for F {
    fn clone_box(&self) -> Box<dyn CloneFnI32> {
        Box::new(self.clone())
    }
}

// 同理为其他返回类型定义对应的trait
trait CloneFnU64: Fn() -> u64 {
    fn clone_box(&self) -> Box<dyn CloneFnU64>;
}

impl<F: Fn() -> u64 + Clone + 'static> CloneFnU64 for F {
    fn clone_box(&self) -> Box<dyn CloneFnU64> {
        Box::new(self.clone())
    }
}

trait CloneFnI8: Fn() -> i8 {
    fn clone_box(&self) -> Box<dyn CloneFnI8>;
}

impl<F: Fn() -> i8 + Clone + 'static> CloneFnI8 for F {
    fn clone_box(&self) -> Box<dyn CloneFnI8> {
        Box::new(self.clone())
    }
}

步骤2：为Callbacks结构体手动实现Clone #

基于自定义trait的clone_box方法，手动为Callbacks实现Clone：

struct Callbacks {
    callback_a: Box<dyn CloneFnI32>,
    callback_b: Box<dyn CloneFnU64>,
    callback_c: Box<dyn CloneFnI8>,
}

impl Clone for Callbacks {
    fn clone(&self) -> Self {
        Callbacks {
            callback_a: self.callback_a.clone_box(),
            callback_b: self.callback_b.clone_box(),
            callback_c: self.callback_c.clone_box(),
        }
    }
}

简化方案：通用可克隆闭包trait #

如果不想为每个返回类型单独定义trait，可以用带关联类型的通用trait：

trait CloneFn {
    type Output;
    fn call(&self) -> Self::Output;
    fn clone_box(&self) -> Box<dyn CloneFn<Output = Self::Output>>;
}

impl<F: Fn() -> O + Clone + 'static, O> CloneFn for F {
    type Output = O;
    fn call(&self) -> O {
        self()
    }
    fn clone_box(&self) -> Box<dyn CloneFn<Output = O>> {
        Box::new(self.clone())
    }
}

// 修改后的Callbacks结构体
struct Callbacks {
    callback_a: Box<dyn CloneFn<Output = i32>>,
    callback_b: Box<dyn CloneFn<Output = u64>>,
    callback_c: Box<dyn CloneFn<Output = i8>>,
}

impl Clone for Callbacks {
    fn clone(&self) -> Self {
        Callbacks {
            callback_a: self.callback_a.clone_box(),
            callback_b: self.callback_b.clone_box(),
            callback_c: self.callback_c.clone_box(),
        }
    }
}

// 使用示例
fn main() {
    let cb = Callbacks {
        callback_a: Box::new(|| 42),
        callback_b: Box::new(|| 100u64),
        callback_c: Box::new(|| -1i8),
    };
    let cb_clone = cb.clone();
    assert_eq!(cb.callback_a.call(), 42);
    assert_eq!(cb_clone.callback_a.call(), 42);
}

关键说明 #

• 'static约束：默认情况下，Box<dyn ...>需要闭包具有'static生命周期（若要捕获非静态变量，可给trait添加生命周期参数，但会增加复杂度）。
• 手动实现Clone：因自定义trait的存在，无法直接派生Clone，必须手动实现并调用每个回调的clone_box方法。

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