with a manual BuildHasher

build_hasher.rs

use std::hash::{BuildHasher, Hasher};
use std::collections::HashMap;

fn bytes_to_int(bytes: &[u8]) -> usize {
    let l = bytes.len();
    (0..l).fold(0, |sum, i| {
        sum + (1 << ((l - i - 1) * 8)) * bytes[i] as usize
    })
}

pub struct MonoHasher {
    state: u64,
}

impl MonoHasher {
    pub fn new(state: u64) -> Self {
        MonoHasher { state }
    }
}

impl Hasher for MonoHasher {
    fn finish(&self) -> u64 {
        self.state
    }

    fn write(&mut self, bytes: &[u8]) {
        let state: u64 = if bytes.len() > 8 {
            bytes_to_int(&bytes[..])
        } else {
            bytes_to_int(bytes)
        };
        self.state += state;
    }
}

pub struct BuildMonoHasher {}

impl BuildMonoHasher {
    pub fn new() -> Self {
        BuildMonoHasher {}
    }
}

impl BuildHasher for BuildMonoHasher {
    type Hasher = MonoHasher;
    fn build_hasher(&self) -> Self::Hasher {
        Self::Hasher::new(65536_u64)
    }
}

fn main {
  let s = BuildMonoHasher::new();
  let q = HashMap::<&str, u32, BuildMonoHasher>::with_hasher(s); 
}