Rust closure to be called on a cache miss
I like what you've done! I don't have too many comments about the content of it, since it looks good. However, you'll see below that I changed the field name value to cache and some of the generic parameter names, just to make things a little clearer. This is just a subjective preference, but I used F for function, K for key, and V for value.

Another thing to note is that in many cases, you don't need to put trait bounds on the parameters for the struct itself. You just need the bounds when you are implementing functions with it, and having the bounds on the struct doesn't save you from having to write the bounds when you use it as a parameter.

If you want to get rid of the Clone bound, you can return a reference to the value now stored within the cache. Here's one possible implementation of that, using HashMap's entry API.

use std::collections::HashMap;
use std::hash::Hash;

struct Cacher&lt;F, K, V&gt; {
    calculation: F,
    cache: HashMap&lt;K, V&gt;,
}

impl&lt;F, K, V&gt; Cacher&lt;F, K, V&gt;
where
    F: Fn(&amp;K) -&gt; V,
    K: Hash + Eq,
{
    fn new(calculation: F) -&gt; Self {
        Cacher {
            calculation,
            cache: HashMap::new(),
        }
    }

    fn value(&amp;mut self, arg: K) -&gt; &amp;V {
        use std::collections::hash_map::Entry;

        match self.cache.entry(arg) {
            Entry::Occupied(occupied) =&gt; occupied.into_mut(),
            Entry::Vacant(vacant) =&gt; {
                let value = (self.calculation)(vacant.key());
                vacant.insert(value)
            }
        }
    }
}