Move hashing functionality

Author: laurmaedje

src/constraint.rs

@@ -4,7 +4,6 @@ use std::collections::hash_map::Entry;
 use std::hash::Hash;
 
 use parking_lot::RwLock;
-use siphasher::sip128::{Hasher128, SipHasher13};
 
 use crate::accelerate;
 
@@ -34,7 +33,7 @@ impl<T: Call> ImmutableConstraint<T> {
     /// Enter a constraint for a call to an immutable function.
     #[inline]
     pub fn push(&self, call: T, ret_hash: u128) {
-        let call_hash = hash(&call);
+        let call_hash = crate::hash::hash(&call);
         let entry = ConstraintEntry { call, call_hash, ret_hash };
         self.0.write().push_inner(Cow::Owned(entry));
     }
@@ -103,7 +102,7 @@ impl<T: Call> MutableConstraint<T> {
     /// Enter a constraint for a call to a mutable function.
     #[inline]
     pub fn push(&self, call: T, ret_hash: u128) {
-        let call_hash = hash(&call);
+        let call_hash = crate::hash::hash(&call);
         let entry = ConstraintEntry { call, call_hash, ret_hash };
         self.0.write().push_inner(Cow::Owned(entry));
     }
@@ -271,14 +270,6 @@ impl<T: Call> Join for MutableConstraint<T> {
     }
 }
 
-/// Produce a 128-bit hash of a value.
-#[inline]
-pub fn hash<T: Hash>(value: &T) -> u128 {
-    let mut state = SipHasher13::new();
-    value.hash(&mut state);
-    state.finish128().as_u128()
-}
-
 /// Check for a constraint violation.
 #[inline]
 #[track_caller]

src/prehashed.rs src/hash.rssrc/prehashed.rs renamed to src/hash.rs

@@ -6,6 +6,28 @@ use std::ops::Deref;
 
 use siphasher::sip128::{Hasher128, SipHasher13};
 
+/// Produce a 128-bit hash of a value.
+#[inline]
+pub fn hash<T: Hash>(value: &T) -> u128 {
+    let mut state = SipHasher13::new();
+    value.hash(&mut state);
+    state.finish128().as_u128()
+}
+
+/// Produce a 128-bit hash of a value's type and the value.
+///
+/// Prefer this over `hash` if the resulting hash is used for the same purpose
+/// as hashes of other types.
+#[inline]
+pub fn hash_any<T: Hash + 'static>(item: &T) -> u128 {
+    // Also hash the TypeId because the type might be converted
+    // through an unsized coercion.
+    let mut state = SipHasher13::new();
+    item.type_id().hash(&mut state);
+    item.hash(&mut state);
+    state.finish128().as_u128()
+}
+
 /// A wrapper type with precomputed hash.
 ///
 /// This is useful if you want to pass large values of `T` to memoized
@@ -37,7 +59,7 @@ impl<T: Hash + 'static> Prehashed<T> {
     /// Compute an item's hash and wrap it.
     #[inline]
     pub fn new(item: T) -> Self {
-        Self { hash: hash(&item), item }
+        Self { hash: hash_any(&item), item }
     }
 
     /// Return the wrapped value.
@@ -53,21 +75,11 @@ impl<T: Hash + 'static> Prehashed<T> {
         F: FnOnce(&mut T) -> U,
     {
         let output = f(&mut self.item);
-        self.hash = hash(&self.item);
+        self.hash = hash_any(&self.item);
         output
     }
 }
 
-/// Hash the item.
-fn hash<T: Hash + 'static>(item: &T) -> u128 {
-    // Also hash the TypeId because the type might be converted
-    // through an unsized coercion.
-    let mut state = SipHasher13::new();
-    item.type_id().hash(&mut state);
-    item.hash(&mut state);
-    state.finish128().as_u128()
-}
-
 impl<T: ?Sized> Deref for Prehashed<T> {
     type Target = T;
 

src/lib.rs

@@ -85,12 +85,12 @@ For the full example see [`examples/calc.rs`][calc].
 mod accelerate;
 mod cache;
 mod constraint;
+mod hash;
 mod input;
-mod prehashed;
 mod track;
 
 pub use crate::cache::evict;
-pub use crate::prehashed::Prehashed;
+pub use crate::hash::Prehashed;
 pub use crate::track::{Track, Tracked, TrackedMut, Validate};
 pub use comemo_macros::{memoize, track};
 
@@ -100,7 +100,8 @@ pub mod internal {
     pub use parking_lot::RwLock;
 
     pub use crate::cache::{Cache, CacheData, memoized, register_evictor};
-    pub use crate::constraint::{Call, ImmutableConstraint, MutableConstraint, hash};
+    pub use crate::constraint::{Call, ImmutableConstraint, MutableConstraint};
+    pub use crate::hash::hash;
     pub use crate::input::{Args, Input, assert_hashable_or_trackable};
     pub use crate::track::{Surfaces, to_parts_mut_mut, to_parts_mut_ref, to_parts_ref};