Expose constraints

Author: laurmaedje

macros/src/track.rs

@@ -200,23 +200,23 @@ fn create(
             #(#variants,)*
         }
 
-        impl ::comemo::Track for #ty {}
+        impl ::comemo::Track for #ty {
+            #[inline]
+            fn valid(&self, constraint: &::comemo::Constraint<Self>) -> bool {
+                let mut this = #maybe_cloned;
+                constraint.valid(|call| match &call.0 { #(#validations,)* })
+            }
+        }
 
         #[doc(hidden)]
         impl ::comemo::internal::Trackable for #ty {
             type Call = __ComemoCall;
             type Surface = __ComemoSurfaceFamily;
             type SurfaceMut = __ComemoSurfaceMutFamily;
 
-            #[inline]
-            fn valid(&self, constraint: &::comemo::internal::Constraint<Self::Call>) -> bool {
-                let mut this = #maybe_cloned;
-                constraint.valid(|call| match &call.0 { #(#validations,)* })
-            }
-
             #[inline]
             #[allow(unused_variables)]
-            fn replay(&mut self, constraint: &::comemo::internal::Constraint<Self::Call>) {
+            fn replay(&mut self, constraint: &::comemo::Constraint<Self>) {
                 constraint.replay(|call| match &call.0 { #(#replays,)* });
             }
 

src/constraint.rs

@@ -3,9 +3,14 @@ use std::hash::Hash;
 
 use siphasher::sip128::{Hasher128, SipHasher};
 
+use crate::track::Trackable;
+
 /// Defines a constraint for a tracked method without arguments.
-pub struct Constraint<Call> {
-    calls: RefCell<Vec<Entry<Call>>>,
+pub struct Constraint<T>
+where
+    T: Trackable + ?Sized,
+{
+    calls: RefCell<Vec<Entry<T::Call>>>,
 }
 
 /// A call entry.
@@ -15,13 +20,21 @@ struct Entry<Call> {
     mutable: bool,
 }
 
-impl<Call> Constraint<Call>
+impl<T> Constraint<T>
 where
-    Call: Clone + PartialEq,
+    T: Trackable + ?Sized,
 {
+    /// Create empty constraints.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
     /// Enter a constraint for a call to an immutable function.
+    ///
+    /// This method is not part of the public API!
     #[inline]
-    pub fn push(&self, call: Call, hash: u128, mutable: bool) {
+    #[doc(hidden)]
+    pub fn push(&self, call: T::Call, hash: u128, mutable: bool) {
         let mut calls = self.calls.borrow_mut();
 
         if !mutable {
@@ -41,19 +54,25 @@ where
     }
 
     /// Whether the method satisfies as all input-output pairs.
+    ///
+    /// This method is not part of the public API!
     #[inline]
+    #[doc(hidden)]
     pub fn valid<F>(&self, mut f: F) -> bool
     where
-        F: FnMut(&Call) -> u128,
+        F: FnMut(&T::Call) -> u128,
     {
         self.calls.borrow().iter().all(|entry| f(&entry.call) == entry.hash)
     }
 
     /// Replay all input-output pairs.
+    ///
+    /// This method is not part of the public API!
     #[inline]
+    #[doc(hidden)]
     pub fn replay<F>(&self, mut f: F)
     where
-        F: FnMut(&Call),
+        F: FnMut(&T::Call),
     {
         for entry in self.calls.borrow().iter() {
             if entry.mutable {
@@ -63,9 +82,9 @@ where
     }
 }
 
-impl<Call> Default for Constraint<Call>
+impl<T> Default for Constraint<T>
 where
-    Call: Clone + PartialEq,
+    T: Trackable + ?Sized,
 {
     fn default() -> Self {
         Self { calls: RefCell::new(vec![]) }
@@ -87,9 +106,9 @@ impl<T: Join> Join<T> for Option<&T> {
     }
 }
 
-impl<Call> Join for Constraint<Call>
+impl<T> Join for Constraint<T>
 where
-    Call: Clone + PartialEq,
+    T: Trackable + ?Sized,
 {
     #[inline]
     fn join(&self, inner: &Self) {

src/input.rs

@@ -3,7 +3,7 @@ use std::marker::PhantomData;
 
 use crate::constraint::{Constraint, Join};
 use crate::internal::Family;
-use crate::track::{Track, Trackable, Tracked, TrackedMut};
+use crate::track::{Track, Tracked, TrackedMut};
 
 /// Ensure a type is suitable as input.
 #[inline]
@@ -85,16 +85,16 @@ where
     T: Track + ?Sized,
 {
     // Forward constraint from `Trackable` implementation.
-    type Constraint = Constraint<T::Call>;
+    type Constraint = Constraint<T>;
     type Tracked = TrackedFamily<T>;
-    type Outer = Option<&'a Constraint<T::Call>>;
+    type Outer = Option<&'a Constraint<T>>;
 
     #[inline]
     fn key<H: Hasher>(&self, _: &mut H) {}
 
     #[inline]
     fn valid(&self, constraint: &Self::Constraint) -> bool {
-        Trackable::valid(self.value, constraint)
+        self.value.valid(constraint)
     }
 
     #[inline]
@@ -104,7 +104,7 @@ where
     fn retrack<'r>(
         self,
         constraint: &'r Self::Constraint,
-    ) -> (Tracked<'r, T>, Option<&'a Constraint<T::Call>>)
+    ) -> (Tracked<'r, T>, Option<&'a Constraint<T>>)
     where
         Self: 'r,
     {
@@ -131,16 +131,16 @@ where
     T: Track + ?Sized,
 {
     // Forward constraint from `Trackable` implementation.
-    type Constraint = Constraint<T::Call>;
+    type Constraint = Constraint<T>;
     type Tracked = TrackedMutFamily<T>;
-    type Outer = Option<&'a Constraint<T::Call>>;
+    type Outer = Option<&'a Constraint<T>>;
 
     #[inline]
     fn key<H: Hasher>(&self, _: &mut H) {}
 
     #[inline]
     fn valid(&self, constraint: &Self::Constraint) -> bool {
-        Trackable::valid(self.value, constraint)
+        self.value.valid(constraint)
     }
 
     #[inline]
@@ -152,7 +152,7 @@ where
     fn retrack<'r>(
         self,
         constraint: &'r Self::Constraint,
-    ) -> (TrackedMut<'r, T>, Option<&'a Constraint<T::Call>>)
+    ) -> (TrackedMut<'r, T>, Option<&'a Constraint<T>>)
     where
         Self: 'r,
     {

src/lib.rs

@@ -89,6 +89,7 @@ mod prehashed;
 mod track;
 
 pub use crate::cache::evict;
+pub use crate::constraint::Constraint;
 pub use crate::prehashed::Prehashed;
 pub use crate::track::{Track, Tracked, TrackedMut};
 pub use comemo_macros::{memoize, track};
@@ -97,7 +98,7 @@ pub use comemo_macros::{memoize, track};
 #[doc(hidden)]
 pub mod internal {
     pub use crate::cache::{last_was_hit, memoized};
-    pub use crate::constraint::{hash, Constraint};
+    pub use crate::constraint::hash;
     pub use crate::input::{assert_hashable_or_trackable, Args};
     pub use crate::track::{to_parts_mut_mut, to_parts_mut_ref, to_parts_ref, Trackable};
 

src/track.rs

@@ -21,6 +21,32 @@ pub trait Track: Trackable {
     fn track_mut(&mut self) -> TrackedMut<Self> {
         TrackedMut { value: self, constraint: None }
     }
+
+    /// Start tracking all accesses into a constraint.
+    #[inline]
+    fn track_with<'a>(&'a self, constraint: &'a Constraint<Self>) -> Tracked<'a, Self> {
+        Tracked {
+            value: self,
+            constraint: Some(constraint),
+        }
+    }
+
+    /// Start tracking all accesses and mutations into a constraint.
+    #[inline]
+    fn track_mut_with<'a>(
+        &'a mut self,
+        constraint: &'a Constraint<Self>,
+    ) -> TrackedMut<'a, Self> {
+        TrackedMut {
+            value: self,
+            constraint: Some(constraint),
+        }
+    }
+
+    /// Whether this value fulfills the given constraints.
+    ///
+    /// Such constraints can be generated with `track_with` or `track_mut_with`.
+    fn valid(&self, constraint: &Constraint<Self>) -> bool;
 }
 
 /// Non-exposed parts of the `Track` trait.
@@ -34,11 +60,8 @@ pub trait Trackable: 'static {
     /// The mutable tracked API surface of this type.
     type SurfaceMut: for<'a> Family<'a>;
 
-    /// Whether an instance fulfills the given constraint.
-    fn valid(&self, constraint: &Constraint<Self::Call>) -> bool;
-
     /// Replay mutations to the value.
-    fn replay(&mut self, constraint: &Constraint<Self::Call>);
+    fn replay(&mut self, constraint: &Constraint<Self>);
 
     /// Access the immutable surface from a `Tracked`.
     fn surface_ref<'a, 't>(
@@ -79,7 +102,7 @@ where
     ///
     /// Starts out as `None` and is set to a stack-stored constraint in the
     /// preamble of memoized functions.
-    pub(crate) constraint: Option<&'a Constraint<T::Call>>,
+    pub(crate) constraint: Option<&'a Constraint<T>>,
 }
 
 // The type `Tracked<T>` automatically dereferences to T's generated surface
@@ -136,7 +159,7 @@ where
     ///
     /// Starts out as `None` and is set to a stack-stored constraint in the
     /// preamble of memoized functions.
-    pub(crate) constraint: Option<&'a Constraint<T::Call>>,
+    pub(crate) constraint: Option<&'a Constraint<T>>,
 }
 
 impl<'a, T> TrackedMut<'a, T>
@@ -214,7 +237,7 @@ where
 
 /// Destructure a `Tracked<_>` into its parts.
 #[inline]
-pub fn to_parts_ref<T>(tracked: Tracked<T>) -> (&T, Option<&Constraint<T::Call>>)
+pub fn to_parts_ref<T>(tracked: Tracked<T>) -> (&T, Option<&Constraint<T>>)
 where
     T: Track + ?Sized,
 {
@@ -225,7 +248,7 @@ where
 #[inline]
 pub fn to_parts_mut_ref<'a, T>(
     tracked: &'a TrackedMut<T>,
-) -> (&'a T, Option<&'a Constraint<T::Call>>)
+) -> (&'a T, Option<&'a Constraint<T>>)
 where
     T: Track + ?Sized,
 {
@@ -236,7 +259,7 @@ where
 #[inline]
 pub fn to_parts_mut_mut<'a, T>(
     tracked: &'a mut TrackedMut<T>,
-) -> (&'a mut T, Option<&'a Constraint<T::Call>>)
+) -> (&'a mut T, Option<&'a Constraint<T>>)
 where
     T: Track + ?Sized,
 {