Post History

A `root.components` field need not exist, so I'm not sure what you're hoping for. Also, I don't know if it's an issue with your description or your code, but the code will only return mutable references to "leaf" `Component`s while your description talks about "all descendants". It's not clear if "all descendants" is intended to include `Component`s that have children as well.

As far as I can tell, changing to:

```rust
match root.components().is_empty() {
    true => v.push(root),
    false =>
        root.components_mut()
            .into_iter()
            .for_each(|c| v.append(&mut subtree_mut(c))),
}
```
would compile and work fine other than the unnecessary allocation of the result of `root.components()` which could be fixed by adding a method to `Component` to test for this case without needing to return a `Vec`. This could probably be finessed some other way.

As for

 > Using `root.components_mut()` would create a temporary value owned by the function and trying to return that is an error.

This doesn't matter. This temporary's lifetime isn't really connected to anything. Just the contents of the `Vec` are attached to the relevant lifetimes. In the above code, this is addressed by consuming that intermediate via `into_iter()` and then just passing `c` directly since it is the mutable ref we want.

And for

 > Even if it weren't an error, the recursive logic would be incorrect and several objects would be added more than once.

I don't quite understand what you're getting at here. In the code I list above, mutable references to all "leaf" `Component`s will be returned (assuming no cycles...). If a `Component` is a child of multiple `Component`s, then its "leaves" will be included multiple times. If this is a problem, then it wouldn't be resolved by directly accessing some `component` field. You need to detect visited `Component`s and avoid reprocessing them. This could be done by having a `visited` field that is set or by having a set of visited `Component`s that gets passed along.