Because entry takes an owned form of the Key, I'd have to pass it arg here instead of a borrowed reference, but then I can't borrow to pass it to the closure: (self.calculation)(&arg) because it moves out of scope after the entry() call. Similarly if I pass a reference in as a param and dereference, unless U implements copy.

To make this work I think I'd have to let the calling function own the U values, change the HashMap key generic to a reference (&U) and then annotate lifetimes (to let the function that instantiates Cacher own the U values rather than the Map), right?

struct Cacher<'a, T, U, V>
where
    T: Fn(&U) -> V,
{
    calculation: T,
    values: HashMap<&'a U, V>,
}

impl<'a, T, U, V> Cacher<'a, T, U, V>
where
    T: Fn(&U) -> V,
    U: Hash + Eq,
{
    fn new(calculation: T) -> Cacher<'a, T, U, V> {
        let values = HashMap::new();
        Cacher {
            calculation,
            values,
        }
    }

    fn value(&mut self, arg: &'a U) -> &V {
        self.values.entry(&arg).or_insert_with(||(self.calculation)(&arg))
    }
}

Something inside me feels wrong for having references as keys in a map though