锈不能以可变的形式借用(变量)，因为它也是不可变的借入。

Question

我遇到过类似于milion时间的类似错误，通常在有问题的代码周围放置大括号是有效的，但是我遇到了相当奇怪的情况：

fn breadth_first_index(
    root: CargoCrateVersionNode,
    redis_connection: &mut Connection,
    show_dev_dependencies: bool,
    show_build_dependencies: bool,
) {
    let mut already_included_versions = vec![root.ccv_version_id];
    let mut dependency_tree: Vec<(Option<DependsOnEdge>, CargoCrateVersionNode)> =
        vec![(None, root)];

    let mut i = 0;
    while i < dependency_tree.len() {
        let (edge_to_current_dependency, current_dependency) = &dependency_tree[i];

        let mut command =
            format!("match (main:CargoCrateVersion)-[edge:depends_on]->(connected) where main.ccv_version_id = {} and (edge.doe_kind = 0", current_dependency.ccv_version_id);
        if show_dev_dependencies {
            command.push_str(" or edge.doe_kind = 2");
        }
        if show_build_dependencies {
            command.push_str(" or edge.doe_kind = 1");
        }
        command.push_str(" )");
        command.push_str(" return edge, connected");

        let redis_answ = redis_connection.graph_query(GRAPH_NAME, command).unwrap();
        let mut parsed_dependencies =
            CargoCrateVersionNode::parse_bulk(&redis_answ.data, "connected").unwrap();
        let mut parsed_edges = DependsOnEdge::parse_bulk(&redis_answ.data, "edge").unwrap();

        while !parsed_dependencies.is_empty() {
            let dependency = parsed_dependencies.remove(0);
            let edge = parsed_edges.remove(0);

            if already_included_versions.contains(&dependency.ccv_version_id) {
                continue;
            }
            // This if let causes the error.
            // I've tried putting curly braces around this block of code, however I was unsucesfull.
            if let Some(edge_to_current) = &edge_to_current_dependency {
                if edge_to_current.doe_optional {
                    if let Some(edge_features) = &edge_to_current.doe_with_features {
                        println!("{:?}", edge_features);
                    }
                }
            }

            already_included_versions.push(dependency.ccv_version_id);
            dependency_tree.push((Some(edge), dependency));
        }
        i += 1;
    }
    println!("---- Dependency tree ----");
    for l in dependency_tree {
        println!("{:?}", l.1);
    }
}

我知道易变性和生命周期，但是我不明白为什么在我的情况下会有错误。我用的是锈菌1.63和生锈版2021。

我得到了以下错误

226 |         let (edge_to_current_dependency, current_dependency) = &dependency_tree[i];
    |                                                                 --------------- immutable borrow occurs here...
253 |                 if let Some(edge_to_current) = edge_to_current_dependency {
    |                                                -------------------------- immutable borrow later used here
...
262 |             dependency_tree.push((Some(edge), dependency));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable borrow occurs here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `package_finder` due to previous error

我知道发生了什么。我正在获取对可变列表中元素的引用，然后实现对此引用的不可变引用，同时在之后仍然对列表进行变异。我试图通过在if let语句周围添加花括号来解决这个问题，但是我仍然得到了相同的错误。我觉得这段代码应该在放置花括号后编译，但如果让的话，它不会编译。我是这么问的，因为我(有点天真)认为这是锈蚀编译器内部工作的错误。

编辑:我能够通过将有问题的行替换为对数组的dirrect访问来解决这个问题，但是无论如何，这并不理想。我觉得这确实是编译器内部的错误，对吗？

if let Some(edge_to_current) = &dependency_tree[i].0 {}

Answer 1

编译器中没有错误(至少，您所呈现的代码是这样的)。问题是，你仍然不熟悉借贷和拥有锈菌的规则。

我想你会喜欢读这一本：https://doc.rust-lang.org/book/ch04-00-understanding-ownership.html

但是，解决您的错误，这一行：let (edge_to_current_dependency, current_dependency) = &dependency_tree[i];

您正在破坏共享引用后面的元素。换句话说，您的let语句包含引用。

您可以借用(只是&)使用&dependency_tree的向量，然后访问它上的元素。没必要这么做。只是要访问的元素的take ownership (意思是，删除&)。

有一点:围绕if let的花括号不能解决任何问题。您只是在创建一个内部作用域，但是再次访问一个共享引用。