Update tests with new join/antijoin interface

Author: ecstatic-morse

src/test.rs

@@ -11,7 +11,7 @@ fn inputs() -> impl Strategy<Value = Vec<(u32, u32)>> {
 
 /// The original way to use datafrog -- computes reachable nodes from a set of edges
 fn reachable_with_var_join(edges: &[(u32, u32)]) -> Relation<(u32, u32)> {
-    let edges: Relation<_> = edges.iter().collect();
+    let edges: Relation<(u32, u32)> = edges.iter().collect();
     let mut iteration = Iteration::new();
 
     let edges_by_successor = iteration.variable::<(u32, u32)>("edges_invert");
@@ -22,15 +22,15 @@ fn reachable_with_var_join(edges: &[(u32, u32)]) -> Relation<(u32, u32)> {
 
     while iteration.changed() {
         // reachable(N1, N3) :- edges(N1, N2), reachable(N2, N3).
-        reachable.from_join(&reachable, &edges_by_successor, |&_, &n3, &n1| (n1, n3));
+        reachable.from_join(&reachable, &edges_by_successor, |_: (u32,), n3, n1| (n1, n3));
     }
 
     reachable.complete()
 }
 
 /// Like `reachable`, but using a relation as an input to `from_join`
 fn reachable_with_relation_join(edges: &[(u32, u32)]) -> Relation<(u32, u32)> {
-    let edges: Relation<_> = edges.iter().collect();
+    let edges: Relation<(u32, u32)> = edges.iter().collect();
     let mut iteration = Iteration::new();
 
     // NB. Changed from `reachable_with_var_join`:
@@ -41,7 +41,7 @@ fn reachable_with_relation_join(edges: &[(u32, u32)]) -> Relation<(u32, u32)> {
 
     while iteration.changed() {
         // reachable(N1, N3) :- edges(N1, N2), reachable(N2, N3).
-        reachable.from_join(&reachable, &edges_by_successor, |&_, &n3, &n1| (n1, n3));
+        reachable.from_join(&reachable, &edges_by_successor, |_: (u32,), n3, n1| (n1, n3));
     }
 
     reachable.complete()
@@ -60,7 +60,7 @@ fn reachable_with_leapfrog(edges: &[(u32, u32)]) -> Relation<(u32, u32)> {
         // reachable(N1, N3) :- edges(N1, N2), reachable(N2, N3).
         reachable.from_leapjoin(
             &reachable,
-            edges_by_successor.extend_with(|&(n2, _)| n2),
+            edges_by_successor.extend_with(|&(n2, _)| (n2,)),
             |&(_, n3), &n1| (n1, n3),
         );
     }
@@ -86,7 +86,7 @@ fn sum_join_via_var(
 
     while iteration.changed() {
         // output(K1, V1 * 100 + V2) :- input1(K1, V1), input2(K1, V2).
-        output.from_join(&input1, &input2, |&k1, &v1, &v2| (k1, v1 * 100 + v2));
+        output.from_join(&input1, &input2, |(k1,), v1, v2| (k1, v1 * 100 + v2));
     }
 
     output.complete()
@@ -98,9 +98,9 @@ fn sum_join_via_relation(
     input1_slice: &[(u32, u32)],
     input2_slice: &[(u32, u32)],
 ) -> Relation<(u32, u32)> {
-    let input1: Relation<_> = input1_slice.iter().collect();
-    let input2: Relation<_> = input2_slice.iter().collect();
-    Relation::from_join(&input1, &input2, |&k1, &v1, &v2| (k1, v1 * 100 + v2))
+    let input1: Relation<(u32, u32)> = input1_slice.iter().collect();
+    let input2: Relation<(u32, u32)> = input2_slice.iter().collect();
+    Relation::from_join(&input1, &input2, |(k1,), v1, v2| (k1, v1 * 100 + v2))
 }
 
 proptest! {
@@ -183,7 +183,7 @@ fn leapjoin_from_extend() {
     while iteration.changed() {
         variable.from_leapjoin(
             &variable,
-            doubles.extend_with(|&(i, _)| i),
+            doubles.extend_with(|&(i, _)| (i,)),
             |&(i, _), &j| (i, j),
         );
     }
@@ -221,11 +221,11 @@ fn passthrough_leaper() {
 
 #[test]
 fn relation_from_antijoin() {
-    let lhs: Relation<_> = (0 .. 10).map(|x| (x, x)).collect();
-    let rhs: Relation<_> = (0 .. 10).filter(|x| x % 2 == 0).collect();
+    let lhs: Relation<(u32, u32)> = (0 .. 10).map(|x| (x, x)).collect();
+    let rhs: Relation<(u32,)> = (0 .. 10).filter(|x| x % 2 == 0).map(|x| (x,)).collect();
     let expected: Relation<_> = (0 .. 10).filter(|x| x % 2 == 1).map(|x| (x, x)).collect();
 
-    let result = Relation::from_antijoin(&lhs, &rhs, |a, b| (*a, *b));
+    let result = Relation::from_antijoin(&lhs, &rhs, |x| x);
 
     assert_eq!(result.elements, expected.elements);
 }

src/variable.rs

@@ -84,7 +84,7 @@ impl<Tuple: Ord> Variable<Tuple> {
     /// variable.extend((0 .. 10).map(|x| (x + 1, x)));
     ///
     /// while iteration.changed() {
-    ///     variable.from_join(&variable, &variable, |&key, &val1, &val2| (val1, val2));
+    ///     variable.from_join(&variable, &variable, |key: (usize,), val1, val2| (val1, val2));
     /// }
     ///
     /// let result = variable.complete();
@@ -120,7 +120,7 @@ impl<Tuple: Ord> Variable<Tuple> {
     /// variable.extend((0 .. 10).map(|x| (x + 1, x)));
     ///
     /// while iteration.changed() {
-    ///     variable.from_join_filtered(&variable, &variable, |&key, &val1, &val2| {
+    ///     variable.from_join_filtered(&variable, &variable, |key: (isize,), val1, val2| {
     ///        ((val1 - val2).abs() <= 3).then(|| (val1, val2))
     ///     });
     /// }
@@ -171,10 +171,10 @@ impl<Tuple: Ord> Variable<Tuple> {
     /// let variable = iteration.variable::<(usize, usize)>("source");
     /// variable.extend((0 .. 10).map(|x| (x, x + 1)));
     ///
-    /// let relation: Relation<_> = (0 .. 10).filter(|x| x % 3 == 0).collect();
+    /// let relation: Relation<_> = (0 .. 10).filter(|x| x % 3 == 0).map(|x| (x,)).collect();
     ///
     /// while iteration.changed() {
-    ///     variable.from_antijoin(&variable, &relation, |&key, &val| (val, key));
+    ///     variable.from_antijoin(&variable, &relation, |(key, val)| (val, key));
     /// }
     ///
     /// let result = variable.complete();