Rust HashMap

use std::collections::HashMap;

// Zero-allocation initialization. Explicit type annotations satisfy the compiler.
let mut map: HashMap<String, i32> = HashMap::new();

// Pre-allocating memory for a known lower bound to prevent reallocation overhead.
let mut preallocated_map: HashMap<&str, i32> = HashMap::with_capacity(100);

let key = String::from("k1");
let val = String::from("v1");

let mut map: HashMap<String, String> = HashMap::new();
map.insert(key, val); // `key` and `val` are moved here.

// println!("{}", key); // COMPILER ERROR: value borrowed here after move

let key = String::from("k1");
let mut map: HashMap<&str, i32> = HashMap::new();

// Storing a string slice (reference) instead of an owned String
map.insert(&key, 42); 

// Returns Option<&V>
if let Some(value) = map.get(&"k1") {
    println!("Found: {}", value);
}

// Returns Option<&mut V> for in-place mutation
if let Some(value_mut) = map.get_mut(&"k1") {
    *value_mut += 10;
}

let mut map: HashMap<&str, i32> = HashMap::new();

// Inserts 100 if "k1" does not exist. Returns a mutable reference to the value.
map.entry("k1").or_insert(100);

// In-place mutation using a closure if the key exists, otherwise inserts a default.
map.entry("k1")
    .and_modify(|e| *e += 1)
    .or_insert(1);