impl Trait

Author: frankmcsherry

src/join.rs

@@ -2,36 +2,41 @@
 
 use super::{Variable, Relation};
 
-pub fn join_into<Key: Ord, Val1: Ord, Val2: Ord, Result: Ord, F: Fn(&Key, &Val1, &Val2)->Result>(
+pub fn join_into<Key: Ord, Val1: Ord, Val2: Ord, Result: Ord>(
     input1: &Variable<(Key, Val1)>,
     input2: &Variable<(Key, Val2)>,
     output: &Variable<Result>,
-    logic: F) {
+    mut logic: impl FnMut(&Key, &Val1, &Val2)->Result) {
 
     let mut results = Vec::new();
 
     let recent1 = input1.recent.borrow();
     let recent2 = input2.recent.borrow();
 
-    for batch2 in input2.stable.borrow().iter() {
-        join_helper(&recent1, &batch2, |k,v1,v2| results.push(logic(k,v1,v2)));
-    }
+    {   // scoped to let `closure` drop borrow of `results`.
 
-    for batch1 in input1.stable.borrow().iter() {
-        join_helper(&batch1, &recent2, |k,v1,v2| results.push(logic(k,v1,v2)));
-    }
+        let mut closure = |k: &Key, v1: &Val1, v2: &Val2| results.push(logic(k,v1,v2));
+
+        for batch2 in input2.stable.borrow().iter() {
+            join_helper(&recent1, &batch2, &mut closure);
+        }
 
-    join_helper(&recent1, &recent2, |k,v1,v2| results.push(logic(k,v1,v2)));
+        for batch1 in input1.stable.borrow().iter() {
+            join_helper(&batch1, &recent2, &mut closure);
+        }
+
+        join_helper(&recent1, &recent2, &mut closure);
+    }
 
     output.insert(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, F: Fn(&Key, &Val)->Result>(
+pub fn antijoin_into<Key: Ord, Val: Ord, Result: Ord>(
     input1: &Variable<(Key, Val)>,
     input2: &Relation<Key>,
     output: &Variable<Result>,
-    logic: F) {
+    mut logic: impl FnMut(&Key, &Val)->Result) {
 
     let mut results = Vec::new();
     let mut tuples2 = &input2[..];
@@ -46,7 +51,10 @@ pub fn antijoin_into<Key: Ord, Val: Ord, Result: Ord, F: Fn(&Key, &Val)->Result>
     output.insert(Relation::from_vec(results));
 }
 
-fn join_helper<K: Ord, V1, V2, F: FnMut(&K, &V1, &V2)>(mut slice1: &[(K,V1)], mut slice2: &[(K,V2)], mut result: F) {
+fn join_helper<K: Ord, V1, V2>(
+    mut slice1: &[(K,V1)],
+    mut slice2: &[(K,V2)],
+    mut result: impl FnMut(&K,&V1,&V2)) {
 
     while !slice1.is_empty() && !slice2.is_empty() {
 
@@ -81,7 +89,7 @@ fn join_helper<K: Ord, V1, V2, F: FnMut(&K, &V1, &V2)>(mut slice1: &[(K,V1)], mu
     }
 }
 
-pub fn gallop<T, F: Fn(&T)->bool>(mut slice: &[T], cmp: F) -> &[T] {
+pub fn gallop<T>(mut slice: &[T], mut cmp: impl FnMut(&T)->bool) -> &[T] {
     // if empty slice, or already >= element, return
     if slice.len() > 0 && cmp(&slice[0]) {
         let mut step = 1;

src/lib.rs

@@ -149,9 +149,9 @@ pub struct Variable<Tuple: Ord> {
     /// A useful name for the variable.
     name: String,
     /// A list of relations whose union are the accepted tuples.
-    stable: Rc<RefCell<Vec<Relation<Tuple>>>>,
+    pub stable: Rc<RefCell<Vec<Relation<Tuple>>>>,
     /// A list of recent tuples, still to be processed.
-    recent: Rc<RefCell<Relation<Tuple>>>,
+    pub recent: Rc<RefCell<Relation<Tuple>>>,
     /// A list of future tuples, to be introduced.
     to_add: Rc<RefCell<Vec<Relation<Tuple>>>>,
 }
@@ -181,11 +181,11 @@ impl<Tuple: Ord> Variable<Tuple> {
     /// let result = variable.complete();
     /// assert_eq!(result.len(), 121);
     /// ```
-    pub fn from_join<K: Ord,V1: Ord, V2: Ord, F: Fn(&K,&V1,&V2)->Tuple>(
+    pub fn from_join<K: Ord,V1: Ord, V2: Ord>(
         &self,
         input1: &Variable<(K,V1)>,
         input2: &Variable<(K,V2)>,
-        logic: F)
+        logic: impl FnMut(&K,&V1,&V2)->Tuple)
     {
         join::join_into(input1, input2, self, logic)
     }
@@ -213,11 +213,11 @@ impl<Tuple: Ord> Variable<Tuple> {
     /// let result = variable.complete();
     /// assert_eq!(result.len(), 16);
     /// ```
-    pub fn from_antijoin<K: Ord,V: Ord, F: Fn(&K,&V)->Tuple>(
+    pub fn from_antijoin<K: Ord, V: Ord>(
         &self,
         input1: &Variable<(K,V)>,
         input2: &Relation<K>,
-        logic: F)
+        logic: impl FnMut(&K,&V)->Tuple)
     {
         join::antijoin_into(input1, input2, self, logic)
     }
@@ -252,7 +252,7 @@ impl<Tuple: Ord> Variable<Tuple> {
     /// let result = variable.complete();
     /// assert_eq!(result.len(), 74);
     /// ```
-    pub fn from_map<T2: Ord, F: Fn(&T2)->Tuple>(&self, input: &Variable<T2>, logic: F) {
+    pub fn from_map<T2: Ord>(&self, input: &Variable<T2>, logic: impl FnMut(&T2)->Tuple) {
         map::map_into(input, self, logic)
     }
 }
@@ -351,7 +351,7 @@ impl<Tuple: Ord> VariableTrait for Variable<Tuple> {
         }
 
         // let mut total = 0;
-        // for tuple in self.tuples.borrow().iter() {
+        // for tuple in self.stable.borrow().iter() {
         //     total += tuple.len();
         // }
 
@@ -364,7 +364,7 @@ impl<Tuple: Ord> VariableTrait for Variable<Tuple> {
 // impl<Tuple: Ord> Drop for Variable<Tuple> {
 //     fn drop(&mut self) {
 //         let mut total = 0;
-//         for batch in self.tuples.borrow().iter() {
+//         for batch in self.stable.borrow().iter() {
 //             total += batch.len();
 //         }
 //         println!("FINAL: {:?}\t{:?}", self.name, total);

src/map.rs

@@ -2,10 +2,10 @@
 
 use super::{Variable, Relation};
 
-pub fn map_into<T1: Ord, T2: Ord, F: Fn(&T1)->T2>(
+pub fn map_into<T1: Ord, T2: Ord>(
     input: &Variable<T1>,
     output: &Variable<T2>,
-    logic: F) {
+    mut logic: impl FnMut(&T1)->T2) {
 
     let mut results = Vec::new();
     let recent = input.recent.borrow();