From 734bcddba8555cd0c4796fc2dc29caccc7b3b393 Mon Sep 17 00:00:00 2001
From: Moritz Borcherding <mb@crown.de>
Date: Thu, 5 Oct 2023 15:44:56 +0200
Subject: [PATCH 1/2] add BuildHasher and Hasher impls for the Crc structs

---
 src/crc128/bytewise.rs | 19 +++++++++++++++++++
 src/crc128/default.rs  | 19 +++++++++++++++++++
 src/crc128/nolookup.rs | 19 +++++++++++++++++++
 src/crc128/slice16.rs  | 19 +++++++++++++++++++
 src/crc16/bytewise.rs  | 19 +++++++++++++++++++
 src/crc16/default.rs   | 19 +++++++++++++++++++
 src/crc16/nolookup.rs  | 19 +++++++++++++++++++
 src/crc16/slice16.rs   | 19 +++++++++++++++++++
 src/crc32/bytewise.rs  | 19 +++++++++++++++++++
 src/crc32/default.rs   | 19 +++++++++++++++++++
 src/crc32/nolookup.rs  | 19 +++++++++++++++++++
 src/crc32/slice16.rs   | 19 +++++++++++++++++++
 src/crc64/bytewise.rs  | 19 +++++++++++++++++++
 src/crc64/default.rs   | 19 +++++++++++++++++++
 src/crc64/nolookup.rs  | 19 +++++++++++++++++++
 src/crc64/slice16.rs   | 19 +++++++++++++++++++
 src/crc8/bytewise.rs   | 19 +++++++++++++++++++
 src/crc8/default.rs    | 19 +++++++++++++++++++
 src/crc8/nolookup.rs   | 19 +++++++++++++++++++
 src/crc8/slice16.rs    | 19 +++++++++++++++++++
 src/lib.rs             |  3 +++
 21 files changed, 383 insertions(+)

diff --git a/src/crc128/bytewise.rs b/src/crc128/bytewise.rs
index 500d7ea..14c3286 100644
--- a/src/crc128/bytewise.rs
+++ b/src/crc128/bytewise.rs
@@ -1,5 +1,6 @@
 use crate::table::crc128_table;
 use crate::{Algorithm, Bytewise, Crc, Digest};
+use core::hash::{BuildHasher, Hasher};
 
 use super::{finalize, init, update_bytewise};
 
@@ -47,3 +48,21 @@ impl<'a> Digest<'a, Bytewise<u128>> {
         finalize(self.crc.algorithm, self.value)
     }
 }
+
+impl<'a> Hasher for Digest<'a, Bytewise<u128>> {
+    fn finish(&self) -> u64 {
+        self.clone().finalize() as u64
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.update(bytes);
+    }
+}
+
+impl<'a> BuildHasher for &'a Crc<Bytewise<u128>> {
+    type Hasher = Digest<'a, Bytewise<u128>>;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        self.digest()
+    }
+}
diff --git a/src/crc128/default.rs b/src/crc128/default.rs
index d623ac4..ae978d0 100644
--- a/src/crc128/default.rs
+++ b/src/crc128/default.rs
@@ -1,5 +1,6 @@
 use crate::crc128::{finalize, init};
 use crate::{Algorithm, Crc, Digest, Implementation};
+use core::hash::{BuildHasher, Hasher};
 
 #[cfg(feature = "no-table-mem-limit")]
 impl Implementation for u128 {
@@ -124,3 +125,21 @@ impl<'a> Digest<'a, u128> {
         finalize(self.crc.algorithm, self.value)
     }
 }
+
+impl<'a> Hasher for Digest<'a, u128> {
+    fn finish(&self) -> u64 {
+        self.clone().finalize() as u64
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.update(bytes);
+    }
+}
+
+impl<'a> BuildHasher for &'a Crc<u128> {
+    type Hasher = Digest<'a, u128>;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        self.digest()
+    }
+}
diff --git a/src/crc128/nolookup.rs b/src/crc128/nolookup.rs
index ef22e3b..6fad3b3 100644
--- a/src/crc128/nolookup.rs
+++ b/src/crc128/nolookup.rs
@@ -1,4 +1,5 @@
 use crate::{Algorithm, Crc, Digest, NoTable};
+use core::hash::{BuildHasher, Hasher};
 
 use super::{finalize, init, update_nolookup};
 
