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

Question

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

3

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

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，我会收到编译器错误。

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);
});

- LoneCuriousWolf

1

F:FnOnce() 的类型为 FnOnce()，这是有原因的吗？如果将其更改为类型 Fn() 并使 helper() 接受 &F，它将起作用。F:FnOnce() 使闭包 F 按值移动到调用中，因此只能使用一次。 - vikram2784

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Peter Hall · Accepted Answer

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,
        }
    }
}