如何在嵌套循环中访问可变迭代

Question

我时不时地在循环中借用（或不借用）可变变量时遇到同样的问题，最后我坐下来编译了一个最小的示例。结果，代码有点傻，但它是我能想到的最短的版本，突出了问题：

struct Association {
    used: bool,
    key: usize,
    value: String,
}

impl Association {
    fn new(key: usize, value: &str) -> Self {
        Association{used: false, key: key, value: value.to_string()}
    }
}

fn find_unused<'a>(data: &'a mut Vec<Association>) -> Option<&'a String> {
    for k in 0.. {
        for a in data {
            if a.key == k && !a.used {
                a.used = true;
                return Some(&a.value);
            }
        }
    }
    None
}

fn main() {
    let mut assoc = vec![
        Association::new(7, "Hello"),
        Association::new(9, "World")
    ];

    println!("{}", find_unused(&mut assoc).unwrap());
    println!("{}", find_unused(&mut assoc).unwrap());
}

这将失败并出现错误，因为 data 之前已移动。如果我改为借它，它会失败，因为它是以前借的。我想准确了解正在发生的事情以及如何解决它。特别是，我不想改变代码的结构，即使它很傻。我不想实现一个解决方法，因为这只是一个最小的例子：请假设循环的嵌套是“正确”的方法，即使它在这里完全愚蠢，它肯定是。

我只想知道如何与借阅检查器沟通这里发生的事情实际上是可以的。我知道一种方法可以做到这一点：

fn find_unused<'a>(data: &'a mut Vec<Association>) -> Option<&'a String> {
    for k in 0.. {
        for j in 0..data.len() {
            if data[j].key == k && !data[j].used {
                data[j].used = true;
                return Some(&data[j].value);
            }
        }
    }
    None
}

这编译没有错误并按预期工作。以我的幼稚理解，应该有一种方法可以用迭代器而不是索引来表达上述内容，我想知道如何做到这一点。

Answer 1

你想要的行为是可能的，如果你：

• 在每个嵌套循环中创建新的可变借用
• 并等待rustc 集成更多Polonius 功能。 （现在可以用cargo +nightly rustc -- -Z polonius 进行实验）。当你等待的时候，你可以使用unsafe，就像在这篇文章中一样：Borrow checker complains about multiple borrowing, when only one will ever occur

保持其余代码相同并专注于这部分，但将 return 注释掉：

fn find_unused<'a>(data: &'a mut Vec<Association>) -> Option<&'a String> {
    for k in 0.. {
        for a in data { // Error - but rustc says what to do here
            if a.key == k && !a.used {
                a.used = true;
                // return Some(&a.value);
            }
        }
    }
    None
}

来自 rustc 的错误消息说明了要做什么以及为什么。通过调用for a in data 中的into_iter() 移动（用完）参数中的可变借用。

rustc 推荐一个可变的重借。这样我们就不会试图借用已经移动的东西。进行更改（并暂时保留 return 注释掉），现在进行以下类型检查：

fn find_unused<'a>(data: &'a mut Vec<Association>) -> Option<&'a String> {
    for k in 0.. {
        for a in &mut *data { // we took rustc's suggestion
            if a.key == k && !a.used {
                a.used = true;
                // return Some(&a.value);
            }
        }
    }
    None
}

如果我们取消注释 return，我们会收到一条错误消息，指出我们返回的值的生命周期与 'a 不匹配。

但如果我们使用cargo +nightly rustc -- -Z polonius 运行，代码类型检查。

@stargateur 建议在comment 中尝试polonius

以下是我对 Polonius 为何提供帮助的猜测：

• 对于当前的 rustc 借用检查器，函数签名中的生命周期在函数体内以相对粗略和简单的方式处理。我认为这里发生的情况是 'a 应该跨越整个函数体，但 a 的新可变借用仅跨越函数体的一部分，因此 Rust 没有统一它们。
• Polonius 跟踪类型中借用的来源。所以它知道&a.value的生命周期来自a，它来自data，它的生命周期是'a，所以Polonius知道return是可以的。

我是基于The Polonius Talk，但The Book 可能是最新的