Why the life time is equal?

help
1

Hello everyone,
I have the following code and it compiles, showing the lifetime of b, e is same.
Can't figure out why.
Anybody help to make an explaination?

#[cfg(all())]
fn main() {
    fn equal<'a, 'b, T>(s1: &'a mut T, s2: &'b mut T)
    where
        'a: 'b,
        'b: 'a,
        T: 'a,
    {
    }

    let mut a = "1".to_owned();
    {
        let mut b: &mut String = &mut a;

        {
            let mut d = "2".to_owned();
            {
                let mut e: &mut String = &mut d;
                equal(b, e);
            }
        }

        b;
    }
}
2

I think the reason is subtyping, i.e. you can always pass longer-living references (unless there is invariance enforced).

3

Yes, it is invariant, notice s1: &'a mut T, s2: &'b mut T

4

No, &'a mut T is covariant in 'a but invariant in T. (I made that mistake previously too.)

5 Likes
5

Sorry, I forget the invariant rule

6

The code will fail to compile if you work with &mut &'lt T:

fn main() {
    fn equal<'a, 'b, T>(s1: &mut &'a T, s2: &mut &'b T)
    where
        'a: 'b,
        'b: 'a,
        T: 'a,
    {
    }

    let a = "1".to_owned();
    {
        let b: &mut &String = &mut &a;
        {
            let d = "2".to_owned();
            {
                let e: &mut &String = &mut &d;
                equal(b, e);
            }
        }
        b;
    }
}

(Playground)

1 Like