有没有办法（以某种方式）在 rust 中创建一个（Box of）闭包的拥有版本？

Question

我想用一个new的 function 编写一个FuncWrapper结构，它将一个 (Boxed) 闭包作为参数，并返回一个装饰闭包，它只是向传入的闭包添加一些样板。 但我也希望返回值被“拥有”，以允许以下（例如）：

fn main() {                                                                                                                                                                                                                           
                                                                                                                                                                                                                                      
    let a: FuncWrapper<u32>;                                                                                                                                                                                                          
                                                                                                                                                                                                                                      
    {                                                                                                                                                                                                                                 
        let foo = |x: u32| {print!("{}", x)};                                                                                                                                                                                         
        let b = &Box::new(foo);                                                                                                                                                                                                       
        a = FuncWrapper::new(b);                                                                                                                                                                                                     
    }                                                                                                                                                                                                                                 
                                                                                                                                                                                                                                      
    let _c = (a.func)(42);                                                                                                                                                                                                            
}                                                                                                                                                                                                                                          

也就是说，我希望 new 的返回值是一个“拥有的”值。

现在我最近了解到 Rust 中的所有闭包（作为 Trais）必须具有与之相关联的生命周期（如果未指定，它将默认为'static 。）但我想它似乎是返回的 FuncWrapper 中闭包的任何生命周期new的价值将是错误的。

我不希望生命周期是传入引用的生命周期，因为这太短了。 例如，以下将不起作用，因为返回值的生命周期是参数f_box_ref的生命周期，在我上面提供的情况下，它的生命周期不够长

struct FuncWrapper<'b, DomainType> {                                                                                                                                                                                                  
    func: Box<dyn Fn(DomainType) + 'b>                                                                                                                                                                                                
}                                                                                                                                                                                                                                     
                                                                                                                                                                                                                                      
impl<'b, DomainType> FuncWrapper<'b, DomainType> {                                                                                                                                                                                    
    fn new<F: Fn(DomainType) + 'static>(f_box_ref: &'b Box<F>) -> FuncWrapper<'b, DomainType> {                                                                                                                                       
        let new_f = move |a: DomainType| {                                                                                                                                                                                            
            // ..add some boilerplate then                                                                                                                                                                                            
            (**f_box_ref)(a)                                                                                                                                                                                                          
        };                                                                                                                                                                                                                            
        let b = Box::new(new_f);                                                                                                                                                                                                      
        FuncWrapper {func: b}                                                                                                                                                                                                         
    }                                                                                                                                                                                                                                 
}    

结果是

error[E0716]: temporary value dropped while borrowed
  --> src/main.rs:22:18
   |
22 |         let b = &Box::new(foo);
   |                  ^^^^^^^^^^^^^ creates a temporary which is freed while still in use
23 |         a = FuncWrapper::new(b);
24 |     }
   |     - temporary value is freed at the end of this statement
...
27 | }
   | - borrow might be used here, when `a` is dropped and runs the destructor for type `FuncWrapper<'_, u32>`
   |
   = note: consider using a `let` binding to create a longer lived value

将返回参数的生命周期更改为'static似乎也是错误的，因为我的目标是在new函数中创建一个新的闭包`，（所以它怎么可能是 static？）但无论如何：

struct FuncWrapper<DomainType> {                                                                                                                                                                                                      
    func: Box<dyn Fn(DomainType) + 'static>                                                                                                                                                                                           
}                                                                                                                                                                                                                                     
                                                                                                                                                                                                                                      
impl<DomainType> FuncWrapper<DomainType> {                                                                                                                                                                                            
    fn new<'b, F: Fn(DomainType) + 'static>(f_box_ref: &'b Box<F>) -> FuncWrapper<DomainType> {                                                                                                                                       
        let new_f = move |a: DomainType| {                                                                                                                                                                                            
            // ..add some boilerplate then                                                                                                                                                                                            
            (**f_box_ref)(a)                                                                                                                                                                                                          
        };                                                                                                                                                                                                                            
        let b = Box::new(new_f);                                                                                                                                                                                                      
        FuncWrapper {func: b}                                                                                                                                                                                                         
    }                                                                                                                                                                                                                                 
}                                                                                                                                                                                                                                     

错误与

error[E0759]: `f_box_ref` has lifetime `'b` but it needs to satisfy a `'static` lifetime requirement
  --> src/main.rs:7:21
   |
