rename to anyhash

Cargo.toml

@@ -1,3 +1,3 @@
 [workspace]
-members = ["hash-t", "hash-t-macros"]
+members = ["anyhash", "anyhash-macros"]
 resolver = "2"

README.md

@@ -1,3 +1,3 @@
-This repository contains the [hash-t](hash-t) and [hash-t-macros](hash-t-macros) crates.
+This repository contains the [anyhash](anyhash) and [anyhash-macros](anyhash-macros) crates.
 
-See [hash-t/README.md](hash-t/README.md).
+See [anyhash/README.md](anyhash/README.md).

hash-t-macros/Cargo.toml → anyhash-macros/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "hash-t-macros"
+name = "anyhash-macros"
 version = "0.1.0"
 edition = "2021"
 authors = ["Maia <[email protected]>"]

anyhash-macros/README.md

@@ -0,0 +1 @@
+This crate provides proc macros for the `anyhash` crate. Don't use this directly.

hash-t-macros/src/lib.rs → anyhash-macros/src/lib.rs

@@ -12,12 +12,12 @@ use syn::{
 };
 
 fn crate_root() -> TokenStream {
-    quote!(::hash_t)
+    quote!(::anyhash)
 }
 
-#[proc_macro_derive(HashT)]
+#[proc_macro_derive(Hash)]
 #[allow(non_snake_case)]
