Recursion 使用impl trait返回递归迭代器时评估需求的溢出

我试图在Rust中的树结构上迭代深度优先。我认为我有一个非常好的简洁的解决方案，但我无法编译它。从概念上讲，它非常简单：迭代子节点，获取每个子节点的深度优先迭代器，将它们展平，并将当前节点的元数据迭代器链接到它

#[derive(Debug, Eq, PartialEq)]
struct Node {
    metadata: Vec<i64>,
    children: Vec<Box<Node>>,
}

impl Node {
    fn depth_first_metadata_iter(&self) -> impl Iterator<Item = &i64> + '_ {
        self.children
            .iter()
            .map(|child| child.depth_first_metadata_iter())
            .flatten()
            .chain(self.metadata.iter())
    }
}

fn main() {
    let tree = Node {
        metadata: vec![1, 2, 3],
        children: vec![
            Box::new(Node {
                metadata: vec![4, 5],
                children: vec![],
            }),
            Box::new(Node {
                metadata: vec![6, 7],
                children: vec![],
            }),
        ],
    };
    println!(
        "{:?}",
        tree.depth_first_metadata_iter().collect::<Vec<&i64>>()
    );
}

（您可以自己在网上查看。）

这可能是一个错误，因为我在

depth\u first\u metadata\u iter

中进行递归调用，返回嵌套迭代器，但如果类似的代码可以在不实现自定义迭代器的情况下工作，那就太好了

我所看到的

E0275

错误的所有其他解决方案（例如）似乎都涉及战略性地将类型注释放置在某个位置-在这里这样做是可能的，还是我尝试的是“不可能的”

如果像这样的代码可以工作的话

取决于你说的“喜欢”是什么意思。这是类似的，可以工作，并且不需要自定义迭代器；从而满足您的所有要求：

fn depth_first_metadata_iter(&self) -> Box<Iterator<Item = &i64> + '_> {
    Box::new({
        self.children
            .iter()
            .flat_map(|child| child.depth_first_metadata_iter())
            .chain(self.metadata.iter())
    })
}

---

.map（x）.flatten（）

=>

flat\u map（x）

添加了指向其他解决方案的链接，感谢“喜欢”到现在为止：）非常感谢您的快速回复！而且duh，显然应该使用

平面地图

。

let a = self.children.iter();
// std::slice::Iter<'_, Box<Node>>

let cls = |child| child.depth_first_metadata_iter();
// Fn(&Box<Node>) -> ?X?

let b = a.flat_map(cls);
// FlatMap<Iter<'_, Box<Node>>, ?X?, Fn(&Box<Node>) -> ?X?>

let d = self.metadata.iter();
// std::slice::Iter<'_, i64>

b.chain(d);
// Chain<FlatMap<Iter<'_, Box<Node>>, ?X?, Fn(&Box<Node>) -> ?X?>, Iter<'_, i64>>

Chain<FlatMap<Iter<'_, Box<Node>>, ?X?, Fn(&Box<Node>) -> ?X?>, Iter<'_, i64>> === ?X?

impl Node {
    fn depth_first_metadata_iter(&self) -> impl Iterator<Item = &i64> + '_ {
        self.x().into_iter()
    }

    fn x(&self) -> Vec<&i64> {
        fn x_inner<'a>(node: &'a Node, v: &mut Vec<&'a i64>) {
            for c in &node.children {
                x_inner(c, v)
            }
            v.extend(&node.metadata);
        }

        let mut v = Vec::new();
        x_inner(self, &mut v);
        v
    }
}