6  |       fn new<'b, F: Fn(DomainType) + 'static>(f_box_ref: &'b Box<F>) -> FuncWrapper<DomainType> {
   |                                                          ---------- this data with lifetime `'b`...
7  |           let new_f = move |a: DomainType| {
   |  _____________________^
8  | |             // ..add some boilerplate then
9  | |             (**f_box_ref)(a)
10 | |         };
   | |_________^ ...is used here...
11 |           let b = Box::new(new_f);
12 |           FuncWrapper {func: b}
   |                              - ...and is required to live as long as `'static` here

这个错误让我感到惊讶，因为我认为move的工作是按价值捕获。 起初我以为我需要先取消引用f_box_ref ？ 但是那个

impl<DomainType> FuncWrapper<DomainType> {                                                                                                                                                                                            
    fn new<'b, F: Fn(DomainType) + 'static>(f_box_ref: &'b Box<F>) -> FuncWrapper<DomainType> {                                                                                                                                       
        let f_box: Box<F> =  *f_box_ref;                                                                                                                                                                                              
        let new_f = move |a: DomainType| {                                                                                                                                                                                            
            // ..add some boilerplate then                                                                                                                                                                                            
            (*f_box)(a)                                                                                                                                                                                                               
        };                                                                                                                                                                                                                            
        let b = Box::new(new_f);                                                                                                                                                                                                      
        FuncWrapper {func: b}                                                                                                                                                                                                         
    }                                                                                                                                                                                                                                 
}                                                                                                                                                                                                                                     
           

结果是

error[E0507]: cannot move out of `*f_box_ref` which is behind a shared reference
 --> src/main.rs:7:30
  |
7 |         let f_box: Box<F> =  *f_box_ref;
  |                              ^^^^^^^^^^
  |                              |
  |                              move occurs because `*f_box_ref` has type `Box<F>`, which does not implement the `Copy` trait
  |                              help: consider borrowing here: `&*f_box_ref`

las，按照“帮助：考虑在这里借用： &*f_box_ref ”的提示也无济于事

impl<DomainType> FuncWrapper<DomainType> {                                                                                                                                                                                            
    fn new<'b, F: Fn(DomainType) + 'static>(f_box_ref: &'b Box<F>) -> FuncWrapper<DomainType> {                                                                                                                                       
        let f_box: &Box<F> =  &*f_box_ref;                                                                                                                                                                                            
        let new_f = move |a: DomainType| {                                                                                                                                                                                            
            // ..add some boilerplate then                                                                                                                                                                                            
            (*f_box)(a)                                                                                                                                                                                                               
        };                                                                                                                                                                                                                            
        let b = Box::new(new_f);                                                                                                                                                                                                      
        FuncWrapper {func: b}                                                                                                                                                                                                         
    }                                                                                                                                                                                                                                 
}

错误与

error[E0759]: `f_box_ref` has lifetime `'b` but it needs to satisfy a `'static` lifetime requirement
  --> src/main.rs:7:31
   |
6  |     fn new<'b, F: Fn(DomainType) + 'static>(f_box_ref: &'b Box<F>) -> FuncWrapper<DomainType> {
   |                                                        ---------- this data with lifetime `'b`...
7  |         let f_box: &Box<F> =  &*f_box_ref;
   |                               ^^^^^^^^^^^ ...is used here...
...
13 |         FuncWrapper {func: b}
   |                            - ...and is required to live as long as `'static` here

所以很明显我们仍然没有返回任何类似新拥有的闭包的东西，并且对返回的闭包的生命周期的任何选择似乎都是武断和错误的。

我在这里尝试做的事情似乎应该很普遍。 我错过了什么？

Answer 1

这非常简单，要从引用中获取拥有的类型，您会立即想到 3 个选项： Copy 、 Clone或ToOwned 。 ToOwned稍微高级一点，因为它也可以更改类型，并且由于Copy需要Cloned ，我将重点关注后者。

要从&Box<Fn>获取拥有的Fn ，您只需调用clone() ：

impl<DomainType> FuncWrapper<DomainType> {
    fn new<F: Fn(DomainType) + Clone + 'static>(f_box_ref: &Box<F>) -> FuncWrapper<DomainType> {
        let f_box = f_box_ref.clone();
        let new_f = move |a: DomainType| {
            // ..add some boilerplate then
            (f_box)(a)
        };
        let b = Box::new(new_f);
        FuncWrapper { func: b }
    }
}

Answer 2

因为它不是FnMut ，只是Fn也许你可以使用Rc而不是Box ？ 你总是可以克隆一个Rc

use std::rc::Rc;

impl<DomainType> FuncWrapper<DomainType> {
    fn new<F: Fn(DomainType) + 'static>(f_rc: Rc<F>) -> FuncWrapper<DomainType> {
        let new_f = move |a: DomainType| {
            // ..add some boilerplate then
            (f_rc)(a)
        };
        let b = Box::new(new_f);
        FuncWrapper { func: b }
    }
}