Why does SimpleComponent take in &Self::Root, but SimpleAsyncComponent takes in Self::Root?

[hwittenborn]

I was migrating some components from using SimpleComponent to using SimpleAsyncComponent, and was greeted with this pretty confusing compiler error (at least until I found the solution):

error[E0195]: lifetime parameters or bounds on method `init` do not match the trait declaration
  --> src/launch.rs:37:14
   |
37 |       async fn init(
   |  ______________^
38 | |         init: Self::Init,
39 | |         root: &Self::Root,
40 | |         sender: AsyncComponentSender<Self>,
41 | |     ) -> AsyncComponentParts<Self> {
   | |_____^ lifetimes do not match method in trait

Changing root: &Self::Root to root: Self::Root fixed the issue, but this wasn't apparent until I manually checked the trait definitions for both.

The page in the book talking about async components made me believe that I wouldn't have to think about it:

Asynchronous components and factories are almost identical compared to regular components and factories.
The only major difference is that they have asynchronous init, update and update_cmd methods.
This allows you to await almost everywhere from within the component.

If there's some internal reason that root requires Self::Root instead of &Self::Root I think it'd be important to note, as a spent a hot minute trying to figure out what went wrong while swapping out the trait being used.

[AaronErhardt]

I think this is because passing &Self::Root to an async method doesn't work due to lifetimes. Most of the time you don't need an owned root though, so regular components pass just a reference.
I think, it's probably a good idea to unify this by passing Self::Root in all cases (it just needs a cheap .clone() call internally anyway). What do you think?

[hwittenborn]

I think, it's probably a good idea to unify this by passing Self::Root in all cases (it just needs a cheap .clone() call internally anyway). What do you think?

I'd definitely prefer that, at least from the perspective of a new user trying to figure out what was going wrong. I know that GTK widgets are reference counted (afaik), so I wouldn't think there'd be much overhead (or at least not enough to be noticeable, especially compared to the time used in other parts of an application like rendering the UI itself).

I haven't done any bench testing on that stuff, but in terms of ergonomics while switching between the two I definitely like both simply taking Self::Root.