@@ -48,3 +49,21 @@ impl<'a> Digest<'a, NoTable<u128>> {
         finalize(self.crc.algorithm, self.value)
     }
 }
+
+impl<'a> Hasher for Digest<'a, NoTable<u128>> {
+    fn finish(&self) -> u64 {
+        self.clone().finalize() as u64
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.update(bytes);
+    }
+}
+
+impl<'a> BuildHasher for &'a Crc<NoTable<u128>> {
+    type Hasher = Digest<'a, NoTable<u128>>;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        self.digest()
+    }
+}
diff --git a/src/crc128/slice16.rs b/src/crc128/slice16.rs
index 948a70d..264c75b 100644
--- a/src/crc128/slice16.rs
+++ b/src/crc128/slice16.rs
@@ -1,5 +1,6 @@
 use crate::table::crc128_table_slice_16;
 use crate::{Algorithm, Crc, Digest, Slice16};
+use core::hash::{BuildHasher, Hasher};
 
 use super::{finalize, init, update_slice16};
 
@@ -47,3 +48,21 @@ impl<'a> Digest<'a, Slice16<u128>> {
         finalize(self.crc.algorithm, self.value)
     }
 }
+
+impl<'a> Hasher for Digest<'a, Slice16<u128>> {
+    fn finish(&self) -> u64 {
+        self.clone().finalize() as u64
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.update(bytes);
+    }
+}
+
+impl<'a> BuildHasher for &'a Crc<Slice16<u128>> {
+    type Hasher = Digest<'a, Slice16<u128>>;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        self.digest()
+    }
+}
diff --git a/src/crc16/bytewise.rs b/src/crc16/bytewise.rs
index 1f042dd..f573527 100644
--- a/src/crc16/bytewise.rs
+++ b/src/crc16/bytewise.rs
@@ -1,6 +1,7 @@
 use crate::crc16::{finalize, init, update_bytewise};
 use crate::table::crc16_table;
 use crate::{Algorithm, Bytewise, Crc, Digest};
+use core::hash::{BuildHasher, Hasher};
 
 impl Crc<Bytewise<u16>> {
     pub const fn new(algorithm: &'static Algorithm<u16>) -> Self {
@@ -46,3 +47,21 @@ impl<'a> Digest<'a, Bytewise<u16>> {
         finalize(self.crc.algorithm, self.value)
     }
 }
+
+impl<'a> Hasher for Digest<'a, Bytewise<u16>> {
+    fn finish(&self) -> u64 {
+        self.clone().finalize() as u64
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.update(bytes);
+    }
+}
+
+impl<'a> BuildHasher for &'a Crc<Bytewise<u16>> {
+    type Hasher = Digest<'a, Bytewise<u16>>;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        self.digest()
+    }
+}
diff --git a/src/crc16/default.rs b/src/crc16/default.rs
index 55b72c9..dc66cc6 100644
--- a/src/crc16/default.rs
+++ b/src/crc16/default.rs
@@ -1,5 +1,6 @@
 use crate::crc16::{finalize, init};
 use crate::{Algorithm, Crc, Digest, Implementation};
+use core::hash::{BuildHasher, Hasher};
 
 #[cfg(feature = "no-table-mem-limit")]
 impl Implementation for u16 {
@@ -124,3 +125,21 @@ impl<'a> Digest<'a, u16> {
         finalize(self.crc.algorithm, self.value)
     }
 }
+
+impl<'a> Hasher for Digest<'a, u16> {
+    fn finish(&self) -> u64 {
+        self.clone().finalize() as u64
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.update(bytes);
+    }
+}
+
+impl<'a> BuildHasher for &'a Crc<u16> {
+    type Hasher = Digest<'a, u16>;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        self.digest()
+    }
+}
diff --git a/src/crc16/nolookup.rs b/src/crc16/nolookup.rs
index eedf5a2..bc8e2c4 100644
--- a/src/crc16/nolookup.rs
+++ b/src/crc16/nolookup.rs
@@ -1,5 +1,6 @@
 use crate::crc16::{finalize, init, update_nolookup};
 use crate::{Algorithm, Crc, Digest, NoTable};
