refactor: update hash types and add hasher trait

Cargo.toml

@@ -67,7 +67,7 @@ human-panic = { version = "2.0.2", optional = true }
 metrohash = { version = "1.0.6", optional = true }
 seahash = { version = "4.1.0", optional = true }
 serde_json = { version = "1.0.132", optional = true }
-twox-hash = { version = "1.6.3", optional = true }
+twox-hash = { version = "2.1.0", optional = true }
 
 [dev-dependencies]
 assert_cmd = "2"
@@ -77,6 +77,6 @@ highway = "1.2.0"
 once_cell = "1.20.2"
 serde_json = "1.0.132"
 seahash = "4.1.0"
-twox-hash = "1.6.3"
+twox-hash = "2.1.0"
 predicates = "3.1.2"
 rand = "0.8"

src/fs.rs

@@ -6,7 +6,6 @@ mod hash;
 use crate::ext::{IteratorExt, WalkBuilderAddPaths, WalkParallelForEach};
 use crate::TreeBag;
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
-use std::hash::Hasher;
 use std::path::{Path, PathBuf};
 
 const CHANNEL_SIZE: usize = 8 * 1024;
@@ -19,9 +18,9 @@ pub fn find_dupes_partial<H, P>(
     directories: &[P],
     max_depth: Option<usize>,
     filter: filter::FileFilter,
-) -> TreeBag<u64, PathBuf>
+) -> TreeBag<H::Hash, PathBuf>
 where
-    H: Hasher + Default,
+    H: crate::hasher::Hasher,
     P: AsRef<Path>,
 {
     let mut paths = directories
@@ -55,9 +54,9 @@ where
     .0
 }
 
-fn hash_entry<H>(filter: &filter::FileFilter, entry: ignore::DirEntry) -> Option<(u64, PathBuf)>
+fn hash_entry<H>(filter: &filter::FileFilter, entry: ignore::DirEntry) -> Option<(H::Hash, PathBuf)>
 where
-    H: Hasher + Default,
+    H: crate::hasher::Hasher,
 {
     let path = entry.path();
     let meta = entry
@@ -73,9 +72,9 @@ where
     Some((hash, entry.into_path()))
 }
 
-pub fn dedupe<H>(tree: TreeBag<u64, PathBuf>) -> crate::FileCounter
+pub fn dedupe<H>(tree: TreeBag<H::Hash, PathBuf>) -> crate::FileCounter<H::Hash>
 where
