hashbrown

The `hashbrown` crate in Rust provides highly optimized implementations of hash maps (`HashMap`) and hash sets (`HashSet`). It is renowned for its performance characteristics, often outperforming the standard library's `std::collections::HashMap` and `std::collections::HashSet` in many real-world scenarios due to its use of a different default hasher (FxHash) and advanced memory management techniques. In fact, since Rust 1.36, the standard library's `HashMap` and `HashSet` are internally powered by `hashbrown`.

While `std::collections::HashMap` uses `SipHasher` by default (which provides strong collision resistance and protection against denial-of-service attacks using carefully crafted keys), `hashbrown` primarily uses `FxHasher` by default, which is generally faster for trusted inputs but might be less robust against adversarial inputs. The `hashbrown` crate offers more flexibility to swap out hashers if needed.

Key features and benefits of `hashbrown` include:
* Superior Performance: Benchmarks often show `hashbrown` providing faster insertions, lookups, and deletions compared to other hash map implementations, especially for integer or short string keys.
* Memory Efficiency: It's designed with memory layout and cache performance in mind, leading to efficient memory usage.
* API Compatibility: It provides an API that is largely compatible with `std::collections::HashMap` and `HashSet`, making it easy to swap between them.
* Internal Standard Library Use: Its performance and reliability led to its adoption as the underlying implementation for `std::collections::HashMap` and `HashSet` in modern Rust versions. This means when you use `std::collections::HashMap`, you are implicitly benefiting from `hashbrown`'s optimizations. However, using the `hashbrown` crate directly can provide access to its specific features, default hasher, or custom build flags that might not be exposed through the `std` facade.
* Custom Hashers: Allows users to specify their own hashing algorithm, providing fine-grained control over performance and security trade-offs.

`hashbrown` is an excellent choice when you need the absolute best performance for hash-based collections in your Rust application, especially when dealing with large datasets or performance-critical loops where collection operations are frequent.

// First, add 'hashbrown' to your Cargo.toml dependencies:
// [dependencies]
// hashbrown = "0.14" // Use the latest stable version

use hashbrown::HashMap;

fn main() {
    // 1. Create a new HashMap
    let mut ages: HashMap<&str, u32> = HashMap::new();

    // 2. Insert key-value pairs
    ages.insert("Alice", 30);
    ages.insert("Bob", 24);
    ages.insert("Charlie", 35);
    ages.insert("David", 24); // Duplicate value is fine

    println!("Initial map: {:?}", ages);

    // 3. Retrieve values
    match ages.get("Alice") {
        Some(age) => println!("Alice's age: {}", age),
        None => println!("Alice not found!"),
    }

    // 4. Update a value
    ages.insert("Bob", 25);
    println!("Bob's updated age: {:?}", ages.get("Bob"));

    // 5. Check if a key exists
    if ages.contains_key("Charlie") {
        println!("Charlie is in the map.");
    }

    // 6. Remove a key-value pair
    let removed_age = ages.remove("David");
    println!("Removed David's age: {:?}", removed_age);
    println!("Map after removing David: {:?}", ages);

    // 7. Iterate over key-value pairs
    println!("Iterating over map:");
    for (name, age) in &ages {
        println!("{}: {}", name, age);
    }

    // 8. Get the number of elements
    println!("Number of elements: {}", ages.len());

    // 9. Clearing the map
    ages.clear();
    println!("Map after clearing: {:?}", ages);
    println!("Number of elements after clearing: {}", ages.len());
}