如何在Rust中递归传递闭包实现N叉树前序遍历？

我需要为N叉树实现前序遍历，要求遍历过程中对每个节点执行传入的闭包。初始实现如下：

#[derive(Debug)]
pub struct Node<T> {
    value: T,
    children: Vec<Node<T>>,
}

impl<T> Node<T> {
    pub fn preorder<F>(&self, mut f: F)
    where
        F: FnMut(&Self),
    {
        f(self);
        self.children.iter().for_each(|child| child.preorder(f));
    }
}

但编译时触发错误：

error[E0507]: cannot move out of `f`, a captured variable in an `FnMut` closure
  --> src/lib.rs:12:62
   |
7  |     pub fn preorder<F>(&self, mut f: F)
   |                               ----- captured outer variable
...
12 |         self.children.iter().for_each(|child| child.preorder(f));
   |                                       -------                ^ move occurs because `f` has type `F`, which does not implement the `Copy` trait
   |                                       |
   |                                       captured by this `FnMut` closure

我已经找到两个解决方案，但都有不足：

1. 给闭包添加Copy约束：

pub fn preorder<F>(&self, mut f: F)
    where
        F: FnMut(&Self) + Copy,

此方法可编译，但强制要求闭包实现Copy，无法处理捕获了不可拷贝变量（比如Vec）的闭包，不符合需求。

2. 使用内部辅助方法规避Copy约束：

pub struct Node<T> {
    value: T,
    children: Vec<Node<T>>,
}

impl<T> Node<T> {
    fn preorder_immersion<F>(&self, f: &mut F)
    where
        F: FnMut(&Self),
    {
        f(self);
        self.children
            .iter()
            .for_each(|child| child.preorder_immersion(f));
    }

    pub fn preorder_mut<F>(&self, mut f: F)
    where
        F: FnMut(&Self),
    {
        self.preorder_immersion(&mut f);
    }
}

该方案可行，但需要为每种遍历实现两个方法，感觉不够优雅。

我希望最终能以如下方式调用：

let mut result = Vec::new();
node.preorder(|n| result.push(*n.value()));

请问是否有更优雅的实现方式？或者上述辅助方法方案是否是合理的选择？

错误原因分析 #

编译错误的核心是：在for_each的闭包中，每次调用child.preorder(f)都会移动闭包f的所有权。由于FnMut闭包默认不实现Copy，第一个子节点拿走f后，后续子节点无法再获取f的所有权，导致所有权转移错误。

方案评价与优化 #

1. 辅助方法方案完全可行，且是Rust惯用法

你找到的辅助方法方案其实是Rust中处理这类FnMut递归传递场景的标准做法，只需调整命名就能优化对外接口的简洁性：将内部辅助方法设为私有，对外暴露的方法保持preorder，用户调用时完全感知不到内部实现细节：

#[derive(Debug)]
pub struct Node<T> {
    value: T,
    children: Vec<Node<T>>,
}

impl<T> Node<T> {
    // 私有辅助方法，接收闭包的可变引用
    fn preorder_inner<F>(&self, f: &mut F)
    where
        F: FnMut(&Self),
    {
        f(self);
        self.children.iter().for_each(|child| child.preorder_inner(f));
    }

    // 对外公开的方法，接收闭包并传递可变引用给辅助方法
    pub fn preorder<F>(&self, mut f: F)
    where
        F: FnMut(&Self),
    {
        self.preorder_inner(&mut f);
    }
}

这样用户依然可以用你期望的方式调用：

let mut result = Vec::new();
node.preorder(|n| result.push(n.value.clone())); // 假设T实现Clone

这种方式的优势在于：

• 对外接口简洁，符合用户预期
• 内部通过传递闭包的可变引用，保证所有子节点共享同一个闭包实例，避免所有权转移问题
• 无需强制约束闭包实现Copy，支持所有FnMut闭包

2. 无需额外方法：手动遍历替代for_each

如果你不想写单独的辅助方法，也可以在preorder方法中手动遍历子节点，但本质上还是需要传递闭包的可变引用，因此最终还是离不开辅助方法的逻辑——直接修改preorder参数为&mut F会导致用户调用时必须传递&mut闭包，反而不够优雅。

总结 #

辅助方法方案是完全合理且优雅的选择，通过私有辅助方法处理递归的可变引用传递，对外保持简洁的调用接口，既解决了所有权问题，又支持所有FnMut闭包场景，完全符合你的需求。

内容的提问来源于stack exchange，提问作者Héctor M.C.