Rust: Modify value in HashMap while immutably borrowing the whole HashMap

Your current problem is about conflicting mutable and immutable borrows, but there's a deeper problem here. This data structure cannot work for what you're trying to do:

struct MyStruct<'a> {
    value: i32,
    substructs: Option<Vec<Pin<&'a MyStruct<'a>>>>,
}

struct Toplevel<'a> {
    my_structs: HashMap<String, Pin<Box<MyStruct<'a>>>>,
}

Any time a type has a lifetime parameter, that lifetime necessarily outlives (or lives exactly as long as) the values of that type. A container Toplevel<'a> which contains references &'a MyStruct must refer to MyStructs which were created before the Toplevel — unless you're using special tools like an arena allocator.

(It's possible to straightforwardly build a tree of references, but they must be constructed leaves first and not using a recursive algorithm; this is usually impractical for dynamic input data.)

In general, references are not really suitable for creating data structures; rather they're for temporarily “borrowing” parts of data structures.

In your case, if you want to have a collection of all the MyStructs and also be able to add connections between them after they are created, you need both shared ownership and interior mutability:

use std::collections::HashMap;
use std::cell::RefCell;
use std::rc::Rc;

struct MyStruct {
    value: i32,
    substructs: Option<Vec<Rc<RefCell<MyStruct>>>>,
}

struct Toplevel {
    my_structs: HashMap<String, Rc<RefCell<MyStruct>>>,
}

The shared ownership via Rc allows both Toplevel and any number of MyStructs to refer to other MyStructs. The interior mutability via RefCell allows the MyStruct's substructs field to be modified even while it's being referred to from other elements of the overall data structure.

Given these definitions, you can write the code that you wanted:

fn main() {
    let mut toplevel = Toplevel {
        my_structs: HashMap::new(),
    };

    // First pass: add the elements to the HashMap
    toplevel.my_structs.insert(
        "abc".into(),
        Rc::new(RefCell::new(MyStruct {
            value: 0,
            substructs: None,
        })),
    );
    toplevel.my_structs.insert(
        "def".into(),
        Rc::new(RefCell::new(MyStruct {
            value: 5,
            substructs: None,
        })),
    );
    toplevel.my_structs.insert(
        "ghi".into(),
        Rc::new(RefCell::new(MyStruct {
            value: -7,
            substructs: None,
        })),
    );

    // Second pass: for each MyStruct, add substructs
    let subs = vec![
        toplevel.my_structs["abc"].clone(),
        toplevel.my_structs["def"].clone(),
        toplevel.my_structs["ghi"].clone(),
    ];
    toplevel.my_structs["abc"].borrow_mut().substructs = Some(subs);
}

Note that because you're having "abc" refer to itself, this creates a reference cycle, which will not be freed when the Toplevel is dropped. To fix this, you can impl Drop for Toplevel and explicitly remove all the substructs references.

Another option, arguably more 'Rusty' is to just use indices for cross-references. This has several pros and cons:

• Adds the cost of additional hash lookups.
• Removes the cost of reference counting and interior mutability.
• Can have “dangling references”: a key could be removed from the map, invalidating the references to it.

use std::collections::HashMap;

struct MyStruct {
    value: i32,
    substructs: Option<Vec<String>>,
}

struct Toplevel {
    my_structs: HashMap<String, MyStruct>,
}

fn main() {
    let mut toplevel = Toplevel {
        my_structs: HashMap::new(),
    };

    // First pass: add the elements to the HashMap
    toplevel.my_structs.insert(
        "abc".into(),
        MyStruct {
            value: 0,
            substructs: None,
        },
    );
    toplevel.my_structs.insert(
        "def".into(),
        MyStruct {
            value: 5,
            substructs: None,
        },
    );
    toplevel.my_structs.insert(
        "ghi".into(),
        MyStruct {
            value: -7,
            substructs: None,
        },
    );

    // Second pass: for each MyStruct, add substructs
    toplevel.my_structs.get_mut("abc").unwrap().substructs =
        Some(vec!["abc".into(), "def".into(), "ghi".into()]);
}

In your code, you are attempting to modify a value referenced in the vector as immutable, which is not allowed. You could store mutable references in the vector instead, and mutate them directly, like this:

let subs = vec![
    toplevel.my_structs.get_mut("abc").unwrap(),
    toplevel.my_structs.get_mut("def").unwrap(),
    toplevel.my_structs.get_mut("ghi").unwrap(),
];
(*subs[0]).substructs = Some(subs.clone());

However, it's easier (although more expensive) to store clones of the structs instead of references:

let subs = vec![
    toplevel.my_structs.get("abc").unwrap().clone(),
    toplevel.my_structs.get("def").unwrap().clone(),
    toplevel.my_structs.get("ghi").unwrap().clone(),
];
(*toplevel.my_structs.get_mut("abc").unwrap()).substructs = Some(subs);