+use core::hash::{BuildHasher, Hasher};
 
 impl Crc<NoTable<u16>> {
     pub const fn new(algorithm: &'static Algorithm<u16>) -> Self {
@@ -47,3 +48,21 @@ impl<'a> Digest<'a, NoTable<u16>> {
         finalize(self.crc.algorithm, self.value)
     }
 }
+
+impl<'a> Hasher for Digest<'a, NoTable<u16>> {
+    fn finish(&self) -> u64 {
+        self.clone().finalize() as u64
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.update(bytes);
+    }
+}
+
+impl<'a> BuildHasher for &'a Crc<NoTable<u16>> {
+    type Hasher = Digest<'a, NoTable<u16>>;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        self.digest()
+    }
+}
diff --git a/src/crc16/slice16.rs b/src/crc16/slice16.rs
index 781cff4..3ac6c51 100644
--- a/src/crc16/slice16.rs
+++ b/src/crc16/slice16.rs
@@ -1,6 +1,7 @@
 use crate::crc16::{finalize, init, update_slice16};
 use crate::table::crc16_table_slice_16;
 use crate::{Algorithm, Crc, Digest, Slice16};
+use core::hash::{BuildHasher, Hasher};
 
 impl Crc<Slice16<u16>> {
     pub const fn new(algorithm: &'static Algorithm<u16>) -> Self {
@@ -46,3 +47,21 @@ impl<'a> Digest<'a, Slice16<u16>> {
         finalize(self.crc.algorithm, self.value)
     }
 }
+
+impl<'a> Hasher for Digest<'a, Slice16<u16>> {
+    fn finish(&self) -> u64 {
+        self.clone().finalize() as u64
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.update(bytes);
+    }
+}
+
+impl<'a> BuildHasher for &'a Crc<Slice16<u16>> {
+    type Hasher = Digest<'a, Slice16<u16>>;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        self.digest()
+    }
+}
diff --git a/src/crc32/bytewise.rs b/src/crc32/bytewise.rs
index 88c7976..b7f9f7d 100644
--- a/src/crc32/bytewise.rs
+++ b/src/crc32/bytewise.rs
@@ -1,5 +1,6 @@
 use crate::table::crc32_table;
 use crate::{Algorithm, Bytewise, Crc, Digest};
+use core::hash::{BuildHasher, Hasher};
 
 use crate::crc32::{finalize, init, update_bytewise};
 
@@ -47,3 +48,21 @@ impl<'a> Digest<'a, Bytewise<u32>> {
         finalize(self.crc.algorithm, self.value)
     }
 }
+
+impl<'a> Hasher for Digest<'a, Bytewise<u32>> {
+    fn finish(&self) -> u64 {
+        self.clone().finalize() as u64
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.update(bytes);
+    }
+}
+
+impl<'a> BuildHasher for &'a Crc<Bytewise<u32>> {
+    type Hasher = Digest<'a, Bytewise<u32>>;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        self.digest()
+    }
+}
diff --git a/src/crc32/default.rs b/src/crc32/default.rs
index 0aaedd3..3bedc3f 100644
--- a/src/crc32/default.rs
+++ b/src/crc32/default.rs
@@ -1,5 +1,6 @@
 use crate::crc32::{finalize, init};
 use crate::{Algorithm, Crc, Digest, Implementation};
+use core::hash::{BuildHasher, Hasher};
 
 #[cfg(feature = "no-table-mem-limit")]
 impl Implementation for u32 {
@@ -124,3 +125,21 @@ impl<'a> Digest<'a, u32> {
         finalize(self.crc.algorithm, self.value)
     }
 }
+
+impl<'a> Hasher for Digest<'a, u32> {
+    fn finish(&self) -> u64 {
+        self.clone().finalize() as u64
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.update(bytes);
+    }
+}
+
+impl<'a> BuildHasher for &'a Crc<u32> {
+    type Hasher = Digest<'a, u32>;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        self.digest()
+    }
+}
diff --git a/src/crc32/nolookup.rs b/src/crc32/nolookup.rs
index de40987..6e86122 100644
--- a/src/crc32/nolookup.rs
+++ b/src/crc32/nolookup.rs
@@ -1,4 +1,5 @@
 use crate::{Algorithm, Crc, Digest, NoTable};
+use core::hash::{BuildHasher, Hasher};
 
 use super::{finalize, init, update_nolookup};
 
@@ -48,3 +49,21 @@ impl<'a> Digest<'a, NoTable<u32>> {
         finalize(self.crc.algorithm, self.value)
     }
 }
