如何在不使用Box的情况下将impl trait返回值存入结构体？

针对你的需求——不使用堆分配、保留惰性迭代、处理匿名闭包生成的迭代器——可以通过泛型结构体捕获匿名类型或者借助type_alias_impl_trait特性来实现，完全符合你的约束条件。

方案1：泛型结构体包裹迭代逻辑 #

核心思路是把原函数中的迭代逻辑封装到自定义结构体里，用泛型参数捕获匿名的迭代器类型，同时为结构体实现Iterator trait保持惰性。

步骤1：定义Item结构体 #

先把原返回元组(u64, impl Iterator<Item=X>, Other, Structs)替换为命名结构体，用泛型捕获内部的匿名迭代器：

// 假设Other、Structs、X都是已定义的类型
struct IterItem<I>
where
    I: Iterator<Item = X>,
{
    count: u64,
    sub_iter: I,
    other: Other,
    structs: Structs,
}

步骤2：定义外层迭代器结构体 #

再定义一个持有迭代状态的外层结构体，负责生成IterItem：

struct OuterIter<'a> {
    input_iter: std::slice::Iter<'a, InputItem>, // 替换为你实际遍历的Input内部迭代器
    current_idx: u64,
}

impl<'a> OuterIter<'a> {
    fn new(input: &'a Input) -> Self {
        OuterIter {
            input_iter: input.items.iter(), // 对应原函数中遍历Input的逻辑
            current_idx: 0,
        }
    }
}

步骤3：为结构体实现Iterator trait #

实现Iterator trait，在next方法中按需生成每个IterItem，包括内部的匿名迭代器：

impl<'a> Iterator for OuterIter<'a> {
    // 用impl Iterator捕获内部匿名迭代器类型
    type Item = IterItem<impl Iterator<Item = X> + 'a>;

    fn next(&mut self) -> Option<Self::Item> {
        self.input_iter.next().map(|item| {
            let idx = self.current_idx;
            self.current_idx += 1;
            
            // 这里的sub_iter是闭包或其他方式生成的匿名迭代器
            let sub_iter = item.generate_sub_iter();
            
            IterItem {
                count: idx,
                sub_iter,
                other: item.other.clone(),
                structs: item.structs.clone(),
            }
        })
    }
}

步骤4：修改原函数返回类型 #

现在函数h可以直接返回这个具体的结构体：

fn h(input: &Input) -> OuterIter<'_> {
    OuterIter::new(input)
}

方案2：使用type_alias_impl_trait简化代码（Rust 1.65+） #

如果你的Rust版本在1.65以上，可以启用type_alias_impl_trait稳定特性，用类型别名隐藏内部的匿名迭代器类型，让代码更简洁：

#![feature(type_alias_impl_trait)]

// 用类型别名捕获匿名迭代器类型
type SubIter<'a> = impl Iterator<Item = X> + 'a;

struct IterItem<'a> {
    count: u64,
    sub_iter: SubIter<'a>,
    other: Other,
    structs: Structs,
}

struct OuterIter<'a> {
    input_iter: std::slice::Iter<'a, InputItem>,
    current_idx: u64,
}

impl<'a> OuterIter<'a> {
    fn new(input: &'a Input) -> Self {
        OuterIter {
            input_iter: input.items.iter(),
            current_idx: 0,
        }
    }
}

impl<'a> Iterator for OuterIter<'a> {
    type Item = IterItem<'a>;

    fn next(&mut self) -> Option<Self::Item> {
        self.input_iter.next().map(|item| {
            let idx = self.current_idx;
            self.current_idx += 1;
            
            let sub_iter = item.generate_sub_iter();
            
            IterItem {
                count: idx,
                sub_iter,
                other: item.other.clone(),
                structs: item.structs.clone(),
            }
        })
    }
}

fn h(input: &Input) -> OuterIter<'_> {
    OuterIter::new(input)
}

方案优势 #

• 完全无堆分配，适配no_std环境；
• 保留惰性迭代特性，只有在调用next时才会执行计算；
• 无需展开闭包，匿名迭代器类型被结构体的泛型或类型别名捕获；
• 返回类型是具体的结构体，满足你转换返回类型的需求。

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