To provide some background, I am writing a parser that creates objects that reference the text from some &'a str, where 'a ties all objects to the lifetime of that string. While parsing, I do some lookups to get previously-parsed items by name, which are stored in a HashMap that holds objects that are tied to the lifetime of the parsed string.

Previously, I was using a &str as the identifier, which worked. Here’s a simplified example of what I had previously, which successfully compiled:

use std::collections::HashMap;

struct ReturnType<'a> {
    key: &'a str,
    value: &'a str
}

struct App<'a> {
    // Key type is &'a str
    map: HashMap<&'a str, &'a str>,
}

impl<'a> App<'a> {
    // Note that I don't have to specify the lifetime of `key` because it's only used for hashing;
    // the return type does not (and shouldn't) capture the lifetime of `key`, since it's returning
    // a value that comes from `self.map`
    pub fn lookup_value(&self, key: &str) -> Option<ReturnType<'a>> {
        self.map.get_key_value(key).map(|(k, v)| ReturnType { key: k.clone(), value: v })
    }
}

fn lookup<'a> (app: &'a App) -> Option<ReturnType<'a>> {
    // Note that I'm calling lookup_value referencing a value with a lifetime shorter than 'a
    let key = String::from("te");
    app.lookup_value(&key)
}

fn main() {
    let root = "testing";

    let app = App {
        map: HashMap::from([(&root[0..2], root)]),
    };

    lookup(&app);
}

However, I recently replaced &'a str in the HashMap key with a new wrapper type, StrRef<'a> which simply wraps around the same &'a str that was previously used. However, now it doesn’t compile:

use std::collections::HashMap;

#[derive(Clone, Hash, PartialEq, Eq)]
struct StrRef<'a> {
    value: &'a str,
}

struct ReturnType<'a> {
    key: StrRef<'a>,
    value: &'a str
}

struct App<'a> {
    // Key type is StrRef<'a>
    map: HashMap<StrRef<'a>, &'a str>,
}

impl<'a> App<'a> {
    // I have tried `StrRef` and `StrRef<'b>` and all have the same error
    pub fn lookup_value(&self, key: &StrRef) -> Option<ReturnType<'a>> {
        // Error: explicit lifetime required in the type of `key`; lifetime `'a` required
        self.map.get_key_value(key).map(|(k, v)| ReturnType { key: k.clone(), value: v })
    }
}

fn lookup<'a> (app: &'a App) -> Option<ReturnType<'a>> {
    let key = String::from("te");
    app.lookup_value(&StrRef { value: &key })
}

fn main() {
    let root = "testing";

    let app = App {
        map: HashMap::from([(StrRef { value: &root[0..2] }, root)]),
    };

    lookup(&app);
}

I have tried providing key to the method as type StrRef and &StrRef but it doesn’t compile, with the error shown in the code snippet above:

error[E0621]: explicit lifetime required in the type of `key`
  --> src/stack_overflow.rs:20:9
   |
19 |     pub fn lookup_value(&self, key: &StrRef) -> Option<ReturnType<'a>> {
   |                                     ------- help: add explicit lifetime `'a` to the type of `key`: `&stack_overflow::fails::StrRef<'a>`
20 |         self.map.get_key_value(key).map(|(k, v)| ReturnType { key: k.clone(), value: v })
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ lifetime `'a` required

The issue is that I am not able to assign the lifetime 'a to StrRef because I need to be able to provide a temporary StrRef to the lookup (where its inner &str composed from a format!()-ed string). I’m confused why the compiler seems to be capturing the lifetime of StrRef in the return type when it’s only being used for hashing? I’m also confused why this works with a &str but not with StrRef.