Lifetime issue for a struct X (optionally) owning another struct Y that has a reference to X

help
5

Well, I guess I misunderstood the "presence of Drop" (rule 3) above. By the comment here(thanks parasyte!)

The essence of the Drop trait is that the drop method gets called when the value becomes unreachable, but while its members are still valid. This means that the owner of a value that implements Drop must have a strictly shorter lifetime than any references the value contains — those references had better still be valid when the owner goes away.

It should mean that: for a struct T<'a> that implement impl<'a> Drop for T<'a>, it requires the lifetime 'a > the lifetime of T. Without implementing Drop, T<'a> requires a lifetime 'a >= the lifetime of T (rule 2 above).

Thus, the following code requires a lifetime 'x > lifetime of Stream. (Without implementing Drop, lifetime 'x >= lifetime of Stream)

struct Stream<'x> {
    listener: Option<Listener<'x>>
}

...

impl<'x> Drop for Stream<'x> {
    ...
}

and the following code requires a lifetime 'a where 'a >= lifetime of Listener and 'a > the lifetime of Stream

struct Listener<'a> {
    stream: &'a mut Stream<'a>
}

When the following line is executed,

let lis = Listener::new(&mut stm);

it needs to find a lifetime 'a where 'a >= lifetime of Listener and 'a > the lifetime of Stream. The 'a we use here is the lifetime &mut stm. However, this 'a is not greater than(>) the lifetime of Stream, since it's a lifetime of a reference to a Stream.

Without implementing Drop for Stream, lifetime 'a is greater than or equal to (>=) the lifetime of Stream instead of greater than (>) lifetime of Stream. So it can be compiled successfully without implementing Drop, since the lifetime 'a can meet bothe 'a >= lifetime of Listener and 'a >= the lifetime of Stream.

Is that right?