Eu tenho o seguinte código:

struct Baz {
    x: usize,
    y: usize,
}

struct Bar {
    baz: Baz,
}

impl Bar {
    fn get_baz_mut(&mut self) -> &mut Baz {
        &mut self.baz
    }
}

struct Foo {
    bar: Bar,
}

impl Foo {
    fn foo(&mut self) -> Option<&mut Baz> {
        for i in 0..4 {
            let baz = self.bar.get_baz_mut();
            if baz.x == 0 {
                return Some(baz);
            }
        }
        None
    }
}

Rust Playground

Falha ao compilar com:

error[E0499]: cannot borrow `self.bar` as mutable more than once at a time
  --> src/main.rs:23:23
   |
23 |             let baz = self.bar.get_baz_mut();
   |                       ^^^^^^^^ mutable borrow starts here in previous iteration of loop
...
29 |     }
   |     - mutable borrow ends here

No entanto, se eu voltarSome(baz.x) deFoo::foo (e altere o tipo de retorno paraOption<usize>), o código é compilado. Isso me faz acreditar que o problema não está no loop, embora o compilador pareça indicar isso. Mais especificamente, acredito que a referência mutável localbaz ficaria fora do escopo na próxima iteração do loop, fazendo com que isso não fosse um problema. Qual é o problema da vida útil com o código acima?

As seguintes perguntas são semelhantes:

No entanto, eles lidam com vidas explicitamente declaradas (e especificamente essas vidas explícitas fazem parte da resposta). Meu código omite essas vidas úteis, portanto removê-las não é uma solução.