enable antijoin from a relation too

Author: nikomatsakis

src/join.rs

@@ -49,17 +49,15 @@ pub(crate) fn join_into_relation<'me, Key: Ord, Val1: Ord, Val2: Ord, Result: Or
 }
 
 /// Moves all recent tuples from `input1` that are not present in `input2` into `output`.
-pub(crate) fn antijoin_into<Key: Ord, Val: Ord, Result: Ord>(
-    input1: &Variable<(Key, Val)>,
+pub(crate) fn antijoin<'me, Key: Ord, Val: Ord, Result: Ord>(
+    input1: impl JoinInput<'me, (Key, Val)>,
     input2: &Relation<Key>,
-    output: &Variable<Result>,
     mut logic: impl FnMut(&Key, &Val) -> Result,
-) {
+) -> Relation<Result> {
     let mut tuples2 = &input2[..];
 
     let results = input1
-        .recent
-        .borrow()
+        .recent()
         .iter()
         .filter(|(ref key, _)| {
             tuples2 = gallop(tuples2, |k| k < key);
@@ -68,7 +66,7 @@ pub(crate) fn antijoin_into<Key: Ord, Val: Ord, Result: Ord>(
         .map(|(ref key, ref val)| logic(key, val))
         .collect::<Vec<_>>();
 
-    output.insert(Relation::from_vec(results));
+    Relation::from_vec(results)
 }
 
 fn join_helper<K: Ord, V1, V2>(

src/lib.rs

@@ -111,6 +111,19 @@ impl<Tuple: Ord> Relation<Tuple> {
         join::join_into_relation(input1, input2, logic)
     }
 
+    /// Creates a `Relation` by removing all values from `input1` that
+    /// share a key with `input2`, and then transforming the reuslting
+    /// 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 {
+        join::antijoin(input1, input2, logic)
+    }
+
     /// Creates a `Relation` from a vector of tuples.
     pub fn from_vec(mut elements: Vec<Tuple>) -> Self {
         elements.sort();
@@ -264,6 +277,11 @@ impl<Tuple: Ord> Variable<Tuple> {
 
     /// Adds tuples from `input1` whose key is not present in `input2`.
     ///
+    /// Note that `input1` must be a variable: if you have a relation
+    /// instead, you can use `Relation::from_antijoin` and then
+    /// `Variable::insert`.  Note that the result will not vary during
+    /// the iteration.
+    ///
     /// # Examples
     ///
     /// This example starts a collection with the pairs (x, x+1) for x in 0 .. 10. It then
@@ -292,7 +310,7 @@ impl<Tuple: Ord> Variable<Tuple> {
         input2: &Relation<K>,
         logic: impl FnMut(&K, &V) -> Tuple,
     ) {
-        join::antijoin_into(input1, input2, self, logic)
+        self.insert(join::antijoin(input1, input2, logic))
     }
 
     /// Adds tuples that result from mapping `input`.