Tidy up

Author: laurmaedje

macros/src/track.rs

@@ -55,10 +55,7 @@ pub fn expand(block: &syn::ItemImpl) -> Result<proc_macro2::TokenStream> {
                 true #(&& #tracked_valids)*
             }
 
-            fn surface<'a, 'r>(tracked: &'r Tracked<'a, #ty>) -> &'r Surface<'a>
-            where
-                Self: Track,
-            {
+            fn surface<'a, 'r>(tracked: &'r Tracked<'a, #ty>) -> &'r Surface<'a> {
                 // Safety: Surface is repr(transparent).
                 unsafe { &*(tracked as *const _ as *const _) }
             }

src/cache.rs

@@ -1,12 +1,11 @@
 use std::any::Any;
 use std::cell::RefCell;
 use std::fmt::Debug;
-use std::hash::{Hash, Hasher};
-use std::marker::PhantomData;
 
 use siphasher::sip128::{Hasher128, SipHasher};
 
-use crate::track::{from_parts, to_parts, Track, Trackable, Tracked};
+use crate::input::Input;
+use crate::internal::Family;
 
 thread_local! {
     /// The global, dynamic cache shared by all memoized functions.
@@ -37,19 +36,19 @@ impl Cache {
     where
         In: Input,
         Out: Debug + Clone + 'static,
-        F: for<'f> Fn(<In::Focus as Family<'f>>::Out) -> Out,
+        F: for<'f> Fn(<In::Hooked as Family<'f>>::Out) -> Out,
     {
         // Compute the hash of the input's key part.
         let hash = {
             let mut state = SipHasher::new();
-            input.hash(&mut state);
+            input.key(&mut state);
             state.finish128().as_u128()
         };
 
         let mut hit = true;
         let output = self.lookup::<In, Out>(hash, &input).unwrap_or_else(|| {
             let constraint = In::Constraint::default();
-            let input = input.focus(&constraint);
+            let input = input.hook_up(&constraint);
             let value = func(input);
             let constrained = Constrained { value: value.clone(), constraint };
             self.insert::<In, Out>(hash, constrained);
@@ -93,70 +92,3 @@ impl Cache {
         self.map.borrow_mut().push(entry);
     }
 }
-
-pub trait Input {
-    type Constraint: Default + 'static;
-    type Focus: for<'f> Family<'f>;
-
-    fn hash<H: Hasher>(&self, state: &mut H);
-    fn valid(&self, constraint: &Self::Constraint) -> bool;
-    fn focus<'f>(
-        self,
-        constraint: &'f Self::Constraint,
-    ) -> <Self::Focus as Family<'f>>::Out
-    where
-        Self: 'f;
-}
-
-impl<T: Hash> Input for T {
-    type Constraint = ();
-    type Focus = HashFamily<T>;
-
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        Hash::hash(self, state);
-    }
-
-    fn valid(&self, _: &()) -> bool {
-        true
-    }
-
-    fn focus<'f>(self, _: &'f ()) -> Self
-    where
-        Self: 'f,
-    {
-        self
-    }
-}
-
-pub struct HashFamily<T>(PhantomData<T>);
-impl<T> Family<'_> for HashFamily<T> {
-    type Out = T;
-}
-
-impl<'a, T: Track> Input for Tracked<'a, T> {
-    type Constraint = <T as Trackable>::Constraint;
-    type Focus = TrackedFamily<T>;
-
-    fn hash<H: Hasher>(&self, _: &mut H) {}
-
-    fn valid(&self, constraint: &Self::Constraint) -> bool {
-        Trackable::valid(to_parts(*self).0, constraint)
-    }
-
-    fn focus<'f>(self, constraint: &'f Self::Constraint) -> Tracked<'f, T>
-    where
-        Self: 'f,
-    {
-        from_parts(to_parts(self).0, Some(constraint))
-    }
-}
-
-pub struct TrackedFamily<T>(PhantomData<T>);
-impl<'f, T: Track + 'f> Family<'f> for TrackedFamily<T> {
-    type Out = Tracked<'f, T>;
-}
-
-pub trait Family<'a> {
-    /// The surface with lifetime.
-    type Out;
-}

src/input.rs

