How am I able to mutate an immutable set? - rust

Question

This is my code.
I am trying to create a Hashmap with i32 as keys and HashSets as values. But when I compile I get a warning that the variable(HashSet) does not need to be mutable. But I am clearly inserting values to the HashSet.
use std::collections::*;
fn main() {
let mut map = HashMap::new();
for i in 0..3 {
// the warning will disappear if I remove the 'mut' keyword
let mut set = HashSet::new();
map.insert(i, set);
}
for (i, set) in &mut map {
for j in *i..(i+5) {
//here I am inserting values to the hashset , therefore set has to be mutable
set.insert(j);
}
}
for (i, set) in &map {
println!("{i} : {:?}", set);
}
}
The warning that I get.
Compiling playground v0.0.1 (/playground)
warning: variable does not need to be mutable
--> src/main.rs:6:13
|
6 | let mut set = HashSet::new();
| ----^^^
| |
| help: remove this `mut`
|
= note: `#[warn(unused_mut)]` on by default
warning: `playground` (bin "playground") generated 1 warning
Finished dev [unoptimized + debuginfo] target(s) in 2.84s
Running `target/debug/playground`
The code compiles fine if I remove the mut keyword. You can try running it on Rust Playground as I did.
I tried to insert elements to an immutable set and I was not able to.
use std::collections::*;
fn main() {
let set = HashSet::new();
set.insert(1);
set.insert(2);
set.insert(3);
println!("{:?}", set);
}
Compilation Error
Compiling playground v0.0.1 (/playground)
error[E0596]: cannot borrow `set` as mutable, as it is not declared as mutable
--> src/main.rs:5:5
|
4 | let set = HashSet::new();
| --- help: consider changing this to be mutable: `mut set`
5 | set.insert(1);
| ^^^^^^^^^^^^^ cannot borrow as mutable
error[E0596]: cannot borrow `set` as mutable, as it is not declared as mutable
--> src/main.rs:6:5
|
4 | let set = HashSet::new();
| --- help: consider changing this to be mutable: `mut set`
5 | set.insert(1);
6 | set.insert(2);
| ^^^^^^^^^^^^^ cannot borrow as mutable
error[E0596]: cannot borrow `set` as mutable, as it is not declared as mutable
--> src/main.rs:7:5
|
4 | let set = HashSet::new();
| --- help: consider changing this to be mutable: `mut set`
...
7 | set.insert(3);
| ^^^^^^^^^^^^^ cannot borrow as mutable
For more information about this error, try `rustc --explain E0596`.
error: could not compile `playground` due to 3 previous errors
So why is the compiler saying that the variable set does not need to be declared mutable?

Answer 1

Immutability in Rust is not the same as constantness of C++ if you are owning the object. Owned things are always mutable, because, why not? You are the owner. You can mutate. Mutability comes close to C++ const when we are talking about borrowing.
So when you are creating a set with let set = HashSet::new();, then the variable name set is immutable. But the object created is mutable. And the insert function takes the ownership of the set, and so it can mutate.
A more concise example to see this may be:
let set: HashSet<i32> = HashSet::new();
let mut set2 = set;
You can always move an immutable object that you own into a mutable, which effectively only renames it and makes mutable (no copy or clone here).
While, for references, the constant correctness is held:
let mut set: HashSet<i32> = HashSet::new();
let set_ref: &HashSet<i32> = &set;
let set_mutref: &mut HashSet<i32> = set_ref; // compile error
// ^^^^^^^ types differ in mutability

Answer 2

TLDR: when you call map.insert(set) you pass ownership (and therefore mutability) from set to map.
Longer answer:
The mut in let mut set = HashSet::new(); gives the following extra capabilities:
reassignment - you can write set = other_hash_set; to reassign the value
mutable referencing - you can write &mut set to get a mutable reference to the set
When you call set.insert(something) (when set has type HashSet, that is transformed by the compiler to HashSet::insert(&mut set, something), which clearly uses option 2 from above, so the mut keyword would be needed.
But your code never does that. in your loop, you write for (i, set) in &mut map. In this case, because &mut HashMap<K, V> implements IntoIterator, this works, and the type of each element is (&K, &mut V). So set here has type &mut HashSet<i32>, so the mut keyword on the binding isn't needed.
I like to think of mut here as "part of the name of the variable". This explains why you can do the following:
let mut i = 5;
let j = i;
let mut k = j;
It's also worth remembering that mutability in Rust often doesn't have the same traps that it does in other langauges.
If you're working with references, the mutability is enforced how you'd expect. But if you're working with owned data, it's not possible for there to be some leftover references that have the data change underneath them. Once you're operating on owned data, you know noone else has a reference.