Rust 多个可变自借自方法调用

Question

I am learning Rust. For my first program, I wrote this code to maintain data about a partial ordering:

use std::collections::{HashMap, HashSet};

struct Node {
    num_before: usize,
    successors: HashSet<String>,
}

impl Node {
    fn new() -> Node {
        Node {
            num_before: 0,
            successors: HashSet::new(),
        }
    }
}

pub struct PartialOrdering {
    node: HashMap<String, Node>,
}

impl PartialOrdering {
    pub fn new() -> PartialOrdering {
        PartialOrdering {
            node: HashMap::new(),
        }
    }

    pub fn get_node(&mut self, name: &String) -> &mut Node {
        self.node.entry(name.clone()).or_insert_with(Node::new)
    }

    pub fn add_order(&mut self, before: &String, after: &String) {
        let mut before_node = self.get_node(before);
        if after != before {
            let mut after_node = self.get_node(after);
            if before_node.successors.insert(after.clone()) {
                after_node.num_before += 1;
            }
        }
    }
}

Compiling this code produces this error:

error[E0499]: cannot borrow `*self` as mutable more than once at a time
  --> main.rs:35:25
   |
33 |         let before_node = self.get_node(before);
   |                           ---- first mutable borrow occurs here
34 |         if after != before {
35 |             let mut after_node = self.get_node(after);
   |                                  ^^^^ second mutable borrow occurs here
36 |             if before_node.successors.insert(after.clone()) {
   |                ---------------------- first borrow later used here

Admittedly I am new to the Rust borrowing rules, but this problem has me stumped. Please tell me what I am doing wrong, and how can I fix it?

Answer 1

The problem is that in Rust it is forbidden to take more than one mutable reference ( &mut ) to an object at a time (see here for details). Your get_node() takes &mut self and uses it to obtain an &mut Node contained in self (where self is a PartialOrdering ). This causes the mutable borrow of self to exist for as long as the value returned by get_node() exists, preventing other calls to get_node() . This means that you can't have before_node: &mut Node and after_node: &mut Node in the same scope, unfortunately.