+
+impl<'a> Hasher for Digest<'a, NoTable<u32>> {
+    fn finish(&self) -> u64 {
+        self.clone().finalize() as u64
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.update(bytes);
+    }
+}
+
+impl<'a> BuildHasher for &'a Crc<NoTable<u32>> {
+    type Hasher = Digest<'a, NoTable<u32>>;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        self.digest()
+    }
+}
diff --git a/src/crc32/slice16.rs b/src/crc32/slice16.rs
index 638becc..613feca 100644
--- a/src/crc32/slice16.rs
+++ b/src/crc32/slice16.rs
@@ -1,5 +1,6 @@
 use crate::table::crc32_table_slice_16;
 use crate::{Algorithm, Crc, Digest, Slice16};
+use core::hash::{BuildHasher, Hasher};
 
 use super::{finalize, init, update_slice16};
 
@@ -47,3 +48,21 @@ impl<'a> Digest<'a, Slice16<u32>> {
         finalize(self.crc.algorithm, self.value)
     }
 }
+
+impl<'a> Hasher for Digest<'a, Slice16<u32>> {
+    fn finish(&self) -> u64 {
+        self.clone().finalize() as u64
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.update(bytes);
+    }
+}
+
+impl<'a> BuildHasher for &'a Crc<Slice16<u32>> {
+    type Hasher = Digest<'a, Slice16<u32>>;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        self.digest()
+    }
+}
diff --git a/src/crc64/bytewise.rs b/src/crc64/bytewise.rs
index e4b66c0..b5d943b 100644
--- a/src/crc64/bytewise.rs
+++ b/src/crc64/bytewise.rs
@@ -1,5 +1,6 @@
 use crate::table::crc64_table;
 use crate::{Algorithm, Bytewise, Crc, Digest};
+use core::hash::{BuildHasher, Hasher};
 
 use super::{finalize, init, update_bytewise};
 
@@ -47,3 +48,21 @@ impl<'a> Digest<'a, Bytewise<u64>> {
         finalize(self.crc.algorithm, self.value)
     }
 }
+
+impl<'a> Hasher for Digest<'a, Bytewise<u64>> {
+    fn finish(&self) -> u64 {
+        self.clone().finalize() as u64
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.update(bytes);
+    }
+}
+
+impl<'a> BuildHasher for &'a Crc<Bytewise<u64>> {
+    type Hasher = Digest<'a, Bytewise<u64>>;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        self.digest()
+    }
+}
diff --git a/src/crc64/default.rs b/src/crc64/default.rs
index bf41dc8..3dbabde 100644
--- a/src/crc64/default.rs
+++ b/src/crc64/default.rs
@@ -1,5 +1,6 @@
 use crate::crc64::{finalize, init};
 use crate::{Algorithm, Crc, Digest, Implementation};
+use core::hash::{BuildHasher, Hasher};
 
 #[cfg(feature = "no-table-mem-limit")]
 impl Implementation for u64 {
@@ -124,3 +125,21 @@ impl<'a> Digest<'a, u64> {
         finalize(self.crc.algorithm, self.value)
     }
 }
+
+impl<'a> Hasher for Digest<'a, u64> {
+    fn finish(&self) -> u64 {
+        self.clone().finalize() as u64
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.update(bytes);
+    }
+}
+
+impl<'a> BuildHasher for &'a Crc<u64> {
+    type Hasher = Digest<'a, u64>;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        self.digest()
+    }
+}
diff --git a/src/crc64/nolookup.rs b/src/crc64/nolookup.rs
index 47ccc2c..7cd9da2 100644
--- a/src/crc64/nolookup.rs
+++ b/src/crc64/nolookup.rs
@@ -1,4 +1,5 @@
 use crate::{Algorithm, Crc, Digest, NoTable};
+use core::hash::{BuildHasher, Hasher};
 
 use super::{finalize, init, update_nolookup};
 
@@ -48,3 +49,21 @@ impl<'a> Digest<'a, NoTable<u64>> {
         finalize(self.crc.algorithm, self.value)
     }
 }
+
+impl<'a> Hasher for Digest<'a, NoTable<u64>> {
+    fn finish(&self) -> u64 {
+        self.clone().finalize() as u64
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.update(bytes);
+    }
+}
+
+impl<'a> BuildHasher for &'a Crc<NoTable<u64>> {
+    type Hasher = Digest<'a, NoTable<u64>>;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        self.digest()
+    }
+}
diff --git a/src/crc64/slice16.rs b/src/crc64/slice16.rs
index 0bd279e..b9ff651 100644
--- a/src/crc64/slice16.rs
+++ b/src/crc64/slice16.rs
@@ -1,5 +1,6 @@
 use crate::table::crc64_table_slice_16;
 use crate::{Algorithm, Crc, Digest, Slice16};
