Merge pull request #22 from nikomatsakis/api-2.0

Proposal: extend API to support more operations on relations [breaking change]

Author: nikomatsakis

Cargo.toml

@@ -7,7 +7,11 @@ description = "Lightweight Datalog engine intended to be embedded in other Rust
 readme = "README.md"
 keywords = ["datalog", "analysis"]
 repository = "https://github.com/rust-lang-nursery/datafrog"
+edition = "2018"
 
 [badges]
 is-it-maintained-issue-resolution = { repository = "https://github.com/rust-lang-nursery/datafrog" }
 is-it-maintained-open-issues = { repository = "https://github.com/rust-lang-nursery/datafrog" }
+
+[dev-dependencies]
+proptest = "0.8.7"

src/join.rs

@@ -1,28 +1,35 @@
 //! Join functionality.
 
 use super::{Relation, Variable};
-
-pub fn join_into<Key: Ord, Val1: Ord, Val2: Ord, Result: Ord>(
+use std::cell::Ref;
+use std::ops::Deref;
+
+/// Implements `join`. Note that `input1` must be a variable, but
+/// `input2` can be either a variable or a relation. This is necessary
+/// because relations have no "recent" tuples, so the fn would be a
+/// guaranteed no-op if both arguments were relations.  See also
+/// `join_into_relation`.
+pub(crate) fn join_into<'me, Key: Ord, Val1: Ord, Val2: Ord, Result: Ord>(
     input1: &Variable<(Key, Val1)>,
-    input2: &Variable<(Key, Val2)>,
+    input2: impl JoinInput<'me, (Key, Val2)>,
     output: &Variable<Result>,
     mut logic: impl FnMut(&Key, &Val1, &Val2) -> Result,
 ) {
     let mut results = Vec::new();
 
-    let recent1 = input1.recent.borrow();
-    let recent2 = input2.recent.borrow();
+    let recent1 = input1.recent();
+    let recent2 = input2.recent();
 
     {
         // scoped to let `closure` drop borrow of `results`.
 
         let mut closure = |k: &Key, v1: &Val1, v2: &Val2| results.push(logic(k, v1, v2));
 
-        for batch2 in input2.stable.borrow().iter() {
+        for batch2 in input2.stable().iter() {
             join_helper(&recent1, &batch2, &mut closure);
         }
 
-        for batch1 in input1.stable.borrow().iter() {
+        for batch1 in input1.stable().iter() {
             join_helper(&batch1, &recent2, &mut closure);
         }
 
@@ -32,18 +39,31 @@ pub fn join_into<Key: Ord, Val1: Ord, Val2: Ord, Result: Ord>(
     output.insert(Relation::from_vec(results));
 }
 
+/// Join, but for two relations.
+pub(crate) fn join_into_relation<'me, Key: Ord, Val1: Ord, Val2: Ord, Result: Ord>(
+    input1: &Relation<(Key, Val1)>,
+    input2: &Relation<(Key, Val2)>,
+    mut logic: impl FnMut(&Key, &Val1, &Val2) -> Result,
+) -> Relation<Result> {
+    let mut results = Vec::new();
+
+    join_helper(&input1.elements, &input2.elements, |k, v1, v2| {
+        results.push(logic(k, v1, v2));
+    });
+
+    Relation::from_vec(results)
+}
+
 /// Moves all recent tuples from `input1` that are not present in `input2` into `output`.
-pub 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);
@@ -52,7 +72,7 @@ pub 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>(
@@ -91,7 +111,7 @@ fn join_helper<K: Ord, V1, V2>(
     }
 }
 
-pub fn gallop<T>(mut slice: &[T], mut cmp: impl FnMut(&T) -> bool) -> &[T] {
+pub(crate) fn gallop<T>(mut slice: &[T], mut cmp: impl FnMut(&T) -> bool) -> &[T] {
     // if empty slice, or already >= element, return
     if !slice.is_empty() && cmp(&slice[0]) {
         let mut step = 1;
@@ -113,3 +133,48 @@ pub fn gallop<T>(mut slice: &[T], mut cmp: impl FnMut(&T) -> bool) -> &[T] {
 
     slice
 }
+
+/// An input that can be used with `from_join`; either a `Variable` or a `Relation`.
+pub trait JoinInput<'me, Tuple: Ord>: Copy {
+    /// If we are on iteration N of the loop, these are the tuples
+    /// added on iteration N-1. (For a `Relation`, this is always an
+    /// empty slice.)
+    type RecentTuples: Deref<Target = [Tuple]>;
+
+    /// If we are on iteration N of the loop, these are the tuples
+    /// added on iteration N - 2 or before. (For a `Relation`, this is
+    /// just `self`.)
+    type StableTuples: Deref<Target = [Relation<Tuple>]>;
+
+    /// Get the set of recent tuples.
+    fn recent(self) -> Self::RecentTuples;
+
+    /// Get the set of stable tuples.
+    fn stable(self) -> Self::StableTuples;
+}
+
+impl<'me, Tuple: Ord> JoinInput<'me, Tuple> for &'me Variable<Tuple> {
+    type RecentTuples = Ref<'me, [Tuple]>;
+    type StableTuples = Ref<'me, [Relation<Tuple>]>;
+
+    fn recent(self) -> Self::RecentTuples {
+        Ref::map(self.recent.borrow(), |r| &r.elements[..])
+    }
+
+    fn stable(self) -> Self::StableTuples {
+        Ref::map(self.stable.borrow(), |v| &v[..])
+    }
+}
+
+impl<'me, Tuple: Ord> JoinInput<'me, Tuple> for &'me Relation<Tuple> {
+    type RecentTuples = &'me [Tuple];
+    type StableTuples = &'me [Relation<Tuple>];
+
+    fn recent(self) -> Self::RecentTuples {
+        &[]
+    }
+
+    fn stable(self) -> Self::StableTuples {
+        std::slice::from_ref(self)
+    }
+}