Rust中如何返回闭包或创建类闭包可调用对象？

一、直接返回闭包的类型处理 #

Rust中闭包是匿名类型，返回闭包需借助**impl Trait**或 trait 对象，同时要匹配捕获变量的生命周期：

针对你第一个示例，假设SomeTrait定义了方法的返回类型，可这样实现：

trait SomeTrait {
    type MethodOutput;
    type Output;
    fn method(&self, i: usize) -> Self::MethodOutput;
    fn other_method(&self, res: Self::MethodOutput) -> Self::Output;
}

fn make_iterator<'a, T>(t: &'a T) -> impl Fn(usize) -> <T as SomeTrait>::Output + 'a
where T: SomeTrait
{
    // 复杂逻辑...
  
    move |i: usize| {
        let res = t.method(i);
        t.other_method(res)
    }
}

这里+ 'a是必须的，因为闭包捕获了&'a T，生命周期必须和输入参数一致。

二、用自定义可调用结构体替代闭包 #

如果需要更明确的类型，或要扩展额外逻辑，可以定义结构体存储捕获的上下文，实现Fn/FnMut/FnOnce trait：

针对第一个示例的结构体实现： #

trait SomeTrait {
    type MethodOutput;
    type Output;
    fn method(&self, i: usize) -> Self::MethodOutput;
    fn other_method(&self, res: Self::MethodOutput) -> Self::Output;
}

struct IteratorMaker<'a, T> {
    t: &'a T,
}

impl<'a, T> FnMut(usize) -> <T as SomeTrait>::Output for IteratorMaker<'a, T>
where T: SomeTrait
{
    fn call_mut(&mut self, i: usize) -> <T as SomeTrait>::Output {
        let res = self.t.method(i);
        self.t.other_method(res)
    }
}

fn make_iterator<'a, T>(t: &'a T) -> IteratorMaker<'a, T>
where T: SomeTrait
{
    // 复杂逻辑...
  
    IteratorMaker { t }
}

调用时和闭包完全一致：maker(5)即可执行逻辑，同时结构体还能添加其他方法扩展功能。

三、针对实际场景的优化 #

你的iter_concentric_rings示例中，可把重复的闭包逻辑提取成辅助函数或结构体，避免重复编写：

方案1：提取闭包生成函数 #

// 假设你的Mesh类型定义如下，根据实际情况调整
struct Mesh<V, E, F> { /* ... */ }

// 提取重复的闭包逻辑为辅助函数
fn vert_id_mapper<'a, V, E, F>(mesh: &'a Mesh<V, E, F>) -> impl Fn(usize, &u32) -> impl Iterator<Item = u32> + 'a
where
    V: Clone + Debug,
    E: Clone + Debug,
    F: Clone + Debug,
{
    move |_depth, &id| {
        let v = unsafe { (*mesh).vert_handle(id) };
        v.iter_verts().map(|h| h.id())
    }
}

// 原方法简化为：
pub fn iter_concentric_rings<'a>(&'a self, depth: usize) -> BFSIterator<impl Iterator<Item = u32>>
where
    V: Clone + Debug,
    E: Clone + Debug,
    F: Clone + Debug,
{
    BFSIterator::new(self.id(), vert_id_mapper(self.mesh))
}

方案2：用结构体封装逻辑 #

struct VertIdMapper<'a, V, E, F> {
    mesh: &'a Mesh<V, E, F>,
}

impl<'a, V, E, F> Fn(usize, &u32) -> impl Iterator<Item = u32> for VertIdMapper<'a, V, E, F>
where
    V: Clone + Debug,
    E: Clone + Debug,
    F: Clone + Debug,
{
    extern "rust-call" fn call(&self, args: (usize, &u32)) -> impl Iterator<Item = u32> {
        let (_depth, &id) = args;
        let v = unsafe { (*self.mesh).vert_handle(id) };
        v.iter_verts().map(|h| h.id())
    }
}

pub fn iter_concentric_rings<'a>(&'a self, depth: usize) -> BFSIterator<impl Iterator<Item = u32>>
where
    V: Clone + Debug,
    E: Clone + Debug,
    F: Clone + Debug,
{
    BFSIterator::new(self.id(), VertIdMapper { mesh: self.mesh })
}

关键总结 #

• 闭包返回：用impl Fn(...) -> ... + 'lifetime实现，必须标注捕获变量的生命周期。
• 可调用结构体：适合需要明确类型或扩展功能的场景，把上下文存入字段后实现Fn系列trait即可。
• 避免重复：将通用闭包逻辑提取为辅助函数或结构体，在需要的地方直接复用，无需重复编写。

内容的提问来源于stack exchange，提问作者Makogan