+use core::hash::{BuildHasher, Hasher};
 
 use super::{finalize, init, update_slice16};
 
@@ -47,3 +48,21 @@ impl<'a> Digest<'a, Slice16<u64>> {
         finalize(self.crc.algorithm, self.value)
     }
 }
+
+impl<'a> Hasher for Digest<'a, Slice16<u64>> {
+    fn finish(&self) -> u64 {
+        self.clone().finalize() as u64
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.update(bytes);
+    }
+}
+
+impl<'a> BuildHasher for &'a Crc<Slice16<u64>> {
+    type Hasher = Digest<'a, Slice16<u64>>;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        self.digest()
+    }
+}
diff --git a/src/crc8/bytewise.rs b/src/crc8/bytewise.rs
index 1cae39e..a54f174 100644
--- a/src/crc8/bytewise.rs
+++ b/src/crc8/bytewise.rs
@@ -1,6 +1,7 @@
 use crate::crc8::{finalize, init, update_bytewise};
 use crate::table::crc8_table;
 use crate::{Algorithm, Bytewise, Crc, Digest};
+use core::hash::{BuildHasher, Hasher};
 
 impl Crc<Bytewise<u8>> {
     pub const fn new(algorithm: &'static Algorithm<u8>) -> Self {
@@ -46,3 +47,21 @@ impl<'a> Digest<'a, Bytewise<u8>> {
         finalize(self.crc.algorithm, self.value)
     }
 }
+
+impl<'a> Hasher for Digest<'a, Bytewise<u8>> {
+    fn finish(&self) -> u64 {
+        self.clone().finalize() as u64
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.update(bytes);
+    }
+}
+
+impl<'a> BuildHasher for &'a Crc<Bytewise<u8>> {
+    type Hasher = Digest<'a, Bytewise<u8>>;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        self.digest()
+    }
+}
diff --git a/src/crc8/default.rs b/src/crc8/default.rs
index 9923b3a..6d085bf 100644
--- a/src/crc8/default.rs
+++ b/src/crc8/default.rs
@@ -1,5 +1,6 @@
 use crate::crc8::{finalize, init};
 use crate::{Algorithm, Crc, Digest, Implementation};
+use core::hash::{BuildHasher, Hasher};
 
 #[cfg(feature = "no-table-mem-limit")]
 impl Implementation for u8 {
@@ -124,3 +125,21 @@ impl<'a> Digest<'a, u8> {
         finalize(self.crc.algorithm, self.value)
     }
 }
+
+impl<'a> Hasher for Digest<'a, u8> {
+    fn finish(&self) -> u64 {
+        self.clone().finalize() as u64
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.update(bytes);
+    }
+}
+
+impl<'a> BuildHasher for &'a Crc<u8> {
+    type Hasher = Digest<'a, u8>;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        self.digest()
+    }
+}
diff --git a/src/crc8/nolookup.rs b/src/crc8/nolookup.rs
index 4b19340..badcbce 100644
--- a/src/crc8/nolookup.rs
+++ b/src/crc8/nolookup.rs
@@ -1,5 +1,6 @@
 use crate::crc8::{finalize, init, update_nolookup};
 use crate::{Algorithm, Crc, Digest, NoTable};
+use core::hash::{BuildHasher, Hasher};
 
 impl Crc<NoTable<u8>> {
     pub const fn new(algorithm: &'static Algorithm<u8>) -> Self {
@@ -47,3 +48,21 @@ impl<'a> Digest<'a, NoTable<u8>> {
         finalize(self.crc.algorithm, self.value)
     }
 }
+
+impl<'a> Hasher for Digest<'a, NoTable<u8>> {
+    fn finish(&self) -> u64 {
+        self.clone().finalize() as u64
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.update(bytes);
+    }
+}
+
+impl<'a> BuildHasher for &'a Crc<NoTable<u8>> {
+    type Hasher = Digest<'a, NoTable<u8>>;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        self.digest()
+    }
+}
diff --git a/src/crc8/slice16.rs b/src/crc8/slice16.rs
index a63ed84..96800c6 100644
--- a/src/crc8/slice16.rs
+++ b/src/crc8/slice16.rs
@@ -1,6 +1,7 @@
 use crate::crc8::{finalize, init, update_slice16};
 use crate::table::crc8_table_slice_16;
 use crate::{Algorithm, Crc, Digest, Slice16};