@@ -0,0 +1,86 @@
+use std::hash::{Hash, Hasher};
+use std::marker::PhantomData;
+
+use crate::internal::Family;
+use crate::track::{from_parts, to_parts, Track, Trackable, Tracked};
+
+/// An argument to a cached function.
+pub trait Input {
+    /// Describes an instance of the argument.
+    type Constraint: Default + 'static;
+
+    /// The argument with constraints hooked in.
+    type Hooked: for<'f> Family<'f>;
+
+    /// Hash the argument if it is a _key_ argument
+    fn key<H: Hasher>(&self, state: &mut H);
+
+    /// Validate the argument if it is a _tracked_ argument.
+    fn valid(&self, constraint: &Self::Constraint) -> bool;
+
+    /// Hook up the given constraints if this is a _tracked_ argument.
+    fn hook_up<'f>(
+        self,
+        constraint: &'f Self::Constraint,
+    ) -> <Self::Hooked as Family<'f>>::Out
+    where
+        Self: 'f;
+}
+
+impl<T: Hash> Input for T {
+    /// No constraint for hashed arguments.
+    type Constraint = ();
+
+    /// The hooked-up type is just `Self`.
+    type Hooked = IdFamily<Self>;
+
+    fn key<H: Hasher>(&self, state: &mut H) {
+        Hash::hash(self, state);
+    }
+
+    fn valid(&self, _: &()) -> bool {
+        true
+    }
+
+    fn hook_up<'f>(self, _: &'f ()) -> Self
+    where
+        Self: 'f,
+    {
+        self
+    }
+}
+
+impl<'a, T: Track> Input for Tracked<'a, T> {
+    /// Forwarded constraint from Trackable implementation.
+    type Constraint = <T as Trackable>::Constraint;
+
+    /// The hooked-up type is `Tracked<'f, T>`.
+    type Hooked = TrackedFamily<T>;
+
+    fn key<H: Hasher>(&self, _: &mut H) {}
+
+    fn valid(&self, constraint: &Self::Constraint) -> bool {
+        Trackable::valid(to_parts(*self).0, constraint)
+    }
+
+    fn hook_up<'f>(self, constraint: &'f Self::Constraint) -> Tracked<'f, T>
+    where
+        Self: 'f,
+    {
+        from_parts(to_parts(self).0, Some(constraint))
+    }
+}
+
+/// Identity type constructor.
+pub struct IdFamily<T>(PhantomData<T>);
+
+impl<T> Family<'_> for IdFamily<T> {
+    type Out = T;
+}
+
+/// 'f -> Tracked<'f, T> type constructor.
+pub struct TrackedFamily<T>(PhantomData<T>);
+
+impl<'f, T: Track + 'f> Family<'f> for TrackedFamily<T> {
+    type Out = Tracked<'f, T>;
+}

src/lib.rs

@@ -2,6 +2,7 @@
 
 mod cache;
 mod hash;
+mod input;
 mod track;
 
 pub use crate::track::{Track, Tracked};
@@ -12,5 +13,11 @@ pub use comemo_macros::{memoize, track};
 pub mod internal {
     pub use crate::cache::CACHE;
     pub use crate::hash::HashConstraint;
-    pub use crate::track::{from_parts, to_parts, Family, Trackable};
+    pub use crate::track::{from_parts, to_parts, Trackable};
+
+    /// Helper trait for lifetime type families.
+    pub trait Family<'a> {
+        /// The concrete type with lifetime 'a.
+        type Out;
+    }
 }

src/main.rs

@@ -55,10 +55,7 @@ const _: () = {
                     && constraint.height.valid(&self.height())
             }
 
-            fn surface<'a, 'r>(tracked: &'r Tracked<'a, Image>) -> &'r Surface<'a>
-            where
-                Self: Track,
-            {
+            fn surface<'a, 'r>(tracked: &'r Tracked<'a, Image>) -> &'r Surface<'a> {
                 // Safety: Surface is repr(transparent).
                 unsafe { &*(tracked as *const _ as *const _) }
             }

src/track.rs

@@ -1,5 +1,7 @@
 use std::ops::Deref;
 
+use crate::internal::Family;
+
 /// Tracks accesses to a value.
 ///
 /// Encapsulates a reference to a value and tracks all accesses to it. The only
@@ -44,25 +46,6 @@ where
     }
 }
 
-/// Destructure a `Tracked<_>` into its parts.
-pub fn to_parts<T>(tracked: Tracked<T>) -> (&T, Option<&T::Constraint>)
-where
-    T: Track,
-{
-    (tracked.inner, tracked.constraint)
-}
-
-/// Create a `Tracked<_>` from its parts.
-pub fn from_parts<'a, T>(
-    inner: &'a T,
-    constraint: Option<&'a T::Constraint>,
-) -> Tracked<'a, T>
-where
-    T: Track,
-{
-    Tracked { inner, constraint }
-}
-
 /// A trackable type.
 ///
 /// This is implemented by types that have an implementation block annoted with
@@ -93,8 +76,21 @@ pub trait Trackable: 'static {
         Self: Track;
 }
 
-/// Workaround for Surface<'a> until GATs are stable.
-pub trait Family<'a> {
-    /// The surface with lifetime.
-    type Out;
+/// Destructure a `Tracked<_>` into its parts.
+pub fn to_parts<T>(tracked: Tracked<T>) -> (&T, Option<&T::Constraint>)
+where
+    T: Track,
+{
+    (tracked.inner, tracked.constraint)
+}
+
+/// Create a `Tracked<_>` from its parts.
+pub fn from_parts<'a, T>(
+    inner: &'a T,
+    constraint: Option<&'a T::Constraint>,
+) -> Tracked<'a, T>
+where
+    T: Track,
+{
+    Tracked { inner, constraint }
 }