-pub fn derive_hash_t(input: TokenStream1) -> TokenStream1 {
+pub fn derive_anyhash(input: TokenStream1) -> TokenStream1 {
     let root = crate_root();
     let hash = quote!(#root::Hash);
     let hasher_write = quote!(#root::HasherWrite);
@@ -164,7 +164,7 @@ pub fn impl_core_hash(input: TokenStream1) -> TokenStream1 {
                 #[inline]
                 fn hash<H: ::core::hash::Hasher>(&self, state: &mut H) {
                     <Self as #hash>::hash(
-                        self, &mut #root::internal::WrapCoreForU64::new(state)
+                        self, &mut #root::internal::WrapCoreForHasherU64::new(state)
                     )
                 }
             }
@@ -259,7 +259,7 @@ pub fn impl_core_build_hasher(input: TokenStream1) -> TokenStream1 {
             impl #impl_generics ::core::hash::BuildHasher for #ident #use_generics #where_ #where_clause
                 Self: #build_hasher_t<u64>,
             {
-                type Hasher = #root::internal::WrapU64ForCore<<Self as #build_hasher_t::<u64>>::Hasher>;
+                type Hasher = #root::internal::WrapHasherU64ForCore<<Self as #build_hasher_t::<u64>>::Hasher>;
 
                 #[inline]
                 fn build_hasher(&self) -> Self::Hasher {
@@ -274,7 +274,7 @@ pub fn impl_core_build_hasher(input: TokenStream1) -> TokenStream1 {
 
 #[proc_macro]
 #[allow(non_snake_case)]
-pub fn impl_hash_t(input: TokenStream1) -> TokenStream1 {
+pub fn impl_hash(input: TokenStream1) -> TokenStream1 {
     let root = crate_root();
     let hash = quote!(#root::Hash);
     let hasher_write = quote!(#root::HasherWrite);
@@ -307,41 +307,7 @@ pub fn impl_hash_t(input: TokenStream1) -> TokenStream1 {
                 #[inline]
                 fn hash<H: #hasher_write>(&self, state: &mut H) {
                     <Self as ::core::hash::Hash>::hash(
-                        self, &mut #root::internal::WrapCoreForT::new(state)
-                    )
-                }
-            }
-        }
-        .to_tokens(&mut output);
-    }
-    output.into()
-}
-
-#[proc_macro]
-pub fn impl_hash_u64(input: TokenStream1) -> TokenStream1 {
-    let root = crate_root();
-    let hash_t = quote!(#root::Hash);
-    let hasher_t = quote!(#root::Hasher);
-
-    let input = parse_macro_input!(input as IdentsWithGenerics);
-    let mut output = TokenStream::new();
-
-    for IdentWithGenerics {
-        impl_generics,
-        ident,
-        use_generics,
-        mut where_clause,
-    } in input.punctuated
-    {
-        let where_ = fix_where(where_clause.as_mut());
-        quote! {
-            impl #impl_generics #hash_t<u64> for #ident #use_generics #where_ #where_clause
-                Self: ::core::hash::Hash,
-            {
-                #[inline]
-                fn hash<H: #hasher_t<u64>>(&self, state: &mut H) {
-                    <Self as ::core::hash::Hash>::hash(
-                        self, &mut #root::internal::WrapU64ForCore::new(state)
+                        self, &mut #root::internal::WrapHasherWriteForCore::new(state)
                     )
                 }
             }

hash-t/Cargo.toml → anyhash/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "hash-t"
+name = "anyhash"
 version = "0.1.0"
 edition = "2021"
 authors = ["Maia <[email protected]>"]
@@ -22,7 +22,7 @@ spooky = ["bytemuck"]
 xxh64 = ["bytemuck"]
 
 [dependencies]
-hash-t-macros = { path = "../hash-t-macros" }
+anyhash-macros = { path = "../anyhash-macros" }
 bnum = { version = "0.10", optional = true }
 bytemuck = { version = "1.14", features = ["min_const_generics"], optional = true }
 

hash-t/src/impls.rs → anyhash/src/impls.rs

@@ -1,4 +1,4 @@
-use crate::{impl_hash_t, Hash, Hasher, HasherWrite};
+use crate::{impl_hash, Hash, Hasher, HasherWrite};
 
 macro_rules! impl_hasher_t_deref {
     () => {
@@ -169,14 +169,20 @@ impl<T: ?Sized + Hash> Hash for &mut T {
 impl<T: ?Sized> Hash for *const T {
     #[inline]
     fn hash<H: HasherWrite>(&self, state: &mut H) {
-        <Self as ::core::hash::Hash>::hash(self, &mut crate::internal::WrapCoreForT::new(state))
+        <Self as ::core::hash::Hash>::hash(
+            self,
+            &mut crate::internal::WrapHasherWriteForCore::new(state),
+        )
     }
 }
 
 impl<T: ?Sized> Hash for *mut T {
     #[inline]
     fn hash<H: HasherWrite>(&self, state: &mut H) {
-        <Self as ::core::hash::Hash>::hash(self, &mut crate::internal::WrapCoreForT::new(state))
+        <Self as ::core::hash::Hash>::hash(
+            self,
+            &mut crate::internal::WrapHasherWriteForCore::new(state),
+        )
     }
 }
 
@@ -265,7 +271,7 @@ mod core_impls {
         time::Duration,
     };
 
-    impl_hash_t!(Layout; TypeId);
+    impl_hash!(Layout; TypeId);
 
     impl Hash for Ordering {
         #[inline]
@@ -279,7 +285,7 @@ mod core_impls {
         fn hash<H: HasherWrite>(&self, _: &mut H) {}
     }
 
-    impl_hash_t!(impl<T> Discriminant<T>);
+    impl_hash!(impl<T> Discriminant<T>);
 
     impl<T: ?Sized + Hash> Hash for ManuallyDrop<T> {
         #[inline]
@@ -304,7 +310,7 @@ mod core_impls {
     }
 
     // RangeInclusive has private internal state
-    impl_hash_t!(impl<I: core::hash::Hash> RangeInclusive<I>);
+    impl_hash!(impl<I: core::hash::Hash> RangeInclusive<I>);
 
     impl<T: Hash> Hash for Bound<T> {
         #[inline]
@@ -339,7 +345,7 @@ mod core_impls {
         }
     }
 
-    impl_hash_t!(Location<'_>);
+    impl_hash!(Location<'_>);
 
     impl<P: Deref<Target = impl Hash>> Hash for Pin<P> {
         #[inline]
@@ -384,7 +390,7 @@ mod core_impls {
         }
     }
 
-    impl_hash_t!(Duration);
+    impl_hash!(Duration);
 
     impl_empty_hash! {
         Infallible, Error, PhantomPinned, RangeFull
@@ -489,7 +495,7 @@ mod alloc_impls {
         }
     }
 
-    impl_hash_t!(impl<T: core::hash::Hash> BTreeSet<T>);
+    impl_hash!(impl<T: core::hash::Hash> BTreeSet<T>);
 
     impl<T: Hash> Hash for LinkedList<T> {
         #[inline]
@@ -531,7 +537,7 @@ mod std_impls {
         time::{Instant, SystemTime},
     };
 
-    impl_hash_t!(
+    impl_hash!(
         OsStr;
         OsString;
         FileType;

hash-t/src/internal.rs → anyhash/src/internal.rs

@@ -57,16 +57,16 @@ macro_rules! impl_hasher_core_fwd {
 }
 
 #[repr(transparent)]
-pub struct WrapCoreForT<'a, H: HasherWrite>(&'a mut H);
+pub struct WrapHasherWriteForCore<'a, H: HasherWrite>(&'a mut H);
 
-impl<'a, H: HasherWrite> WrapCoreForT<'a, H> {
+impl<'a, H: HasherWrite> WrapHasherWriteForCore<'a, H> {
     #[inline(always)]
     pub fn new(hasher: &'a mut H) -> Self {
         Self(hasher)
     }
 }
 
-impl<H: HasherWrite> core::hash::Hasher for WrapCoreForT<'_, H> {
+impl<H: HasherWrite> core::hash::Hasher for WrapHasherWriteForCore<'_, H> {
     #[inline(always)]
     fn finish(&self) -> u64 {
         panic!("`core::hash::Hasher::finish` called while calculating generic hash");
@@ -76,43 +76,43 @@ impl<H: HasherWrite> core::hash::Hasher for WrapCoreForT<'_, H> {
 }
 
 #[repr(transparent)]
-pub struct WrapCoreForU64<'a, H: core::hash::Hasher>(&'a mut H);
+pub struct WrapHasherU64ForCore<H: Hasher<u64>>(H);
 
-impl<'a, H: core::hash::Hasher> WrapCoreForU64<'a, H> {
+impl<H: Hasher<u64>> WrapHasherU64ForCore<H> {
     #[inline(always)]
-    pub fn new(hasher: &'a mut H) -> Self {
+    pub const fn new(hasher: H) -> Self {
         Self(hasher)
     }
 }
 
-impl<H: ::core::hash::Hasher> Hasher<u64> for WrapCoreForU64<'_, H> {
+impl<H: Hasher<u64>> ::core::hash::Hasher for WrapHasherU64ForCore<H> {
     #[inline(always)]
     fn finish(&self) -> u64 {
-        H::finish(self.0)
+        H::finish(&self.0)
     }
-}
 
-impl<H: ::core::hash::Hasher> HasherWrite for WrapCoreForU64<'_, H> {
-    impl_hasher_core_fwd!();
+    impl_hasher_core_fwd!(&mut);
 }
 
 #[repr(transparent)]
-pub struct WrapU64ForCore<H: Hasher<u64>>(H);
+pub struct WrapCoreForHasherU64<'a, H: core::hash::Hasher>(&'a mut H);
 
-impl<H: Hasher<u64>> WrapU64ForCore<H> {
+impl<'a, H: core::hash::Hasher> WrapCoreForHasherU64<'a, H> {
     #[inline(always)]
-    pub const fn new(hasher: H) -> Self {
+    pub fn new(hasher: &'a mut H) -> Self {
         Self(hasher)
     }
 }
 
-impl<H: Hasher<u64>> ::core::hash::Hasher for WrapU64ForCore<H> {
+impl<H: ::core::hash::Hasher> Hasher<u64> for WrapCoreForHasherU64<'_, H> {
     #[inline(always)]
     fn finish(&self) -> u64 {
-        H::finish(&self.0)
+        H::finish(self.0)
     }
+}
 
-    impl_hasher_core_fwd!(&mut);
+impl<H: ::core::hash::Hasher> HasherWrite for WrapCoreForHasherU64<'_, H> {
+    impl_hasher_core_fwd!();
 }
 
 #[cfg(feature = "bytemuck")]