You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: hashmaps.rs
    path of file: ./repos/learnrust/rpl/_11_collections/src
    
    the code of the file until where you have to start completion: //
// Rust's HashMap is an ordinary map type that you might already know about from other langs.
//
// -> They are stored on the heap memory.
//
// So Rust's hash map is:
//
//      HashMap<K, V>
//
// HashMap is a generic type:
//
//  -> Keys are of the type `K`, and,
//  -> Values are of type `V`.
//

// first, you need to bring it to this scope.
use std::collections::HashMap;

#[allow(unused)]
pub fn run() {
    // ===================================================================
    // let's create a new hash map.
    // ===================================================================
    let mut reviews = HashMap::new();

    // ===================================================================
    // let's add some game reviews.
    //
    // key   => game name (&str)
    // value => review score (floating-point number)
    // ===================================================================
    reviews.insert("Mass Effect", 7.9);
    reviews.insert("Sam and Max: Hit the Road", 9.5);
    reviews.insert("Beneath a Steel Sky", 9.0);
    reviews.insert("Dune", 8.0);

    {
        // or, you can construct it from these vectors.
        let games = vec!["Mass Effect", "Sam and Max: Hit the Road"];
        let scores = vec![7.9, 9.5];

        // now, all you need is to zip them together into a map.
        let mut reviews: HashMap<_, _> = games.into_iter().zip(scores.into_iter()).collect();
        //                       ^  ^        |                  |
        //                       |_/         v                  v
        //    Guesses the key and value     Keys = &str      Values = float
        //          types automatically  <---------====---------------=====
        //             from the vectors

        // ===================================================================
        // ☝️ into_iter()
        //
        //    Above, each `into_iter()` takes ownership of a vector.
        //
        //    So you can no longer use the games, or scores.
        //
        //          let _ = games.get(0).unwrap();
        //          let _ = scores.get(0).unwrap();
        //
        // ===================================================================
    }

    // ===================================================================
    // let's access the values inside a map
    // ===================================================================
    let mass_effect = reviews.get("Mass Effect");
    println!(
        "They rated Mass Effect with a score of {:?}.",
        mass_effect.unwrap() // unwrap is not cool, you'll see why below.
    );

    // ===================================================================
    // let's check for the existence of keys
    // ===================================================================

    //
    // first, you're going to learn what happens if you try to access
    // a non-existing key.
    //
    let ping_pong = reviews.get("Ping Pong");

    //
    // uncomment the following line and see what happens:
    //
    // println!(
    //     "They rated Ping Pon with a score of {:?}",
    //     ping_pong.unwrap()
    // );
    //

    // now let's learn how to prevent panicking.
    if let None = ping_pong {
        println!("I don't know anything about the Ping Pong game.");
    }
    // ☝️ remember, `if let` is syntactic sugar for `match`.
    //    here, we check if ping_pong is one of the variants of
    //    the Option enum.

    // let's check for an existing game.
    let sam_and_max = "Sam and Max: Hit the Road";
    if let Some(score) = reviews.get(sam_and_max) {
        println!(
            "But they also rated {} with a score of {:?}.",
            sam_and_max, score,
        );
    }
    // ☝️ here, we check if there is "some" value in the value returned
    //    by the `reviews.get(sam_and_max)`.
    //
    //    if there is, Rust binds it to the `score` variable.

    // ===================================================================
    // let's iterate over each key/value pair
    // ===================================================================
    for (key, value) in &reviews {
        println!("-> They rated {} with a score of {}.", key, value);
    }
    // ☝️ remember: borrow, do not unnecessarily own.
    //
    //    if you've used reviews above instead of &reviews,
    //    then you'd be owning, not borrowing.
    //
    //    so, you would no longer be able to use reviews.
    //    it would have been dropped after the loop ends.

    // ==============================================
    
pub fn run() {
    // ===================================================================
    // let's create a new hash map.
    // ===================================================================
    let mut reviews = HashMap::new();

    // ===================================================================
    // let's add some game reviews.
    //
    // key   => game name (&str)
    // value => review score (floating-point number)
    // ===================================================================
    reviews.insert("Mass Effect", 7.9);
    reviews.insert("Sam and Max: Hit the Road", 9.5);
    reviews.insert("Beneath a Steel Sky", 9.0);
    reviews.insert("Dune", 8.0);

    {
        // or, you can construct it from these vectors.
        let games = vec!["Mass Effect", "Sam and Max: Hit the Road"];
        let scores = vec![7.9, 9.5];

        // now, all you need is to zip them together into a map.
        let mut reviews: HashMap<_, _> = games.into_iter().zip(scores.into_iter()).collect();
        //                       ^  ^        |                  |
        //                       |_/         v                  v
        //    Guesses the key and value     Keys = &str      Values = float
        //          types automatically  <---------====---------------=====
        //             from the vectors

        // ===================================================================
        // ☝️ into_iter()
        //
        //    Above, each `into_iter()` takes ownership of a vector.
        //
        //    So you can no longer use the games, or scores.
        //
        //          let _ = games.get(0).unwrap();
        //          let _ = scores.get(0).unwrap();
        //
        // ===================================================================
    }

    // ===================================================================
    // let's access the values inside a map
    // ===================================================================
    let mass_effect = reviews.get("Mass Effect");
    println!(
        "They rated Mass Effect with a score of {:?}.",
        mass_effect.unwrap() // unwrap is not cool, you'll see why below.
    );

    // ===================================================================
    // let's check for the existence of keys
    // ===================================================================

    //
    // first, you're going to learn what happens if you try to access
    // a non-existing key.
    //
    let ping_pong = reviews.get("Ping Pong");

    //
    // uncomment the following line and see what happens:
    //
    // println!(
    //     "They rated Ping Pon with a score of {:?}",
    //     ping_pong.unwrap()
    // );
    //

    // now let's learn how to prevent panicking.
    if let None = ping_pong {
        println!("I don't know anything about the Ping Pong game.");
    }
    // ☝️ remember, `if let` is syntactic sugar for `match`.
    //    here, we check if ping_pong is one of the variants of
    //    the Option enum.

    // let's check for an existing game.
    let sam_and_max = "Sam and Max: Hit the Road";
    if let Some(score) = reviews.get(sam_and_max) {
        println!(
            "But they also rated {} with a score of {:?}.",
            sam_and_max, score,
        );
    }
    // ☝️ here, we check if there is "some" value in the value returned
    //    by the `reviews.get(sam_and_max)`.
    //
    //    if there is, Rust binds it to the `score` variable.

    // ===================================================================
    // let's iterate over each key/value pair
    // ===================================================================
    for (key, value) in &reviews {
        println!("-> They rated {} with a score of {}.", key, value);
    }
    // ☝️ remember: borrow, do not unnecessarily own.
    //
    //    if you've used reviews above instead of &reviews,
    //    then you'd be owning, not borrowing.
    //
    //    so, you would no longer be able to use reviews.
    //    it would have been dropped after the loop ends.

    // ===================================================================
    // let's overwrite a value
    // ===================================================================
    // you can overwrite a value if you re-insert with the same key again.
    reviews.insert("Mass Effect", 8.5);
    // let's pretty print everything in the map.
    println!("{:#?}", reviews);

    // ===================================================================
    // let's insert a value only if there isn't a key with the same name
    // ===================================================================
    reviews.entry("Ping Pong").or_insert(6.0);
    // adds Ping Pong with a score of 6.0

    reviews.entry("Ping Pong").or_insert(8.0);
    // has no effect, reviews has Ping Pong

    println!("{:#?}", reviews);

    // ===================================================================
    // let's create a program to find word frequencies in a str
    // ===================================================================
    let text = "that that exists exists in that that that that exists exists in";

    let mut freqs = HashMap::new();

    for w in text.split_whitespace() {
        // split_whitespaces() returns an iterator that returns string sub-slices
        // from `text`. they don't re-allocate. rust is as efficient as it goes.

        let c = freqs.entry(w).or_insert(0);
        // c            -> becomes 0 if `w` key doesn't exist on the map.
        // entry(w)     -> returns the entry of a key from the hash map.
        // or_insert(0) -> if the key was absent, inserts the key `w`
        //                 with a value of 0.

        *c += 1;
        // otherwise:
        // -> or_insert() returns the existing entry in the map
        //    as a mutable reference (&mut i32).
        // -> so you need to dereference it to get the i32 value.
        // -> finally, we can increment it.
    }
    // since each c goes out of scope after the loop's scope, the map's
    // values can be used afterwards. otherwise, this wouldn't be possible.
    // remember, rust doesn't allow immutable & mutable borrowers co-exist.

    println!("{:?}", freqs);
}