Rename Args to Multi

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! { |::comemo::internal::Args(#param_tuple)| -> #output #body };
+    let closure = quote! { |::comemo::internal::Multi(#param_tuple)| -> #output #body };
 
     // Adjust the function's body.
     let mut wrapped = function.item.clone();
@@ -148,7 +148,7 @@ fn process(function: &Function) -> Result<TokenStream> {
 
     wrapped.block = parse_quote! { {
         static __CACHE: ::comemo::internal::Cache<
-            <::comemo::internal::Args<#arg_ty_tuple> as ::comemo::internal::Input>::Constraint,
+            <::comemo::internal::Multi<#arg_ty_tuple> as ::comemo::internal::Input>::Constraint,
             #output,
         > = ::comemo::internal::Cache::new(|| {
             ::comemo::internal::register_evictor(|max_age| __CACHE.evict(max_age));
@@ -158,7 +158,7 @@ fn process(function: &Function) -> Result<TokenStream> {
         #(#bounds;)*
 
         ::comemo::internal::memoized(
-            ::comemo::internal::Args(#arg_tuple),
+            ::comemo::internal::Multi(#arg_tuple),
             &::core::default::Default::default(),
             &__CACHE,
             #enabled,

src/input.rs

@@ -117,12 +117,12 @@ where
 }
 
 /// Wrapper for multiple inputs.
-pub struct Args<T>(pub T);
+pub struct Multi<T>(pub T);
 
-macro_rules! args_input {
+macro_rules! multi {
     ($($param:tt $alt:tt $idx:tt ),*) => {
         #[allow(unused_variables, non_snake_case)]
-        impl<'a, $($param: Input<'a>),*> Input<'a> for Args<($($param,)*)> {
+        impl<'a, $($param: Input<'a>),*> Input<'a> for Multi<($($param,)*)> {
             type Constraint = ($($param::Constraint,)*);
             type Outer = ($($param::Outer,)*);
 
@@ -147,7 +147,7 @@ macro_rules! args_input {
                 constraint: &'a Self::Constraint,
             ) -> (Self, Self::Outer) {
                 $(let $param = (self.0).$idx.retrack(&constraint.$idx);)*
-                (Args(($($param.0,)*)), ($($param.1,)*))
+                (Multi(($($param.0,)*)), ($($param.1,)*))
             }
         }
 
@@ -166,16 +166,16 @@ macro_rules! args_input {
     };
 }
 
-args_input! {}
-args_input! { A Z 0 }
-args_input! { A Z 0, B Y 1 }
-args_input! { A Z 0, B Y 1, C X 2 }
-args_input! { A Z 0, B Y 1, C X 2, D W 3 }
-args_input! { A Z 0, B Y 1, C X 2, D W 3, E V 4 }
-args_input! { A Z 0, B Y 1, C X 2, D W 3, E V 4, F U 5 }
-args_input! { A Z 0, B Y 1, C X 2, D W 3, E V 4, F U 5, G T 6 }
-args_input! { A Z 0, B Y 1, C X 2, D W 3, E V 4, F U 5, G T 6, H S 7 }
-args_input! { A Z 0, B Y 1, C X 2, D W 3, E V 4, F U 5, G T 6, H S 7, I R 8 }
-args_input! { A Z 0, B Y 1, C X 2, D W 3, E V 4, F U 5, G T 6, H S 7, I R 8, J Q 9 }
-args_input! { A Z 0, B Y 1, C X 2, D W 3, E V 4, F U 5, G T 6, H S 7, I R 8, J Q 9, K P 10 }
-args_input! { A Z 0, B Y 1, C X 2, D W 3, E V 4, F U 5, G T 6, H S 7, I R 8, J Q 9, K P 10, L O 11 }
+multi! {}
+multi! { A Z 0 }
+multi! { A Z 0, B Y 1 }
+multi! { A Z 0, B Y 1, C X 2 }
+multi! { A Z 0, B Y 1, C X 2, D W 3 }
+multi! { A Z 0, B Y 1, C X 2, D W 3, E V 4 }
+multi! { A Z 0, B Y 1, C X 2, D W 3, E V 4, F U 5 }
+multi! { A Z 0, B Y 1, C X 2, D W 3, E V 4, F U 5, G T 6 }
+multi! { A Z 0, B Y 1, C X 2, D W 3, E V 4, F U 5, G T 6, H S 7 }
+multi! { A Z 0, B Y 1, C X 2, D W 3, E V 4, F U 5, G T 6, H S 7, I R 8 }
+multi! { A Z 0, B Y 1, C X 2, D W 3, E V 4, F U 5, G T 6, H S 7, I R 8, J Q 9 }
+multi! { A Z 0, B Y 1, C X 2, D W 3, E V 4, F U 5, G T 6, H S 7, I R 8, J Q 9, K P 10 }
+multi! { A Z 0, B Y 1, C X 2, D W 3, E V 4, F U 5, G T 6, H S 7, I R 8, J Q 9, K P 10, L O 11 }

src/lib.rs

@@ -110,7 +110,7 @@ pub mod internal {
     pub use crate::cache::{Cache, CacheData, memoized, register_evictor};
     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::input::{Input, Multi, assert_hashable_or_trackable};
     pub use crate::track::{Surfaces, to_parts_mut_mut, to_parts_mut_ref, to_parts_ref};
 
     #[cfg(feature = "testing")]