"Temporary value dropped while borrowed" error after using unwrap()

In the following code, sometimes I only need the first Keymap produced by get_keymaps(). So I figured I could use first(). However, I found out it returns an Option<&T>, so I had to use unwrap() to get the value inside.

#[derive(Debug, Default)]
pub struct Keymap {
    pub key: char,
    pub command: String,
    pub description: String,
    pub prompt: Option<String>,
}

impl Keymap {
    pub fn new<S: AsRef<str>>(key: char, command: S) -> Self {
        let command = command.as_ref().to_owned();
        let description = command.clone();

        Self {
            key,
            command,
            description,
            ..Default::default()
        }
    }
}

fn get_keymaps<'a>() -> Vec<Keymap> {
    vec![Keymap::new('t', "echo 'test'")]
}

fn handle_keymap(keymap: &Keymap) {
    println!("Do something with {:?}", keymap);
}

fn main() {
    let keymap = get_keymaps().first().unwrap();
    handle_keymap(keymap);
}

Rust Playground

But now I'm getting the following error:

error[E0716]: temporary value dropped while borrowed
  --> src/main.rs:33:18
   |
33 |     let keymap = get_keymaps().first().unwrap();
   |                  ^^^^^^^^^^^^^                 - temporary value is freed at the end of this statement
   |                  |
   |                  creates a temporary value which is freed while still in use
34 |     handle_keymap(keymap);
   |                   ------ borrow later used here

I don't quite understand why a temporary value was freed. I'm not very sure what it means. And I don't know how to fix it.

You can imagine that something like

let keymap = get_keymaps().first().unwrap();

actually looks like this:

let keymap = {
    let temporary = get_keymaps();
    temporary.first().unwrap()
};

The call to first borrows from temporary but temporary gets dropped at the end of the block, i.e. the assignment statement. But when you want to use the reference created by first later, it forces temporary to outlive that use causing the compile error. By hoisting the assignment to temporary out of the assignment to keymap, you can create a value that lives long enough (exactly like the compiler message says):

let longer_lived_value = get_keymaps();
let keymap = longer_lived_value.first().unwrap();

Note that the same thing doesn't apply to the call to unwrap. That's because unlike first, which takes self by reference, unwrap takes self by value, taking ownership of the temporary instead of borrowing from it.