Remove playground and debug printing

Author: laurmaedje

macros/src/memoize.rs

@@ -20,7 +20,6 @@ pub fn expand(item: &syn::Item) -> Result<proc_macro2::TokenStream> {
 /// Details about a function that should be memoized.
 struct Function {
     item: syn::ItemFn,
-    name: syn::Ident,
     args: Vec<Argument>,
     output: syn::Type,
 }
@@ -55,12 +54,7 @@ fn prepare(function: &syn::ItemFn) -> Result<Function> {
         syn::ReturnType::Type(_, ty) => ty.as_ref().clone(),
     };
 
-    Ok(Function {
-        item: function.clone(),
-        name: function.sig.ident.clone(),
-        args,
-        output,
-    })
+    Ok(Function { item: function.clone(), args, output })
 }
 
 /// Preprocess a function argument.
@@ -135,14 +129,12 @@ fn process(function: &Function) -> Result<TokenStream> {
 
     // Adjust the function's body.
     let mut wrapped = function.item.clone();
-    let name = function.name.to_string();
     let unique = quote! { __ComemoUnique };
 
     wrapped.block = parse_quote! { {
         struct #unique;
         #(#bounds;)*
         ::comemo::internal::memoized(
-            #name,
             ::core::any::TypeId::of::<#unique>(),
             ::comemo::internal::Args(#arg_tuple),
             #closure,

macros/src/track.rs

@@ -44,7 +44,6 @@ pub fn expand(item: &syn::Item) -> Result<TokenStream> {
 
 /// Details about a method that should be tracked.
 struct Method {
-    name: syn::Ident,
     vis: syn::Visibility,
     sig: syn::Signature,
     args: Vec<syn::Ident>,
@@ -168,7 +167,6 @@ fn prepare_method(vis: syn::Visibility, sig: &syn::Signature) -> Result<Method>
     }
 
     Ok(Method {
-        name: sig.ident.clone(),
         vis,
         sig: sig.clone(),
         args,
@@ -240,7 +238,7 @@ fn create(
 
 /// Produce a constraint validation for a method.
 fn create_validation(method: &Method) -> TokenStream {
-    let name = &method.name;
+    let name = &method.sig.ident;
     let args = &method.args;
     let prepared = method.args.iter().zip(&method.kinds).map(|(arg, kind)| match kind {
         Kind::Normal => quote! { #arg.to_owned() },
@@ -256,7 +254,7 @@ fn create_validation(method: &Method) -> TokenStream {
 fn create_wrapper(method: &Method) -> TokenStream {
     let vis = &method.vis;
     let sig = &method.sig;
-    let name = &method.name;
+    let name = &method.sig.ident;
     let args = &method.args;
     quote! {
         #vis #sig {
@@ -273,7 +271,7 @@ fn create_wrapper(method: &Method) -> TokenStream {
 
 /// Produce a constraint field for a method.
 fn create_constraint(method: &Method) -> TokenStream {
-    let name = &method.name;
+    let name = &method.sig.ident;
     let types = &method.types;
     if types.is_empty() {
         quote! { #name: ::comemo::internal::SoloConstraint, }
@@ -288,6 +286,6 @@ fn create_constraint(method: &Method) -> TokenStream {
 
 /// Produce a join call for a method's constraint.
 fn create_join(method: &Method) -> TokenStream {
-    let name = &method.name;
+    let name = &method.sig.ident;
     quote! { self.#name.join(&inner.#name); }
 }

src/cache.rs

@@ -14,61 +14,6 @@ thread_local! {
     static CACHE: RefCell<Cache> = RefCell::new(Cache::default());
 }
 
-/// Execute a function or use a cached result for it.
-pub fn memoized<In, Out, F>(name: &'static str, id: TypeId, input: In, func: F) -> Out
-where
-    In: Input,
-    Out: Debug + Clone + 'static,
-    F: for<'f> FnOnce(<In::Tracked as Family<'f>>::Out) -> Out,
-{
-    CACHE.with(|cache| {
-        // Compute the hash of the input's key part.
-        let key = {
-            let mut state = SipHasher::new();
-            input.key(&mut state);
-            let hash = state.finish128().as_u128();
-            (id, hash)
-        };
-
-        let mut hit = true;
-        let mut borrowed = cache.borrow_mut();
-
-        // Check whether there is a cached entry.
-        let output = match borrowed.lookup::<In, Out>(key, &input) {
-            Some(output) => output,
-            None => {
-                hit = false;
-                borrowed.depth += 1;
-                drop(borrowed);
-
-                // Point all tracked parts of the input to these constraints.
-                let constraint = In::Constraint::default();
-                let (tracked, outer) = input.retrack(&constraint);
-
-                // Execute the function with the new constraints hooked in.
-                let output = func(tracked);
-
-                // Add the new constraints to the previous outer ones.
-                outer.join(&constraint);
-
-                // Insert the result into the cache.
-                borrowed = cache.borrow_mut();
-                borrowed.insert::<In, Out>(key, constraint, output.clone());
-                borrowed.depth -= 1;
-
-                output
-            }
-        };
-
-        // Print details.
-        let depth = borrowed.depth;
-        let label = if hit { "[hit]" } else { "[miss]" };
-        eprintln!("{depth} {name:<12} {label:<7} {output:?}");
-
-        output
-    })
-}
-
 /// Configure the caching behaviour.
 pub fn config(config: Config) {
     CACHE.with(|cache| cache.borrow_mut().config = config);
@@ -109,6 +54,50 @@ pub fn evict() {
     });
 }
 
+/// Execute a function or use a cached result for it.
+pub fn memoized<In, Out, F>(id: TypeId, input: In, func: F) -> Out
+where
+    In: Input,
+    Out: Debug + Clone + 'static,
+    F: for<'f> FnOnce(<In::Tracked as Family<'f>>::Out) -> Out,
+{
+    CACHE.with(|cache| {
+        // Compute the hash of the input's key part.
+        let key = {
+            let mut state = SipHasher::new();
+            input.key(&mut state);
+            let hash = state.finish128().as_u128();
+            (id, hash)
+        };
+
+        // Check if there is a cached output.
+        let mut borrow = cache.borrow_mut();
+        if let Some(output) = borrow.lookup::<In, Out>(key, &input) {
+            return output;
+        }
+
+        borrow.depth += 1;
+        drop(borrow);
+
+        // Point all tracked parts of the input to these constraints.
+        let constraint = In::Constraint::default();
+        let (tracked, outer) = input.retrack(&constraint);
+
+        // Execute the function with the new constraints hooked in.
+        let output = func(tracked);
+
+        // Add the new constraints to the previous outer ones.
+        outer.join(&constraint);
+
+        // Insert the result into the cache.
+        borrow = cache.borrow_mut();
+        borrow.insert::<In, Out>(key, constraint, output.clone());
+        borrow.depth -= 1;
+
+        output
+    })
+}
+
 /// The global cache.
 #[derive(Default)]
 struct Cache {
@@ -189,6 +178,7 @@ impl Entry {
     {
         let Constrained::<In::Constraint, Out> { constraint, output } =
             self.constrained.downcast_ref().expect("wrong entry type");
+
         input.valid(constraint).then(|| {
             self.age = 0;
             output.clone()

src/main.rs

@@ -15,7 +15,7 @@ use siphasher::sip128::{Hasher128, SipHasher};
 /// # `Hash` and `Eq`
 /// When implementing both `Hash` and `Eq`, the following property [must
 /// hold][property]:
-/// ```
+/// ```text
 /// a == b -> hash(a) == hash(b)
 /// ```
 /// The inverse implication does not follow from this immediately. However,