迭代中可变借用冲突？或是Rust生命周期问题？

问题代码 #

struct Thing<'a> {
    slice: &'a [u8],
}

struct ThingGetter {
    buffer: [u8; 10],
    index: usize,
}

impl ThingGetter {
    pub fn next_thing(&mut self) -> Option<Thing> {
        self.index += 1;
        if self.index == 42 {
            return None;
        } else {
            let thing = Thing {
                slice: &self.buffer[..],
            };
            return Some(thing);
        }
    }
}

struct Wrapper {
    getter: ThingGetter,
}

impl Wrapper {
    pub fn get_thing(&mut self) -> Option<Thing> {
        loop {
            if let Some(thing) = self.getter.next_thing() {
                return Some(thing);
            } else {
                continue;
            }
        }
    }
}

编译错误 #

error[E0499]: cannot borrow `self.getter` as mutable more than once at a time
  --> src/thing.rs:31:34
   |
29 |     pub fn get_thing(&mut self) -> Option<Thing> {
   |                      - let's call the lifetime of this reference `'1`
30 |         loop {
31 |             if let Some(thing) = self.getter.next_thing() {
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^ `self.getter` was mutably borrowed here in the previous iteration of the loop
32 |                 return Some(thing);
   |                        ----------- returning this value requires that `self.getter` is borrowed for `'1`

核心困惑 #

将continue;改为return None;即可正常编译，但无法理解为何编译器认为self.getter被多次可变借用——前一次迭代的借用在再次调用next_thing时已经不可访问。

错误原因 #

编译器的借用检查器对循环场景的生命周期推断存在局限性：

1. next_thing的签名被默认推断为：pub fn next_thing<'a>(&'a mut self) -> Option<Thing<'a>>，即返回的Thing持有&mut self的生命周期绑定。
2. 在get_thing的循环中，若某次调用next_thing返回Some(thing)，该Thing的生命周期必须与get_thing的&mut self生命周期'1一致（确保返回值在函数外部仍有效）。
3. 编译器无法证明未返回Thing的迭代结束后，可变借用已完全释放，因此会假设前一次迭代的借用仍存在，与下一次迭代的新借用冲突。

而改为return None;时，函数直接终止，所有借用自动释放，编译器可以确认无冲突。

解决方案 #

通过代码块限制可变借用的作用域，让编译器明确每次迭代的借用在块结束后即释放：

impl Wrapper {
    pub fn get_thing(&mut self) -> Option<Thing> {
        loop {
            // 将next_thing的调用包裹在单独块中，限制借用生命周期
            let opt_thing = {
                self.getter.next_thing()
            };
            match opt_thing {
                Some(thing) => return Some(thing),
                None => continue,
            }
        }
    }
}

这样每次迭代的可变借用仅存在于块内，块结束后借用立即释放，下一次迭代可安全重新借用self.getter。

内容的提问来源于stack exchange，提问作者ccleve