Cacher implementation in Rust

main.rs

use std::collections::{HashMap, hash_map::DefaultHasher};
use std::hash::{Hash, Hasher};
use std::fmt::Display;

fn main() {
    let mut c: Cacher<u32, u32> = Cacher::new(|x| x);
    let v = c.value(3);
    println!("uncached value is: {}", v);
    let v = c.value(3);
    println!("cached value is: {}", v);
}

struct Cacher<T, U>
where
    T: Hash + Display,
{
    calculation: fn(T) -> U,
    cache: HashMap<u64, U>,
}

impl<T, U> Cacher<T, U>
where
    T: Hash + Display,
{
    fn new(calculation: fn(T) -> U) -> Self {
        Self {
            calculation,
            cache: HashMap::new(),
        }
    }

    fn value(&mut self, arg: T) -> &U {
        let mut hasher = DefaultHasher::new();
        arg.hash(&mut hasher);
        let hash = hasher.finish();
        
        if !self.cache.contains_key(&hash) {
            println!("value for arg = {} not konwn yet", &arg);
            let res = (self.calculation)(arg);
            self.cache.insert(hash, res);
        }

        self.cache.get(&hash).unwrap()
    }
}