rust - 如何使用对 FnOnce 闭包的引用？

我有一个需要递归传递闭包参数的函数

use std::cell::RefCell;
use std::rc::Rc;

pub struct TreeNode {
    val: i32,
    left: Option<Rc<RefCell<TreeNode>>>,
    right: Option<Rc<RefCell<TreeNode>>>,
}

pub fn pre_order<F>(root: Option<Rc<RefCell<TreeNode>>>, f: F)
where
    F: FnOnce(i32) -> (),
{
    helper(&root, f);

    fn helper<F>(root: &Option<Rc<RefCell<TreeNode>>>, f: F)
    where
        F: FnOnce(i32),
    {
        match root {
            Some(node) => {
                f(node.borrow().val);
                helper(&node.borrow().left, f);
                helper(&node.borrow().right, f);
            }
            None => return,
        }
    }
}

这不起作用:

error[E0382]: use of moved value: `f`
  --> src/lib.rs:23:45
   |
22 |                 f(node.borrow().val);
   |                 - value moved here
23 |                 helper(&node.borrow().left, f);
   |                                             ^ value used here after move
   |
   = note: move occurs because `f` has type `F`, which does not implement the `Copy` trait

error[E0382]: use of moved value: `f`
  --> src/lib.rs:24:46
   |
23 |                 helper(&node.borrow().left, f);
   |                                             - value moved here
24 |                 helper(&node.borrow().right, f);
   |                                              ^ value used here after move
   |
   = note: move occurs because `f` has type `F`, which does not implement the `Copy` trait

如果我尝试将 f 的类型从 f: F 更改为 f: &F，则会出现编译器错误

error[E0507]: cannot move out of borrowed content
  --> src/lib.rs:22:17
   |
22 |                 f(node.borrow().val);
   |                 ^ cannot move out of borrowed content

我怎样才能解决这个问题？

我这样调用函数:

let mut node = TreeNode::new(15);
node.left = Some(Rc::new(RefCell::new(TreeNode::new(9))));

let node_option = Some(Rc::new(RefCell::new(node)));
pre_order(node_option, |x| {
    println!("{:?}", x);
});

最佳答案

FnOnce 是最通用的函数约束。但是，这意味着您的代码必须适用于所有可能的功能，包括那些使用其环境的功能。这就是它被称为 FnOnce 的原因:你唯一知道的是它至少可以被调用一次 - 但不一定更多。在 pre_order 中，我们只能假设每个可能的 F 都是正确的:它可以被调用一次。

如果您将其更改为 Fn 或 FnMut ，以排除消耗其环境的闭包，您将能够多次调用它。 FnMut 是下一个最通用的函数特征，因此最好接受它而不是 Fn ，以确保您可以接受最多的函数:

pub fn pre_order<F>(root: Option<Rc<RefCell<TreeNode>>>, mut f: F)
where
    F: FnMut(i32),
{
    helper(&root, &mut f);

    fn helper<F>(root: &Option<Rc<RefCell<TreeNode>>>, f: &mut F)
    where
        F: FnMut(i32),
    {
        match root {
            Some(node) => {
                f(node.borrow().val);
                helper(&node.borrow().left, f);
                helper(&node.borrow().right, f);
            }
            None => return,
        }
    }
}

关于rust - 如何使用对 FnOnce 闭包的引用？，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/54491654/