Как сгладить древовидную структуру в Rust до Vec<&mut...>?

Это невозможно, если бы вы могли получить 2 изменяемые ссылки на дочерние элементы одновременно, одну через ссылку self, а другую через прямые изменяемые ссылки на дочерние элементы внутри одного и того же Vec.

Итак, предположим, что у вас есть такое дерево:

let mut root = Dir {
    name: "root".into(),
    children: vec![],
};
let child = Dir {
    name: "child".into(),
    children: vec![],
};
root.children.push(child);
// assume this produces [&mut root, &mut root.children[0]]
let refs = root.flatten();
let child1 = &mut refs[0].children[0];
let child2 = refs[1];

child1 и child2 будут изменяемой ссылкой на одно и то же место в памяти, и это считается неопределенным поведением в Rust.

Вы можете сгладить вложенную структуру, если поместите своих детей за общими ссылками и используете внутреннюю изменчивость, чтобы вернуть изменчивость, один из способов сделать это:

use std::{cell::RefCell, rc::Rc};
#[derive(Debug, Clone)]
struct Dir {
    name: String,
    children: Vec<Rc<RefCell<Dir>>>,
}

trait Flatten {
    fn flatten(self, flat: &mut Vec<Self>) where Self: Sized;
}
impl Flatten for Rc<RefCell<Dir>> {
    fn flatten(self, flat: &mut Vec<Self>) {
        flat.push(Rc::clone(&self));
        for child in &self.borrow().children {
            Rc::clone(child).flatten(flat);
        }
    }
}

impl Dir {
    fn new(name: impl Into<String>) -> Rc<RefCell<Self>> {
        Rc::new(RefCell::new(Dir {
            name: name.into(),
            children: Vec::new(),
        }))
    }
}

fn main() {
    let root = Dir::new("root");
    let child = Dir::new("child");
    let sibling = Dir::new("sibling");
    let grandchild = Dir::new("grandchild");
    child.borrow_mut().children.push(grandchild);
    root.borrow_mut().children.extend([child, sibling]);
    let mut refs = Vec::with_capacity(4);
    root.flatten(&mut refs);
    dbg!(refs);
}

Я хотел бы расширить ответ @ cafce25: вы не можете сгладить до Vec<&mut Dir>, потому что это даст вам два способа получить изменяемую ссылку на одно и то же. Один из этих путей проходит через children. Следовательно: вы все еще можете получить Vec<&mut …>, просто он не может включать доступ к children.

Итак, если у вас, например,

#[derive(Debug, Clone)]
struct NodeCommon {
    name: String,
    …
}

#[derive(Debug, Clone)]
struct Dir {
    common: NodeCommon,
    children: Vec<Node>,
}

вы можете получить Vec<&mut NodeCommon> с помощью кода выше. Детская площадка

Хотя я хотел бы спросить: что вы будете делать с этим Vec? Если вы собираетесь перебирать его только для изменения некоторых вещей, было бы несколько расточительно создавать для этого Vec. Более хорошим решением проблемы «абстрактного хождения по дереву» может быть вызов FnMut для каждого Dir:

impl Node {
    fn for_each_dir_mut<'a>(&'a mut self, f: &mut impl FnMut(&mut Dir)) {
        if let Node::Dir(dir) = self {
            f(dir);
            for node in dir.children.iter_mut() {
                node.for_each_dir_mut(f);
            }
        }
    }
}

Детская площадка