Storing from inside a loop a borrowed value to container in outer scope?

Question

I set myself a little task to acquire some basic Rust knowledge. The task was:

Read some key-value pairs from stdin and put them into a hashmap.

Answer 1

The lifetime of 'text' is limited to the scope of the loop. The key-value pair that I'm extracting within the loop is therefore also bound to the loops boundaries. Thus, inserting them to the outer map would lead to an dangling pointer since 'text' will be destroyed after each iteration.

Sounds right to me.

Make an "owned copy" of the key value pair.

An owned &str is a String:

map.insert(kv_pair[0].to_string(), kv_pair[1].to_string());

Edit

The original code is below, but I've updated the answer above to be more idiomatic

map.insert(String::from_str(kv_pair[0]), String::from_str(kv_pair[1]));

Answer 2

In Rust 1.1 the function words was marked as deprecated. Now you should use split_whitespace.

Here is an alternative solution which is a bit more functional and idiomatic (works with 1.3).

use std::io::{self, BufRead};
use std::collections::HashMap;

fn main() {
    let stdin = io::stdin();

    // iterate over all lines, "change" the lines and collect into `HashMap`
    let map: HashMap<_, _> = stdin.lock().lines().filter_map(|line_res| {
        // convert `Result` to `Option` and map the `Some`-value to a pair of
        // `String`s
        line_res.ok().map(|line| {
            let kv: Vec<_> = line.split_whitespace().take(2).collect();
            (kv[0].to_owned(), kv[1].to_owned())
        })
    }).collect();

    println!("{}", map.len());
}