Lazy Loaded prevented by unexpectedly long lifetime

main.rs

use std::collections::HashMap;

struct MyResult {
    data: u32
}

impl MyResult {
    fn new(input: &String) -> MyResult {
        let mut sum = 0u32;
        // Assume this was an expensive calculation
        for byte in input.as_bytes() {
            sum += *byte as u32;
        }
        MyResult {
            data: sum
        }
    }
}

struct ResultCache {
    results: HashMap<String, MyResult>
}

impl ResultCache {
    fn new() -> ResultCache {
        ResultCache {
            results: HashMap::new()
        }
    }

    fn get_result_for(&mut self, input: &str) -> &MyResult {
        let key = input.to_string();
        {
            // Immutable Borrow here
            if let Some(result) = self.results.get(&key) {
                return result
            };
            // Immutable borrow should end here
        }
        // Prevents mutable borrow here
        let results = &mut self.results;
        let result = MyResult::new(&key);
        results.insert(key.clone(), result);
        results.get(&key).unwrap()
        // Actually ends here
    }
}

fn main() {
    let mut rc = ResultCache::new();
    let result = rc.get_result_for("Hello");
    println!("{}", result.data)
}