+use core::hash::{BuildHasher, Hasher};
 
 impl Crc<Slice16<u8>> {
     pub const fn new(algorithm: &'static Algorithm<u8>) -> Self {
@@ -46,3 +47,21 @@ impl<'a> Digest<'a, Slice16<u8>> {
         finalize(self.crc.algorithm, self.value)
     }
 }
+
+impl<'a> Hasher for Digest<'a, Slice16<u8>> {
+    fn finish(&self) -> u64 {
+        self.clone().finalize() as u64
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.update(bytes);
+    }
+}
+
+impl<'a> BuildHasher for &'a Crc<Slice16<u8>> {
+    type Hasher = Digest<'a, Slice16<u8>>;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        self.digest()
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index d0a4ded..2858324 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -39,12 +39,15 @@ mod table;
 mod util;
 
 /// Implementation using a 16 * 256 entry lookup table. Use it with `Crc<Slice16<W>>`
+#[derive(Clone)]
 pub struct Slice16<W: Width>(core::marker::PhantomData<W>);
 
 /// Implementation using a 256 entry lookup table. Use it with `Crc<Bytewise<W>>`
+#[derive(Clone)]
 pub struct Bytewise<W: Width>(core::marker::PhantomData<W>);
 
 /// Implementation using no lookup table. Use it with `Crc<Nolookup<W>>`
+#[derive(Clone)]
 pub struct NoTable<W: Width>(core::marker::PhantomData<W>);
 
 impl<W: Width> crate::private::Sealed for Slice16<W> {}

From 24b4d003692a1191a716a55ad786ee7c0afb7e30 Mon Sep 17 00:00:00 2001
From: Moritz Borcherding <mb@crown.de>
Date: Thu, 5 Oct 2023 15:53:42 +0200
Subject: [PATCH 2/2] remove unnecessary casts to u64 in the Crc<u64> case

---
 src/crc64/bytewise.rs | 2 +-
 src/crc64/default.rs  | 2 +-
 src/crc64/nolookup.rs | 2 +-
 src/crc64/slice16.rs  | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/crc64/bytewise.rs b/src/crc64/bytewise.rs
index b5d943b..2c0c718 100644
--- a/src/crc64/bytewise.rs
+++ b/src/crc64/bytewise.rs
@@ -51,7 +51,7 @@ impl<'a> Digest<'a, Bytewise<u64>> {
 
 impl<'a> Hasher for Digest<'a, Bytewise<u64>> {
     fn finish(&self) -> u64 {
-        self.clone().finalize() as u64
+        self.clone().finalize()
     }
 
     fn write(&mut self, bytes: &[u8]) {
diff --git a/src/crc64/default.rs b/src/crc64/default.rs
index 3dbabde..1f2cb56 100644
--- a/src/crc64/default.rs
+++ b/src/crc64/default.rs
@@ -128,7 +128,7 @@ impl<'a> Digest<'a, u64> {
 
 impl<'a> Hasher for Digest<'a, u64> {
     fn finish(&self) -> u64 {
-        self.clone().finalize() as u64
+        self.clone().finalize()
     }
 
     fn write(&mut self, bytes: &[u8]) {
diff --git a/src/crc64/nolookup.rs b/src/crc64/nolookup.rs
index 7cd9da2..77067bf 100644
--- a/src/crc64/nolookup.rs
+++ b/src/crc64/nolookup.rs
@@ -52,7 +52,7 @@ impl<'a> Digest<'a, NoTable<u64>> {
 
 impl<'a> Hasher for Digest<'a, NoTable<u64>> {
     fn finish(&self) -> u64 {
-        self.clone().finalize() as u64
+        self.clone().finalize()
     }
 
     fn write(&mut self, bytes: &[u8]) {
diff --git a/src/crc64/slice16.rs b/src/crc64/slice16.rs
index b9ff651..034a233 100644
--- a/src/crc64/slice16.rs
+++ b/src/crc64/slice16.rs
@@ -51,7 +51,7 @@ impl<'a> Digest<'a, Slice16<u64>> {
 
 impl<'a> Hasher for Digest<'a, Slice16<u64>> {
     fn finish(&self) -> u64 {
-        self.clone().finalize() as u64
+        self.clone().finalize()
     }
 
     fn write(&mut self, bytes: &[u8]) {