Rust 从函数返回递归迭代器

我有一个功能：

---

关于如何使用

子体\u iter

功能有什么想法吗？

。要

pub fn subjections\u iter（self，from:Tree）->Box{

？@rampion，它将消耗

self

，表面上看起来并不需要，特别是考虑到引入临时（如我的评论中所示）“解决”这个问题。@rampion，如果我只更改

子体的签名

use std::iter;

#[derive(Clone)]
struct Tree {
    value: String,
    children: Vec<Tree>,
}

struct NoClone;

impl NoClone {
    pub fn children(&self, from: &Tree) -> Vec<Tree> {
        from.children.clone()
    }

    pub fn descendants_vec<'a>(&'a self, from: Tree) -> Vec<Tree> {
        let children = self.children(&from);
        iter::once(from)
            .chain(children.into_iter().flat_map(|child| self.descendants_vec(child)))
            .collect::<Vec<Tree>>()
    }

    pub fn descendants_iter<'a>(&'a self, from: Tree) -> Box<Iterator<Item = Tree> + 'a> {
        let children = self.children(&from);
        Box::new(iter::once(from)
                     .chain(children.into_iter().flat_map(move |child| {
                                                              self.descendants_iter(child)
                                                          })))
    }
}

fn main() {
    //println!("Flattened (Iter): {:?}", mapped_iter());
    println!("Flattened (Vec): {:?}", mapped_vec());
}

fn tree() -> Tree {
    let tree_a = Tree {
        value: "a".to_owned(),
        children: Vec::new(),
    };

    let tree_b = Tree {
        value: "b".to_owned(),
        children: Vec::new(),
    };

    let tree_c = Tree {
        value: "c".to_owned(),
        children: Vec::new(),
    };

    Tree {
        value: "abc".to_owned(),
        children: vec![tree_a, tree_b, tree_c],
    }
}

/*fn mapped_iter() -> Vec<String> {
    let tree = tree();
    let no_clone = NoClone;
    no_clone.descendants_iter(tree).map(|x| x.value).collect::<Vec<String>>()
}*/

fn mapped_vec() -> Vec<String> {
    let tree = tree();
    let no_clone = NoClone;
    no_clone.descendants_vec(tree)
        .into_iter()
        .map(|x| x.value)
        .collect::<Vec<String>>()
}