Support antijoins on arbitrary prefixes

Author: ecstatic-morse

src/join.rs

@@ -98,21 +98,26 @@ where
 }
 
 /// Moves all recent tuples from `input1` that are not present in `input2` into `output`.
-pub(crate) fn antijoin<Key: Ord, Val: Ord, Result: Ord>(
-    input1: &Relation<(Key, Val)>,
-    input2: &Relation<Key>,
-    mut logic: impl FnMut(&Key, &Val) -> Result,
-) -> Relation<Result> {
+pub(crate) fn antijoin<P, A, O>(
+    input1: &Relation<A>,
+    input2: &Relation<P>,
+    mut logic: impl FnMut(A) -> O,
+) -> Relation<O>
+where
+    A: Copy + Split<P>,
+    P: Ord,
+    O: Ord,
+{
     let mut tuples2 = &input2[..];
 
     let results = input1
         .elements
         .iter()
-        .filter(|(ref key, _)| {
-            tuples2 = gallop(tuples2, |k| k < key);
-            tuples2.first() != Some(key)
+        .filter(|el| {
+            tuples2 = gallop(tuples2, |p| p < &el.prefix());
+            tuples2.first() != Some(&el.prefix())
         })
-        .map(|(ref key, ref val)| logic(key, val))
+        .map(|&el| logic(el))
         .collect::<Vec<_>>();
 
     Relation::from_vec(results)

src/relation.rs

@@ -67,11 +67,15 @@ impl<Tuple: Ord> Relation<Tuple> {
     /// tuples with the `logic` closure. Like
     /// [`Variable::from_antijoin`] except for use where the inputs
     /// are not varying across iterations.
-    pub fn from_antijoin<Key: Ord, Val1: Ord>(
-        input1: &Relation<(Key, Val1)>,
-        input2: &Relation<Key>,
-        logic: impl FnMut(&Key, &Val1) -> Tuple,
-    ) -> Self {
+    pub fn from_antijoin<P, A>(
+        input1: &Relation<A>,
+        input2: &Relation<P>,
+        logic: impl FnMut(A) -> Tuple,
+    ) -> Self
+    where
+        P: Ord,
+        A: Copy + Split<P>
+    {
         join::antijoin(input1, input2, logic)
     }
 

src/variable.rs

@@ -180,12 +180,15 @@ impl<Tuple: Ord> Variable<Tuple> {
     /// let result = variable.complete();
     /// assert_eq!(result.len(), 16);
     /// ```
-    pub fn from_antijoin<K: Ord, V: Ord>(
+    pub fn from_antijoin<P, A>(
         &self,
-        input1: &Variable<(K, V)>,
-        input2: &Relation<K>,
-        logic: impl FnMut(&K, &V) -> Tuple,
-    ) {
+        input1: &Variable<A>,
+        input2: &Relation<P>,
+        logic: impl FnMut(A) -> Tuple,
+    ) where
+        A: Copy + Split<P>,
+        P: Ord,
+    {
         self.insert(join::antijoin(&input1.recent.borrow(), input2, logic))
     }