Merge pull request #17 from nikomatsakis/from_leapjoin

add `.from_leapjoin` method to public API

Author: nikomatsakis

examples/borrow_check.rs

@@ -61,7 +61,7 @@ fn main() {
         subset_r1p.complete()
     };
 
-    let requires = {
+    let _requires = {
         // Create a new iteration context, ...
         let mut iteration2 = Iteration::new();
 

src/lib.rs

@@ -17,13 +17,18 @@ use std::rc::Rc;
 
 mod join;
 mod map;
-pub mod treefrog;
+mod treefrog;
+pub use treefrog::{
+    extend_anti::ExtendAnti, extend_with::ExtendWith, filter_anti::FilterAnti,
+    filter_with::FilterWith, Leaper, RelationLeaper,
+};
 
 /// A static, ordered list of key-value pairs.
 ///
 /// A relation represents a fixed set of key-value pairs. In many places in a
 /// Datalog computation we want to be sure that certain relations are not able
 /// to vary (for example, in antijoins).
+#[derive(Clone)]
 pub struct Relation<Tuple: Ord> {
     /// Sorted list of distinct tuples.
     pub elements: Vec<Tuple>,
@@ -114,7 +119,7 @@ impl<Tuple: Ord> std::ops::Deref for Relation<Tuple> {
 /// It can inform the user if they have ceased changing, at which point the
 /// computation should be done.
 pub struct Iteration {
-    variables: Vec<Box<VariableTrait>>,
+    variables: Vec<Box<dyn VariableTrait>>,
 }
 
 impl Iteration {
@@ -222,6 +227,7 @@ impl<Tuple: Ord> Variable<Tuple> {
     ) {
         join::join_into(input1, input2, self, logic)
     }
+
     /// Adds tuples from `input1` whose key is not present in `input2`.
     ///
     /// # Examples
@@ -254,6 +260,7 @@ impl<Tuple: Ord> Variable<Tuple> {
     ) {
         join::antijoin_into(input1, input2, self, logic)
     }
+
     /// Adds tuples that result from mapping `input`.
     ///
     /// # Examples
@@ -286,6 +293,21 @@ impl<Tuple: Ord> Variable<Tuple> {
     pub fn from_map<T2: Ord>(&self, input: &Variable<T2>, logic: impl FnMut(&T2) -> Tuple) {
         map::map_into(input, self, logic)
     }
+
+    /// Adds tuples that result from combining `source` with the
+    /// relations given in `leapers`. This operation is very flexible
+    /// and can be used to do a combination of joins and anti-joins.
+    /// The main limitation is that the things being combined must
+    /// consist of one dynamic variable (`source`) and then several
+    /// fixed relations (`leapers`).
+    pub fn from_leapjoin<'a, SourceTuple: Ord, Val: Ord + 'a>(
+        &self,
+        source: &Variable<SourceTuple>,
+        leapers: &mut [&mut dyn Leaper<'a, SourceTuple, Val>],
+        logic: impl FnMut(&SourceTuple, &Val) -> Tuple,
+    ) {
+        treefrog::leapjoin_into(source, leapers, self, logic)
+    }
 }
 
 impl<Tuple: Ord> Clone for Variable<Tuple> {

src/treefrog.rs

@@ -5,7 +5,7 @@ use super::{Relation, Variable};
 /// Performs treefrog leapjoin using a list of leapers.
 pub fn leapjoin_into<'a, Tuple: Ord, Val: Ord + 'a, Result: Ord>(
     source: &Variable<Tuple>,
-    leapers: &mut [&mut Leaper<'a, Tuple, Val>],
+    leapers: &mut [&mut dyn Leaper<'a, Tuple, Val>],
     output: &Variable<Result>,
     mut logic: impl FnMut(&Tuple, &Val) -> Result,
 ) {
@@ -138,7 +138,7 @@ impl<Key: Ord, Val: Ord> RelationLeaper<Key, Val> for Relation<(Key, Val)> {
     }
 }
 
-mod extend_with {
+pub(crate) mod extend_with {
     use super::{binary_search, Leaper, Relation};
     use join::gallop;
 
@@ -205,7 +205,7 @@ mod extend_with {
     }
 }
 
-mod extend_anti {
+pub(crate) mod extend_anti {
     use super::{binary_search, Leaper, Relation};
     use join::gallop;
 
@@ -269,7 +269,7 @@ mod extend_anti {
     }
 }
 
-mod filter_with {
+pub(crate) mod filter_with {
 
     use super::{Leaper, Relation};
 
@@ -328,7 +328,7 @@ mod filter_with {
     }
 }
 
-mod filter_anti {
+pub(crate) mod filter_anti {
 
     use super::{Leaper, Relation};