Overhaul ExtendAnti to support arbitrary prefixes

Author: ecstatic-morse

src/treefrog.rs

@@ -297,17 +297,19 @@ impl<T: Ord + Copy> Relation<T> {
     {
         extend_with::ExtendWith::from(self, key_func)
     }
-}
 
-impl<Key: Ord, Val: Ord> Relation<(Key, Val)> {
     /// Extend with `Val` using the complement of the relation.
-    pub fn extend_anti<'leap, Tuple: Ord, Func: Fn(&Tuple) -> Key>(
-        &'leap self,
-        key_func: Func,
-    ) -> extend_anti::ExtendAnti<'leap, Key, Val, Tuple, Func>
-    where
-        Key: 'leap,
-        Val: 'leap,
+    ///
+    /// This leaper *removes* all proposed values that appear as a suffix in `self` for the prefix
+    /// extracted from the source tuple via `key_func`.
+    ///
+    ///
+    ///
+    /// ```prolog
+    /// step_sibling(X, Y) :- parent(X, P), parent(Y, P), !biological_sibling(X, Y).
+    /// ```
+    pub fn extend_anti<P, F, S>(&self, key_func: F) -> extend_anti::ExtendAnti<'_, P, T, F>
+        where F: Fn(&S) -> P
     {
         extend_anti::ExtendAnti::from(self, key_func)
     }
@@ -419,63 +421,45 @@ pub(crate) mod extend_anti {
 
     use super::{binary_search, Leaper, Relation};
     use crate::join::gallop;
+    use crate::Split;
 
     /// Wraps a Relation<Tuple> as a leaper.
-    pub struct ExtendAnti<'leap, Key, Val, Tuple, Func>
-    where
-        Key: Ord + 'leap,
-        Val: Ord + 'leap,
-        Tuple: Ord,
-        Func: Fn(&Tuple) -> Key,
-    {
-        relation: &'leap Relation<(Key, Val)>,
-        key_func: Func,
-        old_key: Option<(Key, Range<usize>)>,
-        phantom: ::std::marker::PhantomData<Tuple>,
+    pub struct ExtendAnti<'a, P, T, F> {
+        relation: &'a Relation<T>,
+        key_func: F,
+        old_key: Option<(P, Range<usize>)>,
     }
 
-    impl<'leap, Key, Val, Tuple, Func> ExtendAnti<'leap, Key, Val, Tuple, Func>
-    where
-        Key: Ord + 'leap,
-        Val: Ord + 'leap,
-        Tuple: Ord,
-        Func: Fn(&Tuple) -> Key,
-    {
+    impl<'a, P, T, F> ExtendAnti<'a, P, T, F> {
         /// Constructs a ExtendAnti from a relation and key and value function.
-        pub fn from(relation: &'leap Relation<(Key, Val)>, key_func: Func) -> Self {
-            ExtendAnti {
-                relation,
-                key_func,
-                old_key: None,
-                phantom: ::std::marker::PhantomData,
-            }
+        pub fn from(relation: &'a Relation<T>, key_func: F) -> Self {
+            ExtendAnti { relation, key_func, old_key: None }
         }
     }
 
-    impl<'leap, Key: Ord, Val: Ord + 'leap, Tuple: Ord, Func> Leaper<Tuple, Val>
-        for ExtendAnti<'leap, Key, Val, Tuple, Func>
+    impl<P, T, S, F> Leaper<S, T::Suffix> for ExtendAnti<'_, P, T, F>
     where
-        Key: Ord + 'leap,
-        Val: Ord + 'leap,
-        Tuple: Ord,
-        Func: Fn(&Tuple) -> Key,
+        T: Copy + Split<P>,
+        P: Ord,
+        T::Suffix: Ord,
+        F: Fn(&S) -> P,
     {
-        fn count(&mut self, _prefix: &Tuple) -> usize {
+        fn count(&mut self, _prefix: &S) -> usize {
             usize::max_value()
         }
-        fn propose(&mut self, _prefix: &Tuple, _values: &mut Vec<Val>) {
+        fn propose(&mut self, _prefix: &S, _values: &mut Vec<T::Suffix>) {
             panic!("ExtendAnti::propose(): variable apparently unbound.");
         }
-        fn intersect(&mut self, prefix: &Tuple, values: &mut Vec<Val>) {
+        fn intersect(&mut self, prefix: &S, values: &mut Vec<T::Suffix>) {
             let key = (self.key_func)(prefix);
 
             let range = match self.old_key.as_ref() {
                 Some((old, range)) if old == &key => range.clone(),
 
                 _ => {
-                    let start = binary_search(&self.relation.elements, |x| &x.0 < &key);
+                    let start = binary_search(&self.relation.elements, |x| &x.prefix() < &key);
                     let slice1 = &self.relation[start..];
-                    let slice2 = gallop(slice1, |x| &x.0 <= &key);
+                    let slice2 = gallop(slice1, |x| &x.prefix() <= &key);
                     let range = start..self.relation.len()-slice2.len();
 
                     self.old_key = Some((key, range.clone()));
@@ -487,8 +471,8 @@ pub(crate) mod extend_anti {
             let mut slice = &self.relation[range];
             if !slice.is_empty() {
                 values.retain(|v| {
-                    slice = gallop(slice, |kv| &kv.1 < v);
-                    slice.get(0).map(|kv| &kv.1) != Some(v)
+                    slice = gallop(slice, |kv| &kv.suffix() < v);
+                    slice.get(0).map(|kv| kv.suffix()).as_ref() != Some(v)
                 });
             }
         }