-    H: Hasher + Default,
+    H: crate::hasher::Hasher,
 {
     let (sender, receiver) = crossbeam_channel::bounded(CHANNEL_SIZE);
     rayon::join(
@@ -90,10 +89,10 @@ where
 }
 
 fn process_bucket<H>(
-    sender: &mut crossbeam_channel::Sender<(u64, crate::Path)>,
-    (old_hash, bucket): (u64, Vec<PathBuf>),
+    sender: &mut crossbeam_channel::Sender<(H::Hash, crate::Path)>,
+    (old_hash, bucket): (H::Hash, Vec<PathBuf>),
 ) where
-    H: Hasher + Default,
+    H: crate::hasher::Hasher,
 {
     if bucket.len() == 1 {
         let file = bucket.into_iter().next().unwrap();
@@ -112,9 +111,9 @@ fn process_bucket<H>(
     }
 }
 
-fn rehash_file<H>(file: &Path) -> Result<u64, ()>
+fn rehash_file<H>(file: &Path) -> Result<H::Hash, ()>
 where
-    H: Hasher + Default,
+    H: crate::hasher::Hasher,
 {
     if file.metadata().map(|f| f.len()).unwrap_or(0) < BLOCK_SIZE as _ {
         return Err(());

src/fs/hash.rs

@@ -1,13 +1,12 @@
 use super::BLOCK_SIZE;
 use std::fs::File;
-use std::hash::Hasher;
 use std::io::{self, Read};
 use std::path::Path;
 
 /// Get a checksum of the first 4 KiB (at most) of a file.
-pub fn partial<H>(path: &Path) -> io::Result<u64>
+pub fn partial<H>(path: &Path) -> io::Result<H::Hash>
 where
-    H: Hasher + Default,
+    H: crate::hasher::Hasher,
 {
     let mut file = File::open(path)?;
     let mut buffer = [0u8; BLOCK_SIZE];
@@ -27,18 +26,18 @@ where
 }
 
 /// Get a complete checksum of a file.
-pub fn full<H>(path: &Path) -> io::Result<u64>
+pub fn full<H>(path: &Path) -> io::Result<H::Hash>
 where
-    H: Hasher + Default,
+    H: crate::hasher::Hasher,
 {
     /// Compile time [`Write`](std::io::Write) wrapper for a [`Hasher`](core::hash::Hasher).
     /// This should get erased at compile time.
     #[repr(transparent)]
     struct HashWriter<H>(H);
 
-    impl<H: Hasher> io::Write for HashWriter<H> {
+    impl<H: crate::hasher::Hasher> io::Write for HashWriter<H> {
         fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-            self.0.write(buf);
+            crate::hasher::Hasher::write(&mut self.0, buf);
             Ok(buf.len())
         }
 

src/hasher.rs

@@ -0,0 +1,64 @@
+pub trait Hasher: Default {
+    type Hash: Hash;
+    fn write(&mut self, buf: &[u8]);
+    fn finish(self) -> Self::Hash;
+}
+
+pub trait Hash: PartialEq + Eq + PartialOrd + Ord + Send + Sync + Copy {}
+
+impl<T> Hash for T where T: PartialEq + Eq + PartialOrd + Ord + Send + Sync + Copy {}
+
+impl Hasher for ahash::AHasher {
+    type Hash = u64;
+    fn write(&mut self, buf: &[u8]) {
+        std::hash::Hasher::write(self, buf);
+    }
+    fn finish(self) -> Self::Hash {
+        std::hash::Hasher::finish(&self)
+    }
+}
+
+impl Hasher for highway::HighwayHasher {
+    type Hash = [u64; 4];
+    fn write(&mut self, buf: &[u8]) {
+        use highway::HighwayHash;
+        self.append(buf);
+    }
+
+    fn finish(self) -> Self::Hash {
+        use highway::HighwayHash;
+        self.finalize256()
+    }
+}
+
+impl Hasher for metrohash::MetroHash128 {
+    type Hash = (u64, u64);
+    fn write(&mut self, buf: &[u8]) {
+        std::hash::Hasher::write(self, buf);
+    }
+
+    fn finish(self) -> Self::Hash {
+        self.finish128()
+    }
+}
+
+impl Hasher for seahash::SeaHasher {
+    type Hash = u64;
+    fn write(&mut self, buf: &[u8]) {
+        std::hash::Hasher::write(self, buf);
+    }
+    fn finish(self) -> Self::Hash {
+        std::hash::Hasher::finish(&self)
+    }
+}
+
+impl Hasher for twox_hash::xxhash3_128::Hasher {
+    type Hash = u128;
+    fn write(&mut self, buf: &[u8]) {
+        self.write(buf);
+    }
+
+    fn finish(self) -> Self::Hash {
+        self.finish_128()
+    }
+}

src/lib.rs

@@ -28,17 +28,18 @@
 mod bag;
 mod ext;
 mod fs;
+mod hasher;
 mod path;
 
 pub use bag::{Factor, Fdupes, Machine, TreeBag};
 pub use globset;
+pub use hasher::Hasher;
 pub use path::Path;
 pub use regex;
-use std::hash::Hasher;
 use std::rc::Rc;
 
-pub type FileCounter = TreeBag<u64, Path>;
-pub type FileReplicates<'a> = bag::Replicates<'a, u64, Path>;
+pub type FileCounter<H> = TreeBag<H, Path>;
+pub type FileReplicates<'a, H> = bag::Replicates<'a, H, Path>;
 
 /// Search configuration.
 ///
@@ -83,9 +84,10 @@ where
     P: AsRef<std::path::Path>,
 {
     /// This will attemps a complete scan according to its configuration.
-    pub fn scan<H>(self) -> FileCounter
+    pub fn scan<H>(self) -> FileCounter<H::Hash>
     where
-        H: Hasher + Default,
+        H: hasher::Hasher,
+        H::Hash: std::fmt::Debug,
     {
         #[cfg(unix)]
         let file_filter = fs::filter::FileFilter::new(