你能克隆一个闭包吗？

Question

FnMut 闭包不能被克隆，原因很明显，但 Fn 闭包具有不可变范围；有什么方法可以创建 Fn 闭包的“副本”吗？

尝试克隆它会导致：

error[E0599]: no method named `clone` found for type `std::boxed::Box<std::ops::Fn(i8, i8) -> i8 + std::marker::Send + 'static>` in the current scope
  --> src/main.rs:22:25
   |
22 |             fp: self.fp.clone(),
   |                         ^^^^^
   |
   = note: self.fp is a function, perhaps you wish to call it
   = note: the method `clone` exists but the following trait bounds were not satisfied:
           `std::boxed::Box<std::ops::Fn(i8, i8) -> i8 + std::marker::Send> : std::clone::Clone`

以某种方式将原始指针传递给Fn 是否安全，例如：

let func_pnt = &mut Box<Fn<...> + Send> as *mut Box<Fn<...>>

从技术上讲，上述方法可行，但看起来很奇怪。

这是我正在尝试做的一个示例：

use std::thread;

struct WithCall {
    fp: Box<Fn(i8, i8) -> i8 + Send>,
}

impl WithCall {
    pub fn new(fp: Box<Fn(i8, i8) -> i8 + Send>) -> WithCall {
        WithCall { fp: fp }
    }

    pub fn run(&self, a: i8, b: i8) -> i8 {
        (self.fp)(a, b)
    }
}

impl Clone for WithCall {
    fn clone(&self) -> WithCall {
        WithCall {
            fp: self.fp.clone(),
        }
    }
}

fn main() {
    let adder = WithCall::new(Box::new(|a, b| a + b));
    println!("{}", adder.run(1, 2));

    let add_a = adder.clone();
    let add_b = adder.clone();

    let a = thread::spawn(move || {
        println!("In remote thread: {}", add_a.run(10, 10));
    });

    let b = thread::spawn(move || {
        println!("In remote thread: {}", add_b.run(10, 10));
    });

    a.join().expect("Thread A panicked");
    b.join().expect("Thread B panicked");
}

playground

我有一个带有盒装闭包的结构，我需要将该结构传递给多个线程。我不能，但我也不能克隆它，因为你不能克隆Box<Fn<>>，也不能克隆&Fn<...>。

Answer 1

锈 1.26

如果所有捕获的变量都实现，闭包实现Copy 和Clone。您可以重写代码以使用泛型而不是盒装 trait 对象来克隆它：

use std::thread;

#[derive(Clone)]
struct WithCall<F> {
    fp: F,
}

impl<F> WithCall<F>
where
    F: Fn(i8, i8) -> i8,
{
    pub fn new(fp: F) -> Self {
        WithCall { fp }
    }

    pub fn run(&self, a: i8, b: i8) -> i8 {
        (self.fp)(a, b)
    }
}

fn main() {
    let adder = WithCall::new(|a, b| a + b);
    println!("{}", adder.run(1, 2));

    let add_a = adder.clone();
    let add_b = adder;

    let a = thread::spawn(move || {
        println!("In remote thread: {}", add_a.run(10, 10));
    });

    let b = thread::spawn(move || {
        println!("In remote thread: {}", add_b.run(10, 10));
    });

    a.join().expect("Thread A panicked");
    b.join().expect("Thread B panicked");
}

Rust 1.26 之前

请记住，闭包会捕获它们的环境，因此它们有自己的生命周期，基于环境。但是，您可以引用 Fn* 并进一步传递它们，或者将它们存储在结构中：

fn do_more<F>(f: &F) -> u8
where
    F: Fn(u8) -> u8,
{
    f(0)
}

fn do_things<F>(f: F) -> u8
where
    F: Fn(u8) -> u8,
{
    // We can pass the reference to our closure around,
    // effectively allowing us to use it multiple times.
    f(do_more(&f))
}

fn main() {
    let val = 2;
    // The closure captures `val`, so it cannot live beyond that.
    println!("{:?}", do_things(|x| (x + 1) * val));
}

