Rust中如何在trait实现中使用函数类型且避免动态分配？

你遇到的核心问题是：稳定版Rust不允许在IntoIterator的关联类型IntoIter中使用impl Fn(A)->B，但又不想通过Box<dyn Iterator>引入动态分配。以下是两种可行的无动态分配解决方案：

方案1：将无捕获闭包转为函数指针 #

你的闭包|a| get_b(a)没有捕获任何外部环境变量，这类闭包可以直接强制转换为fn(A)->B类型（函数指针）。修改iter方法的返回类型后，就能在IntoIterator中直接指定具体的泛型参数：

struct Foo {
    // 原有字段
}

// 假设A和B是已定义的类型示例
type A = i32;
type B = String;

fn get_b(a: A) -> B {
    a.to_string()
}

struct FooIterator<F: Fn(A) -> B> {
    f: F,
    // 其他迭代器相关字段
}

impl<F> Iterator for FooIterator<F>
where
    F: Fn(A) -> B,
{
    type Item = B;

    fn next(&mut self) -> Option<Self::Item> {
        // 迭代逻辑示例
        Some((self.f)(A::default()))
    }
}

impl Foo {
    // 修改返回类型为具体的函数指针泛型
    fn iter(&self) -> FooIterator<fn(A) -> B> {
        FooIterator {
            f: |a| get_b(a), // 无捕获闭包自动转换为fn指针
        }
    }
}

impl IntoIterator for &Foo {
    type Item = B;
    // 直接指定具体的迭代器类型
    type IntoIter = FooIterator<fn(A) -> B>;

    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }
}

这种方式完全不需要动态分配，函数指针是固定大小的具体类型，符合IntoIterator对关联类型的要求。

方案2：自定义零大小闭包类型 #

如果后续需要让闭包捕获环境变量，可以把闭包逻辑封装成一个自定义的零大小结构体，并手动实现Fn系列 trait：

struct Foo {
    // 原有字段
}

type A = i32;
type B = String;

fn get_b(a: A) -> B {
    a.to_string()
}

// 自定义零大小类型，替代闭包
struct GetB;

// 手动实现Fn系列trait
impl FnOnce<(A,)> for GetB {
    type Output = B;
    extern "rust-call" fn call_once(self, args: (A,)) -> Self::Output {
        get_b(args.0)
    }
}

impl FnMut<(A,)> for GetB {
    extern "rust-call" fn call_mut(&mut self, args: (A,)) -> Self::Output {
        get_b(args.0)
    }
}

impl Fn<(A,)> for GetB {
    extern "rust-call" fn call(&self, args: (A,)) -> Self::Output {
        get_b(args.0)
    }
}

struct FooIterator<F: Fn(A) -> B> {
    f: F,
    // 其他迭代器相关字段
}

impl<F> Iterator for FooIterator<F>
where
    F: Fn(A) -> B,
{
    type Item = B;

    fn next(&mut self) -> Option<Self::Item> {
        Some((self.f)(A::default()))
    }
}

impl Foo {
    fn iter(&self) -> FooIterator<GetB> {
        FooIterator {
            f: GetB,
        }
    }
}

impl IntoIterator for &Foo {
    type Item = B;
    type IntoIter = FooIterator<GetB>;

    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }
}

这种方式同样没有动态分配，还能通过给GetB添加字段来实现环境捕获，灵活性更强。

补充说明 #

稳定版Rust中，impl Trait仅允许出现在函数的参数或返回值位置，不能用于关联类型、结构体字段等场景。而IntoIterator的IntoIter关联类型必须是一个可命名的具体类型，因此直接写impl Fn(A)->B会报错。

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