create a from_leapjoin on Relation

Author: nikomatsakis

src/lib.rs

@@ -100,6 +100,16 @@ impl<Tuple: Ord> Relation<Tuple> {
         Relation { elements }
     }
 
+    /// Creates a `Relation` using the `leapjoin` logic;
+    /// see [`Variable::leapjoin`]
+    pub fn from_leapjoin<'a, SourceTuple: Ord, Val: Ord + 'a>(
+        source: &Relation<SourceTuple>,
+        leapers: &mut [&mut dyn Leaper<'a, SourceTuple, Val>],
+        logic: impl FnMut(&SourceTuple, &Val) -> Tuple,
+    ) -> Self {
+        treefrog::leapjoin(&source.elements, leapers, logic)
+    }
+
     /// Creates a `Relation` by joining the values from `input1` and
     /// `input2` and then applying `logic`. Like
     /// [`Variable::from_join`] except for use where the inputs are
@@ -398,7 +408,7 @@ impl<Tuple: Ord> Variable<Tuple> {
         leapers: &mut [&mut dyn Leaper<'a, SourceTuple, Val>],
         logic: impl FnMut(&SourceTuple, &Val) -> Tuple,
     ) {
-        self.insert(treefrog::leapjoin(source, leapers, logic));
+        self.insert(treefrog::leapjoin(&source.recent.borrow(), leapers, logic));
     }
 }
 

src/test.rs

@@ -126,3 +126,30 @@ proptest! {
         assert_eq!(output1.elements, output2.elements);
     }
 }
+
+/// Test that `from_leapjoin` matches against the tuples from an
+/// `extend` that precedes first iteration.
+///
+/// This was always true, but wasn't immediately obvious to me until I
+/// re-read the code more carefully. -nikomatsakis
+#[test]
+fn leapjoin_from_extend() {
+    let doubles: Relation<(u32, u32)> = (0..10).map(|i| (i, i * 2)).collect();
+
+    let mut iteration = Iteration::new();
+
+    let variable = iteration.variable::<(u32, u32)>("variable");
+    variable.extend(Some((2, 2)));
+
+    while iteration.changed() {
+        variable.from_leapjoin(
+            &variable,
+            &mut [&mut doubles.extend_with(|&(i, _)| i)],
+            |&(i, _), &j| (i, j),
+        );
+    }
+
+    let variable = variable.complete();
+
+    assert_eq!(variable.elements, vec![(2, 2), (2, 4)]);
+}

src/treefrog.rs

@@ -1,17 +1,17 @@
 //! Join functionality.
 
-use super::{Relation, Variable};
+use super::Relation;
 
 /// Performs treefrog leapjoin using a list of leapers.
 pub(crate) fn leapjoin<'a, Tuple: Ord, Val: Ord + 'a, Result: Ord>(
-    source: &Variable<Tuple>,
+    source: &[Tuple],
     leapers: &mut [&mut dyn Leaper<'a, Tuple, Val>],
     mut logic: impl FnMut(&Tuple, &Val) -> Result,
 ) -> Relation<Result> {
     let mut result = Vec::new(); // temp output storage.
     let mut values = Vec::new(); // temp value storage.
 
-    for tuple in source.recent.borrow().iter() {
+    for tuple in source {
         // Determine which leaper would propose the fewest values.
         let mut min_index = usize::max_value();
         let mut min_count = usize::max_value();