我会说，由于生命周期问题，将Fn* 转换为原始指针并传递它并不是普遍安全的。

Answer 2

您要做的是从多个线程调用闭包。也就是说，跨多个线程共享闭包。一想到“跨多个线程共享”这个短语，我首先想到的是to reach for Arc（至少在RFC 458 以某种形式实现之前，& 将变得可以跨线程使用）。

这允许安全的共享内存（它实现Clone 而不要求其内部类型为Clone，因为Clone 只是创建了一个指向同一内存的新指针），因此您可以拥有一个@987654331 @对象在多个线程中使用，无需复制。

总而言之，将您的 WithCall 放入 Arc 并克隆它。

use std::sync::Arc;
use std::thread;

type Fp = Box<Fn(i8, i8) -> i8 + Send + Sync>;

struct WithCall {
    fp: Fp,
}

impl WithCall {
    pub fn new(fp: Fp) -> WithCall {
        WithCall { fp }
    }

    pub fn run(&self, a: i8, b: i8) -> i8 {
        (self.fp)(a, b)
    }
}

fn main() {
    let adder = WithCall::new(Box::new(|a, b| a + b));
    println!("{}", adder.run(1, 2));

    let add_a = Arc::new(adder);
    let add_b = add_a.clone();

    let a = thread::spawn(move || {
        println!("In remote thread: {}", add_a.run(10, 10));
    });
    let b = thread::spawn(move || {
        println!("In remote thread: {}", add_b.run(10, 10));
    });

    a.join().expect("thread a panicked");
    b.join().expect("thread b panicked");
}

playground

---

旧答案（这仍然相关）：拥有&mut Fn 特征对象是很不寻常的，因为Fn::call 需要&self。 mut 不是必需的，我认为它实际上增加了零额外功能。拥有&mut Box<Fn()> 确实增加了一些功能，但也很不寻常。

如果您更改为& 指针而不是&mut，事情会更自然地工作（&Fn 和&Box<Fn>）。如果没有看到您正在使用的实际代码，就很难确切地知道您在做什么，但是

fn call_it(f: &Fn()) {
    (*f)();
    (*f)();
}

fn use_closure(f: &Fn()) {
    call_it(f);
    call_it(f);
}

fn main() {
    let x = 1i32;
    use_closure(&|| println!("x is {}", x));
}

（这部分是由于&T 是Copy，部分是由于重新借用；它也适用于&mut。）

或者，您可以关闭闭包，这可能适用于更多情况：

fn foo(f: &Fn()) {
    something_else(|| f())
}

由于显而易见的原因，无法克隆 FnMut 闭包。

FnMut 不能被克隆并没有内在的原因，它只是一个带有一些字段的结构（以及一个采用 &mut self 的方法，而不是 &self 或 self 就像 Fn 和 @ 987654355@ 分别）。如果您创建一个结构并手动实现FnMut，您仍然可以为它实现Clone。

或者以某种方式将原始指针传递给 Fn 是否安全，例如：

let func_pnt = &mut Box<Fn<...> + Send> as *mut Box<Fn<...>>

从技术上讲，上述方法可行，但看起来很奇怪。

从技术上讲，如果你小心地确保满足 Rust 的别名和生命周期要求，它就可以工作......但是通过选择不安全的指针，你把这个负担放在了自己身上，而不是让编译器帮助你。对编译器错误的正确响应是使用unsafe 代码，而不是深入研究错误并调整代码以使其更有意义（对编译器而言，这通常会使其更有意义），这是相对罕见的对人类）。

Answer 3

这是 1.22.1 中的工作代码

我们的目的是完成这项工作。

let x = |x| { println!("----{}",x)};

let mut y = Box::new(x);

y.clone();

使用了顶部建议的原始代码。

我从克隆 Fn 闭包开始。

type Fp = Box<Fn(i8, i8) -> i8 + Send + Sync>;

最终在结构体WithCall 中添加Arc 周围的Fp

Play rust : working code Gist : working code in 1.22.1