Simplify lifetime setup (#13)

Author: laurmaedje

macros/src/memoize.rs

@@ -134,7 +134,7 @@ fn process(function: &Function) -> Result<TokenStream> {
     // Construct the inner closure.
     let output = &function.output;
     let body = &function.item.block;
-    let closure = quote! { |#param_tuple| -> #output #body };
+    let closure = quote! { |::comemo::internal::Args(#param_tuple)| -> #output #body };
 
     // Adjust the function's body.
     let mut wrapped = function.item.clone();

src/cache.rs

@@ -19,17 +19,17 @@ thread_local! {
 }
 
 /// Execute a function or use a cached result for it.
-pub fn memoized<'c, In, Out, F>(
+pub fn memoized<'a, In, Out, F>(
     mut input: In,
-    constraint: &'c In::Constraint,
+    constraint: &'a In::Constraint,
     cache: &Cache<In::Constraint, Out>,
     enabled: bool,
     func: F,
 ) -> Out
 where
-    In: Input + 'c,
+    In: Input<'a>,
     Out: Clone + 'static,
-    F: FnOnce(In::Tracked<'c>) -> Out,
+    F: FnOnce(In) -> Out,
 {
     // Early bypass if memoization is disabled.
     // Hopefully the compiler will optimize this away, if the condition is constant.
@@ -80,15 +80,15 @@ where
     output
 }
 
-fn memoized_disabled<'c, In, Out, F>(
+fn memoized_disabled<'a, In, Out, F>(
     input: In,
-    constraint: &'c In::Constraint,
+    constraint: &'a In::Constraint,
     func: F,
 ) -> Out
 where
-    In: Input + 'c,
+    In: Input<'a>,
     Out: Clone + 'static,
-    F: FnOnce(In::Tracked<'c>) -> Out,
+    F: FnOnce(In) -> Out,
 {
     // Execute the function with the new constraints hooked in.
     let (input, outer) = input.retrack(constraint);
@@ -168,9 +168,9 @@ impl<C, Out: 'static> CacheData<C, Out> {
     }
 
     /// Look for a matching entry in the cache.
-    fn lookup<In>(&self, key: u128, input: &In) -> Option<(&In::Constraint, &Out)>
+    fn lookup<'a, In>(&self, key: u128, input: &In) -> Option<(&In::Constraint, &Out)>
     where
-        In: Input<Constraint = C>,
+        In: Input<'a, Constraint = C>,
     {
         self.entries
             .get(&key)?
@@ -180,9 +180,9 @@ impl<C, Out: 'static> CacheData<C, Out> {
     }
 
     /// Insert an entry into the cache.
-    fn insert<In>(&mut self, key: u128, constraint: In::Constraint, output: Out)
+    fn insert<'a, In>(&mut self, key: u128, constraint: In::Constraint, output: Out)
     where
-        In: Input<Constraint = C>,
+        In: Input<'a, Constraint = C>,
     {
         self.entries
             .entry(key)
@@ -209,17 +209,17 @@ struct CacheEntry<C, Out> {
 
 impl<C, Out: 'static> CacheEntry<C, Out> {
     /// Create a new entry.
-    fn new<In>(constraint: In::Constraint, output: Out) -> Self
+    fn new<'a, In>(constraint: In::Constraint, output: Out) -> Self
     where
-        In: Input<Constraint = C>,
+        In: Input<'a, Constraint = C>,
     {
         Self { constraint, output, age: AtomicUsize::new(0) }
     }
 
     /// Return the entry's output if it is valid for the given input.
-    fn lookup<In>(&self, input: &In) -> Option<(&In::Constraint, &Out)>
+    fn lookup<'a, In>(&self, input: &In) -> Option<(&In::Constraint, &Out)>
     where
-        In: Input<Constraint = C>,
+        In: Input<'a, Constraint = C>,
     {
         input.validate(&self.constraint).then(|| {
             self.age.store(0, Ordering::SeqCst);

src/input.rs

@@ -5,21 +5,16 @@ use crate::track::{Track, Tracked, TrackedMut, Validate};
 
 /// Ensure a type is suitable as input.
 #[inline]
-pub fn assert_hashable_or_trackable<In: Input>(_: &In) {}
+pub fn assert_hashable_or_trackable<'a, In: Input<'a>>(_: &In) {}
 
 /// An input to a cached function.
 ///
 /// This is implemented for hashable types, `Tracked<_>` types and `Args<(...)>`
 /// types containing tuples up to length twelve.
-pub trait Input {
+pub trait Input<'a> {
     /// The constraints for this input.
     type Constraint: Default + Clone + Join + 'static;
 
-    /// The input with new constraints hooked in.
-    type Tracked<'r>
-    where
-        Self: 'r;
-
     /// The extracted outer constraints.
     type Outer: Join<Self::Constraint>;
 
@@ -34,21 +29,14 @@ pub trait Input {
 
     /// Hook up the given constraint to the tracked parts of the input and
     /// return the result alongside the outer constraints.
-    fn retrack<'r>(
-        self,
-        constraint: &'r Self::Constraint,
-    ) -> (Self::Tracked<'r>, Self::Outer)
+    fn retrack(self, constraint: &'a Self::Constraint) -> (Self, Self::Outer)
     where
-        Self: 'r;
+        Self: Sized;
 }
 
-impl<T: Hash> Input for T {
+impl<'a, T: Hash> Input<'a> for T {
     // No constraint for hashed inputs.
     type Constraint = ();
-    type Tracked<'r>
-        = Self
-    where
-        Self: 'r;
     type Outer = ();
 
     #[inline]
@@ -65,24 +53,17 @@ impl<T: Hash> Input for T {
     fn replay(&mut self, _: &Self::Constraint) {}
 
     #[inline]
-    fn retrack<'r>(self, _: &'r ()) -> (Self::Tracked<'r>, Self::Outer)
-    where
-        Self: 'r,
-    {
+    fn retrack(self, _: &'a ()) -> (Self, Self::Outer) {
         (self, ())
     }
 }
 
-impl<'a, T> Input for Tracked<'a, T>
+impl<'a, T> Input<'a> for Tracked<'a, T>
 where
     T: Track + ?Sized,
 {
     // Forward constraint from `Trackable` implementation.
     type Constraint = <T as Validate>::Constraint;
-    type Tracked<'r>
-        = Tracked<'r, T>
-    where
-        Self: 'r;
     type Outer = Option<&'a Self::Constraint>;
 
     #[inline]
@@ -97,13 +78,7 @@ where
     fn replay(&mut self, _: &Self::Constraint) {}
 
     #[inline]
-    fn retrack<'r>(
-        self,
-        constraint: &'r Self::Constraint,
-    ) -> (Self::Tracked<'r>, Self::Outer)
-    where
-        Self: 'r,
-    {
+    fn retrack(self, constraint: &'a Self::Constraint) -> (Self, Self::Outer) {
         let tracked = Tracked {
             value: self.value,
             constraint: Some(constraint),
@@ -113,16 +88,12 @@ where
     }
 }
 
-impl<'a, T> Input for TrackedMut<'a, T>
+impl<'a, T> Input<'a> for TrackedMut<'a, T>
 where
     T: Track + ?Sized,
 {
     // Forward constraint from `Trackable` implementation.
     type Constraint = T::Constraint;
-    type Tracked<'r>
-        = TrackedMut<'r, T>
-    where
-        Self: 'r;
     type Outer = Option<&'a Self::Constraint>;
 
     #[inline]
@@ -139,13 +110,7 @@ where
     }
 
     #[inline]
-    fn retrack<'r>(
-        self,
-        constraint: &'r Self::Constraint,
-    ) -> (Self::Tracked<'r>, Self::Outer)
-    where
-        Self: 'r,
-    {
+    fn retrack(self, constraint: &'a Self::Constraint) -> (Self, Self::Outer) {
         let tracked = TrackedMut { value: self.value, constraint: Some(constraint) };
         (tracked, self.constraint)
     }
@@ -157,9 +122,8 @@ pub struct Args<T>(pub T);
 macro_rules! args_input {
     ($($param:tt $alt:tt $idx:tt ),*) => {
         #[allow(unused_variables, non_snake_case)]
-        impl<$($param: Input),*> Input for Args<($($param,)*)> {
+        impl<'a, $($param: Input<'a>),*> Input<'a> for Args<($($param,)*)> {
             type Constraint = ($($param::Constraint,)*);
-            type Tracked<'r> = ($($param::Tracked<'r>,)*) where Self: 'r;
             type Outer = ($($param::Outer,)*);
 
             #[inline]
@@ -178,15 +142,12 @@ macro_rules! args_input {
             }
 
             #[inline]
-            fn retrack<'r>(
+            fn retrack(
                 self,
-                constraint: &'r Self::Constraint,
-            ) -> (Self::Tracked<'r>, Self::Outer)
-            where
-                Self: 'r,
-            {
+                constraint: &'a Self::Constraint,
+            ) -> (Self, Self::Outer) {
                 $(let $param = (self.0).$idx.retrack(&constraint.$idx);)*
-                (($($param.0,)*), ($($param.1,)*))
+                (Args(($($param.0,)*)), ($($param.1,)*))
             }
         }