Unable to understand HashMap issue

[krishnatorque]

Code

lazy_static! {
    static ref PATHS: HashMap<String, String> = HashMap::new();
}

pub fn add (path: Path) {
    PATHS.insert("mid".to_string(), path);
}

Error

cannot borrow data in a dereference of `PATHS` as mutable
trait `DerefMut` is required to modify through a dereference, but it is not implemented for `PATHS`

[RedDocMD]

This code cannot exist in Rust since it seems to me that PATHS is a global and globals cannot be declared with let in Rust.

[krishnatorque]

I have updated the code.
Sorry I am new to rust

[erelde]

Globals in Rust can't be safely mutably borrowed. You either have to redesign your application to avoid global state, or use some type allowing internal mutation (example: Mutex). I recommand you go with the first approach : avoid global state.

[RedDocMD]

Yes, so you see that PATHS is not declared as mut and cannot be borrowed as mut.
If you want mutability, you have to wrap it in a type that gives you interior mutability. For example a Mutex.

[krishnatorque]

Thank you so much.
A small example will be very helpful.

[RedDocMD]

Something like:

lazy_static! {
    static ref PATHS: Mutex<HashMap<String, String>> = Mutex::new(HashMap::new());
}

pub fn add (path: Path) {
    let paths = PATHS.lock();
    paths.insert("mid".to_string(), path);
}

[krishnatorque]

Awesome
Thank you so much

[krishnatorque]

Hi, Thank you for your reply.

I was unable to find any solution to avoid global variable.
Can you please give me some example from this snippet so that I can avoid it.

[erelde]

For example, in the context calling add :

// you currently have something like :
add(value);
// instead do :
let mut map = HashMap::new();
add(&mut map, value);

Avoiding global state is generally very simple.

[Michael-F-Bryan]

@krishnatorque

I was unable to find any solution to avoid global variable.

The typical strategy is to pass the shared state to each function as an argument. You can also store the thing in a struct so it is available as self.whatever.

If it starts feeling cumbersome to pass all these shared objects around via arguments I normally interpret that as my code saying "maybe you are sharing too much state here and should refactor your code to be less coupled?"