leap by-value

ecstatic-morse · ecstatic-morse · commit ccaca5be970c · 2022-01-05T21:49:51.000-08:00
diff --git a/src/relation.rs b/src/relation.rs
@@ -36,9 +36,9 @@ impl<Tuple: Ord> Relation<Tuple> {
 
     /// Creates a `Relation` using the `leapjoin` logic;
     /// see [`Variable::from_leapjoin`]
-    pub fn from_leapjoin<'leap, SourceTuple: Ord, Val: Ord + 'leap>(
+    pub fn from_leapjoin<SourceTuple: Ord, Val: Ord>(
         source: &Relation<SourceTuple>,
-        leapers: impl Leapers<'leap, SourceTuple, Val>,
+        leapers: impl Leapers<SourceTuple, Val>,
         logic: impl FnMut(&SourceTuple, &Val) -> Tuple,
     ) -> Self {
         treefrog::leapjoin(&source.elements, leapers, logic)
diff --git a/src/treefrog.rs b/src/treefrog.rs
@@ -3,9 +3,9 @@
 use super::Relation;
 
 /// Performs treefrog leapjoin using a list of leapers.
-pub(crate) fn leapjoin<'leap, Tuple: Ord, Val: Ord + 'leap, Result: Ord>(
+pub(crate) fn leapjoin<Tuple: Ord, Val: Ord, Result: Ord>(
     source: &[Tuple],
-    mut leapers: impl Leapers<'leap, Tuple, Val>,
+    mut leapers: impl Leapers<Tuple, Val>,
     mut logic: impl FnMut(&Tuple, &Val) -> Result,
 ) -> Relation<Result> {
     let mut result = Vec::new(); // temp output storage.
@@ -36,7 +36,7 @@ pub(crate) fn leapjoin<'leap, Tuple: Ord, Val: Ord + 'leap, Result: Ord>(
 
             // Push remaining items into result.
             for val in values.drain(..) {
-                result.push(logic(tuple, val));
+                result.push(logic(tuple, &val));
             }
         }
     }
@@ -45,23 +45,23 @@ pub(crate) fn leapjoin<'leap, Tuple: Ord, Val: Ord + 'leap, Result: Ord>(
 }
 
 /// Implemented for a tuple of leapers
-pub trait Leapers<'leap, Tuple, Val> {
+pub trait Leapers<Tuple, Val> {
     /// Internal method:
     fn for_each_count(&mut self, tuple: &Tuple, op: impl FnMut(usize, usize));
 
     /// Internal method:
-    fn propose(&mut self, tuple: &Tuple, min_index: usize, values: &mut Vec<&'leap Val>);
+    fn propose(&mut self, tuple: &Tuple, min_index: usize, values: &mut Vec<Val>);
 
     /// Internal method:
-    fn intersect(&mut self, tuple: &Tuple, min_index: usize, values: &mut Vec<&'leap Val>);
+    fn intersect(&mut self, tuple: &Tuple, min_index: usize, values: &mut Vec<Val>);
 }
 
 macro_rules! tuple_leapers {
     ($($Ty:ident)*) => {
         #[allow(unused_assignments, non_snake_case)]
-        impl<'leap, Tuple, Val, $($Ty),*> Leapers<'leap, Tuple, Val> for ($($Ty,)*)
+        impl<Tuple, Val, $($Ty),*> Leapers<Tuple, Val> for ($($Ty,)*)
         where
-            $($Ty: Leaper<'leap, Tuple, Val>,)*
+            $($Ty: Leaper<Tuple, Val>,)*
         {
             fn for_each_count(&mut self, tuple: &Tuple, mut op: impl FnMut(usize, usize)) {
                 let ($($Ty,)*) = self;
@@ -73,7 +73,7 @@ macro_rules! tuple_leapers {
                 )*
             }
 
-            fn propose(&mut self, tuple: &Tuple, min_index: usize, values: &mut Vec<&'leap Val>) {
+            fn propose(&mut self, tuple: &Tuple, min_index: usize, values: &mut Vec<Val>) {
                 let ($($Ty,)*) = self;
                 let mut index = 0;
                 $(
@@ -85,7 +85,7 @@ macro_rules! tuple_leapers {
                     panic!("no match found for min_index={}", min_index);
             }
 
-            fn intersect(&mut self, tuple: &Tuple, min_index: usize, values: &mut Vec<&'leap Val>) {
+            fn intersect(&mut self, tuple: &Tuple, min_index: usize, values: &mut Vec<Val>) {
                 let ($($Ty,)*) = self;
                 let mut index = 0;
                 $(
@@ -107,13 +107,13 @@ tuple_leapers!(A B C D E F);
 tuple_leapers!(A B C D E F G);
 
 /// Methods to support treefrog leapjoin.
-pub trait Leaper<'leap, Tuple, Val> {
+pub trait Leaper<Tuple, Val> {
     /// Estimates the number of proposed values.
     fn count(&mut self, prefix: &Tuple) -> usize;
     /// Populates `values` with proposed values.
-    fn propose(&mut self, prefix: &Tuple, values: &mut Vec<&'leap Val>);
+    fn propose(&mut self, prefix: &Tuple, values: &mut Vec<Val>);
     /// Restricts `values` to proposed values.
-    fn intersect(&mut self, prefix: &Tuple, values: &mut Vec<&'leap Val>);
+    fn intersect(&mut self, prefix: &Tuple, values: &mut Vec<Val>);
 }
 
 pub(crate) mod filters {
@@ -131,7 +131,7 @@ pub(crate) mod filters {
         predicate: Func,
     }
 
-    impl<'leap, Tuple, Func> PrefixFilter<Tuple, Func>
+    impl<Tuple, Func> PrefixFilter<Tuple, Func>
     where
         Func: Fn(&Tuple) -> bool,
     {
@@ -144,7 +144,7 @@ pub(crate) mod filters {
         }
     }
 
-    impl<'leap, Tuple, Val, Func> Leaper<'leap, Tuple, Val> for PrefixFilter<Tuple, Func>
+    impl<Tuple, Val, Func> Leaper<Tuple, Val> for PrefixFilter<Tuple, Func>
     where
         Func: Fn(&Tuple) -> bool,
     {
@@ -157,34 +157,34 @@ pub(crate) mod filters {
             }
         }
         /// Populates `values` with proposed values.
-        fn propose(&mut self, _prefix: &Tuple, _values: &mut Vec<&'leap Val>) {
+        fn propose(&mut self, _prefix: &Tuple, _values: &mut Vec<Val>) {
             panic!("PrefixFilter::propose(): variable apparently unbound");
         }
         /// Restricts `values` to proposed values.
-        fn intersect(&mut self, _prefix: &Tuple, _values: &mut Vec<&'leap Val>) {
+        fn intersect(&mut self, _prefix: &Tuple, _values: &mut Vec<Val>) {
             // We can only be here if we returned max_value() above.
         }
     }
 
-    impl<'leap, Tuple, Func> Leapers<'leap, Tuple, ()> for PrefixFilter<Tuple, Func>
+    impl<Tuple, Func> Leapers<Tuple, ()> for PrefixFilter<Tuple, Func>
     where
         Func: Fn(&Tuple) -> bool,
     {
         fn for_each_count(&mut self, tuple: &Tuple, mut op: impl FnMut(usize, usize)) {
-            if <Self as Leaper<'_, Tuple, ()>>::count(self, tuple) == 0 {
+            if <Self as Leaper<Tuple, ()>>::count(self, tuple) == 0 {
                 op(0, 0)
             } else {
                 // we will "propose" the `()` value if the predicate applies
                 op(0, 1)
             }
         }
 
-        fn propose(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<&'leap ()>) {
+        fn propose(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<()>) {
             assert_eq!(min_index, 0);
-            values.push(&());
+            values.push(());
         }
 
-        fn intersect(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<&'leap ()>) {
+        fn intersect(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<()>) {
             assert_eq!(min_index, 0);
             assert_eq!(values.len(), 1);
         }
@@ -202,17 +202,17 @@ pub(crate) mod filters {
         }
     }
 
-    impl<'leap, Tuple> Leaper<'leap, Tuple, ()> for Passthrough<Tuple> {
+    impl<Tuple> Leaper<Tuple, ()> for Passthrough<Tuple> {
         /// Estimates the number of proposed values.
         fn count(&mut self, _prefix: &Tuple) -> usize {
             1
         }
         /// Populates `values` with proposed values.
-        fn propose(&mut self, _prefix: &Tuple, values: &mut Vec<&'leap ()>) {
-            values.push(&())
+        fn propose(&mut self, _prefix: &Tuple, values: &mut Vec<()>) {
+            values.push(())
         }
         /// Restricts `values` to proposed values.
-        fn intersect(&mut self, _prefix: &Tuple, _values: &mut Vec<&'leap ()>) {
+        fn intersect(&mut self, _prefix: &Tuple, _values: &mut Vec<()>) {
             // `Passthrough` never removes values (although if we're here it indicates that the user
             // didn't need a `Passthrough` in the first place)
         }
@@ -250,7 +250,7 @@ pub(crate) mod filters {
         predicate: Func,
     }
 
-    impl<'leap, Tuple, Val, Func> ValueFilter<Tuple, Val, Func>
+    impl<Tuple, Val, Func> ValueFilter<Tuple, Val, Func>
     where
         Func: Fn(&Tuple, &Val) -> bool,
     {
@@ -263,7 +263,7 @@ pub(crate) mod filters {
         }
     }
 
-    impl<'leap, Tuple, Val, Func> Leaper<'leap, Tuple, Val> for ValueFilter<Tuple, Val, Func>
+    impl<Tuple, Val, Func> Leaper<Tuple, Val> for ValueFilter<Tuple, Val, Func>
     where
         Func: Fn(&Tuple, &Val) -> bool,
     {
@@ -272,11 +272,11 @@ pub(crate) mod filters {
             usize::max_value()
         }
         /// Populates `values` with proposed values.
-        fn propose(&mut self, _prefix: &Tuple, _values: &mut Vec<&'leap Val>) {
+        fn propose(&mut self, _prefix: &Tuple, _values: &mut Vec<Val>) {
             panic!("PrefixFilter::propose(): variable apparently unbound");
         }
         /// Restricts `values` to proposed values.
-        fn intersect(&mut self, prefix: &Tuple, values: &mut Vec<&'leap Val>) {
+        fn intersect(&mut self, prefix: &Tuple, values: &mut Vec<Val>) {
             values.retain(|val| (self.predicate)(prefix, val));
         }
     }
@@ -372,11 +372,11 @@ pub(crate) mod extend_with {
         }
     }
 
-    impl<'leap, Key, Val, Tuple, Func> Leaper<'leap, Tuple, Val>
+    impl<'leap, Key, Val, Tuple, Func> Leaper<Tuple, Val>
         for ExtendWith<'leap, Key, Val, Tuple, Func>
     where
         Key: Ord + 'leap,
-        Val: Ord + 'leap,
+        Val: Clone + Ord + 'leap,
         Tuple: Ord,
         Func: Fn(&Tuple) -> Key,
     {
@@ -393,11 +393,11 @@ pub(crate) mod extend_with {
 
             self.end - self.start
         }
-        fn propose(&mut self, _prefix: &Tuple, values: &mut Vec<&'leap Val>) {
+        fn propose(&mut self, _prefix: &Tuple, values: &mut Vec<Val>) {
             let slice = &self.relation[self.start..self.end];
-            values.extend(slice.iter().map(|&(_, ref val)| val));
+            values.extend(slice.iter().map(|&(_, ref val)| val.clone()));
         }
-        fn intersect(&mut self, _prefix: &Tuple, values: &mut Vec<&'leap Val>) {
+        fn intersect(&mut self, _prefix: &Tuple, values: &mut Vec<Val>) {
             let mut slice = &self.relation[self.start..self.end];
             values.retain(|v| {
                 slice = gallop(slice, |kv| &kv.1 < v);
@@ -406,24 +406,24 @@ pub(crate) mod extend_with {
         }
     }
 
-    impl<'leap, Key, Val, Tuple, Func> Leapers<'leap, Tuple, Val>
+    impl<'leap, Key, Val, Tuple, Func> Leapers<Tuple, Val>
         for ExtendWith<'leap, Key, Val, Tuple, Func>
     where
         Key: Ord + 'leap,
-        Val: Ord + 'leap,
+        Val: Clone + Ord + 'leap,
         Tuple: Ord,
         Func: Fn(&Tuple) -> Key,
     {
         fn for_each_count(&mut self, tuple: &Tuple, mut op: impl FnMut(usize, usize)) {
             op(0, self.count(tuple))
         }
 
-        fn propose(&mut self, tuple: &Tuple, min_index: usize, values: &mut Vec<&'leap Val>) {
+        fn propose(&mut self, tuple: &Tuple, min_index: usize, values: &mut Vec<Val>) {
             assert_eq!(min_index, 0);
             Leaper::propose(self, tuple, values);
         }
 
-        fn intersect(&mut self, _: &Tuple, min_index: usize, _: &mut Vec<&'leap Val>) {
+        fn intersect(&mut self, _: &Tuple, min_index: usize, _: &mut Vec<Val>) {
             assert_eq!(min_index, 0);
         }
     }
@@ -467,7 +467,7 @@ pub(crate) mod extend_anti {
         }
     }
 
-    impl<'leap, Key: Ord, Val: Ord + 'leap, Tuple: Ord, Func> Leaper<'leap, Tuple, Val>
+    impl<'leap, Key: Ord, Val: Ord + 'leap, Tuple: Ord, Func> Leaper<Tuple, Val>
         for ExtendAnti<'leap, Key, Val, Tuple, Func>
     where
         Key: Ord + 'leap,
@@ -478,10 +478,10 @@ pub(crate) mod extend_anti {
         fn count(&mut self, _prefix: &Tuple) -> usize {
             usize::max_value()
         }
-        fn propose(&mut self, _prefix: &Tuple, _values: &mut Vec<&'leap Val>) {
+        fn propose(&mut self, _prefix: &Tuple, _values: &mut Vec<Val>) {
             panic!("ExtendAnti::propose(): variable apparently unbound.");
         }
-        fn intersect(&mut self, prefix: &Tuple, values: &mut Vec<&'leap Val>) {
+        fn intersect(&mut self, prefix: &Tuple, values: &mut Vec<Val>) {
             let key = (self.key_func)(prefix);
 
             let range = match self.old_key.as_ref() {
@@ -546,7 +546,7 @@ pub(crate) mod filter_with {
         }
     }
 
-    impl<'leap, Key, Val, Val2, Tuple, Func> Leaper<'leap, Tuple, Val2>
+    impl<'leap, Key, Val, Val2, Tuple, Func> Leaper<Tuple, Val2>
         for FilterWith<'leap, Key, Val, Tuple, Func>
     where
         Key: Ord + 'leap,
@@ -567,15 +567,15 @@ pub(crate) mod filter_with {
             self.old_key_val = Some((key_val, is_present));
             if is_present { usize::MAX } else { 0 }
         }
-        fn propose(&mut self, _prefix: &Tuple, _values: &mut Vec<&'leap Val2>) {
+        fn propose(&mut self, _prefix: &Tuple, _values: &mut Vec<Val2>) {
             panic!("FilterWith::propose(): variable apparently unbound.");
         }
-        fn intersect(&mut self, _prefix: &Tuple, _values: &mut Vec<&'leap Val2>) {
+        fn intersect(&mut self, _prefix: &Tuple, _values: &mut Vec<Val2>) {
             // Only here because we didn't return zero above, right?
         }
     }
 
-    impl<'leap, Key, Val, Tuple, Func> Leapers<'leap, Tuple, ()>
+    impl<'leap, Key, Val, Tuple, Func> Leapers<Tuple, ()>
         for FilterWith<'leap, Key, Val, Tuple, Func>
     where
         Key: Ord + 'leap,
@@ -591,12 +591,12 @@ pub(crate) mod filter_with {
             }
         }
 
-        fn propose(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<&'leap ()>) {
+        fn propose(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<()>) {
             assert_eq!(min_index, 0);
-            values.push(&());
+            values.push(());
         }
 
-        fn intersect(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<&'leap ()>) {
+        fn intersect(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<()>) {
             assert_eq!(min_index, 0);
             assert_eq!(values.len(), 1);
         }
@@ -639,7 +639,7 @@ pub(crate) mod filter_anti {
         }
     }
 
-    impl<'leap, Key: Ord, Val: Ord + 'leap, Val2, Tuple: Ord, Func> Leaper<'leap, Tuple, Val2>
+    impl<'leap, Key: Ord, Val: Ord + 'leap, Val2, Tuple: Ord, Func> Leaper<Tuple, Val2>
         for FilterAnti<'leap, Key, Val, Tuple, Func>
     where
         Key: Ord + 'leap,
@@ -660,15 +660,15 @@ pub(crate) mod filter_anti {
             self.old_key_val = Some((key_val, is_present));
             if is_present { 0 } else { usize::MAX }
         }
-        fn propose(&mut self, _prefix: &Tuple, _values: &mut Vec<&'leap Val2>) {
+        fn propose(&mut self, _prefix: &Tuple, _values: &mut Vec<Val2>) {
             panic!("FilterAnti::propose(): variable apparently unbound.");
         }
-        fn intersect(&mut self, _prefix: &Tuple, _values: &mut Vec<&'leap Val2>) {
+        fn intersect(&mut self, _prefix: &Tuple, _values: &mut Vec<Val2>) {
             // Only here because we didn't return zero above, right?
         }
     }
 
-    impl<'leap, Key, Val, Tuple, Func> Leapers<'leap, Tuple, ()>
+    impl<'leap, Key, Val, Tuple, Func> Leapers<Tuple, ()>
         for FilterAnti<'leap, Key, Val, Tuple, Func>
     where
         Key: Ord + 'leap,
@@ -684,13 +684,13 @@ pub(crate) mod filter_anti {
             }
         }
 
-        fn propose(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<&'leap ()>) {
+        fn propose(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<()>) {
             // We only get here if `tuple` is *not* a member of `self.relation`
             assert_eq!(min_index, 0);
-            values.push(&());
+            values.push(());
         }
 
-        fn intersect(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<&'leap ()>) {
+        fn intersect(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<()>) {
             // We only get here if `tuple` is not a member of `self.relation`
             assert_eq!(min_index, 0);
             assert_eq!(values.len(), 1);
diff --git a/src/variable.rs b/src/variable.rs
@@ -241,10 +241,10 @@ impl<Tuple: Ord> Variable<Tuple> {
     /// - Finally, you get a callback `logic` that accepts each `(SourceTuple, Val)`
     ///   that was successfully joined (and not filtered) and which maps to the
     ///   type of this variable.
-    pub fn from_leapjoin<'leap, SourceTuple: Ord, Val: Ord + 'leap>(
+    pub fn from_leapjoin<SourceTuple: Ord, Val: Ord>(
         &self,
         source: &Variable<SourceTuple>,
-        leapers: impl Leapers<'leap, SourceTuple, Val>,
+        leapers: impl Leapers<SourceTuple, Val>,
         logic: impl FnMut(&SourceTuple, &Val) -> Tuple,
     ) {
         self.insert(treefrog::leapjoin(&source.recent.borrow(), leapers, logic));

Original file line number	Diff line number	Diff line change
`@@ -3,9 +3,9 @@`
`3`	`3`	`use super::Relation;`
`4`	`4`
`5`	`5`	`/// Performs treefrog leapjoin using a list of leapers.`
`6`		`-pub(crate) fn leapjoin<'leap, Tuple: Ord, Val: Ord + 'leap, Result: Ord>(`
	`6`	`+pub(crate) fn leapjoin<Tuple: Ord, Val: Ord, Result: Ord>(`
`7`	`7`	`source: &[Tuple],`
`8`		`- mut leapers: impl Leapers<'leap, Tuple, Val>,`
	`8`	`+ mut leapers: impl Leapers<Tuple, Val>,`
`9`	`9`	`mut logic: impl FnMut(&Tuple, &Val) -> Result,`
`10`	`10`	`) -> Relation<Result> {`
`11`	`11`	`let mut result = Vec::new(); // temp output storage.`
`@@ -36,7 +36,7 @@ pub(crate) fn leapjoin<'leap, Tuple: Ord, Val: Ord + 'leap, Result: Ord>(`
`36`	`36`
`37`	`37`	`// Push remaining items into result.`
`38`	`38`	`for val in values.drain(..) {`
`39`		`- result.push(logic(tuple, val));`
	`39`	`+ result.push(logic(tuple, &val));`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`	`}`
`@@ -45,23 +45,23 @@ pub(crate) fn leapjoin<'leap, Tuple: Ord, Val: Ord + 'leap, Result: Ord>(`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`/// Implemented for a tuple of leapers`
`48`		`-pub trait Leapers<'leap, Tuple, Val> {`
	`48`	`+pub trait Leapers<Tuple, Val> {`
`49`	`49`	`/// Internal method:`
`50`	`50`	`fn for_each_count(&mut self, tuple: &Tuple, op: impl FnMut(usize, usize));`
`51`	`51`
`52`	`52`	`/// Internal method:`
`53`		`- fn propose(&mut self, tuple: &Tuple, min_index: usize, values: &mut Vec<&'leap Val>);`
	`53`	`+ fn propose(&mut self, tuple: &Tuple, min_index: usize, values: &mut Vec<Val>);`
`54`	`54`
`55`	`55`	`/// Internal method:`
`56`		`- fn intersect(&mut self, tuple: &Tuple, min_index: usize, values: &mut Vec<&'leap Val>);`
	`56`	`+ fn intersect(&mut self, tuple: &Tuple, min_index: usize, values: &mut Vec<Val>);`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`macro_rules! tuple_leapers {`
`60`	`60`	`($($Ty:ident)*) => {`
`61`	`61`	`#[allow(unused_assignments, non_snake_case)]`
`62`		`- impl<'leap, Tuple, Val, $($Ty),> Leapers<'leap, Tuple, Val> for ($($Ty,))`
	`62`	`+ impl<Tuple, Val, $($Ty),> Leapers<Tuple, Val> for ($($Ty,))`
`63`	`63`	`where`
`64`		`- $($Ty: Leaper<'leap, Tuple, Val>,)*`
	`64`	`+ $($Ty: Leaper<Tuple, Val>,)*`
`65`	`65`	`{`
`66`	`66`	`fn for_each_count(&mut self, tuple: &Tuple, mut op: impl FnMut(usize, usize)) {`
`67`	`67`	`let ($($Ty,)*) = self;`
`@@ -73,7 +73,7 @@ macro_rules! tuple_leapers {`
`73`	`73`	`)*`
`74`	`74`	`}`
`75`	`75`
`76`		`- fn propose(&mut self, tuple: &Tuple, min_index: usize, values: &mut Vec<&'leap Val>) {`
	`76`	`+ fn propose(&mut self, tuple: &Tuple, min_index: usize, values: &mut Vec<Val>) {`
`77`	`77`	`let ($($Ty,)*) = self;`
`78`	`78`	`let mut index = 0;`
`79`	`79`	`$(`
`@@ -85,7 +85,7 @@ macro_rules! tuple_leapers {`
`85`	`85`	`panic!("no match found for min_index={}", min_index);`
`86`	`86`	`}`
`87`	`87`
`88`		`- fn intersect(&mut self, tuple: &Tuple, min_index: usize, values: &mut Vec<&'leap Val>) {`
	`88`	`+ fn intersect(&mut self, tuple: &Tuple, min_index: usize, values: &mut Vec<Val>) {`
`89`	`89`	`let ($($Ty,)*) = self;`
`90`	`90`	`let mut index = 0;`
`91`	`91`	`$(`
`@@ -107,13 +107,13 @@ tuple_leapers!(A B C D E F);`
`107`	`107`	`tuple_leapers!(A B C D E F G);`
`108`	`108`
`109`	`109`	`/// Methods to support treefrog leapjoin.`
`110`		`-pub trait Leaper<'leap, Tuple, Val> {`
	`110`	`+pub trait Leaper<Tuple, Val> {`
`111`	`111`	`/// Estimates the number of proposed values.`
`112`	`112`	`fn count(&mut self, prefix: &Tuple) -> usize;`
`113`	`113`	/// Populates `values` with proposed values.
`114`		`- fn propose(&mut self, prefix: &Tuple, values: &mut Vec<&'leap Val>);`
	`114`	`+ fn propose(&mut self, prefix: &Tuple, values: &mut Vec<Val>);`
`115`	`115`	/// Restricts `values` to proposed values.
`116`		`- fn intersect(&mut self, prefix: &Tuple, values: &mut Vec<&'leap Val>);`
	`116`	`+ fn intersect(&mut self, prefix: &Tuple, values: &mut Vec<Val>);`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`pub(crate) mod filters {`
`@@ -131,7 +131,7 @@ pub(crate) mod filters {`
`131`	`131`	`predicate: Func,`
`132`	`132`	`}`
`133`	`133`
`134`		`- impl<'leap, Tuple, Func> PrefixFilter<Tuple, Func>`
	`134`	`+ impl<Tuple, Func> PrefixFilter<Tuple, Func>`
`135`	`135`	`where`
`136`	`136`	`Func: Fn(&Tuple) -> bool,`
`137`	`137`	`{`
`@@ -144,7 +144,7 @@ pub(crate) mod filters {`
`144`	`144`	`}`
`145`	`145`	`}`
`146`	`146`
`147`		`- impl<'leap, Tuple, Val, Func> Leaper<'leap, Tuple, Val> for PrefixFilter<Tuple, Func>`
	`147`	`+ impl<Tuple, Val, Func> Leaper<Tuple, Val> for PrefixFilter<Tuple, Func>`
`148`	`148`	`where`
`149`	`149`	`Func: Fn(&Tuple) -> bool,`
`150`	`150`	`{`
`@@ -157,34 +157,34 @@ pub(crate) mod filters {`
`157`	`157`	`}`
`158`	`158`	`}`
`159`	`159`	/// Populates `values` with proposed values.
`160`		`- fn propose(&mut self, _prefix: &Tuple, _values: &mut Vec<&'leap Val>) {`
	`160`	`+ fn propose(&mut self, _prefix: &Tuple, _values: &mut Vec<Val>) {`
`161`	`161`	`panic!("PrefixFilter::propose(): variable apparently unbound");`
`162`	`162`	`}`
`163`	`163`	/// Restricts `values` to proposed values.
`164`		`- fn intersect(&mut self, _prefix: &Tuple, _values: &mut Vec<&'leap Val>) {`
	`164`	`+ fn intersect(&mut self, _prefix: &Tuple, _values: &mut Vec<Val>) {`
`165`	`165`	`// We can only be here if we returned max_value() above.`
`166`	`166`	`}`
`167`	`167`	`}`
`168`	`168`
`169`		`- impl<'leap, Tuple, Func> Leapers<'leap, Tuple, ()> for PrefixFilter<Tuple, Func>`
	`169`	`+ impl<Tuple, Func> Leapers<Tuple, ()> for PrefixFilter<Tuple, Func>`
`170`	`170`	`where`
`171`	`171`	`Func: Fn(&Tuple) -> bool,`
`172`	`172`	`{`
`173`	`173`	`fn for_each_count(&mut self, tuple: &Tuple, mut op: impl FnMut(usize, usize)) {`
`174`		`- if <Self as Leaper<'_, Tuple, ()>>::count(self, tuple) == 0 {`
	`174`	`+ if <Self as Leaper<Tuple, ()>>::count(self, tuple) == 0 {`
`175`	`175`	`op(0, 0)`
`176`	`176`	`} else {`
`177`	`177`	// we will "propose" the `()` value if the predicate applies
`178`	`178`	`op(0, 1)`
`179`	`179`	`}`
`180`	`180`	`}`
`181`	`181`
`182`		`- fn propose(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<&'leap ()>) {`
	`182`	`+ fn propose(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<()>) {`
`183`	`183`	`assert_eq!(min_index, 0);`
`184`		`- values.push(&());`
	`184`	`+ values.push(());`
`185`	`185`	`}`
`186`	`186`
`187`		`- fn intersect(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<&'leap ()>) {`
	`187`	`+ fn intersect(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<()>) {`
`188`	`188`	`assert_eq!(min_index, 0);`
`189`	`189`	`assert_eq!(values.len(), 1);`
`190`	`190`	`}`
`@@ -202,17 +202,17 @@ pub(crate) mod filters {`
`202`	`202`	`}`
`203`	`203`	`}`
`204`	`204`
`205`		`- impl<'leap, Tuple> Leaper<'leap, Tuple, ()> for Passthrough<Tuple> {`
	`205`	`+ impl<Tuple> Leaper<Tuple, ()> for Passthrough<Tuple> {`
`206`	`206`	`/// Estimates the number of proposed values.`
`207`	`207`	`fn count(&mut self, _prefix: &Tuple) -> usize {`
`208`	`208`	`1`
`209`	`209`	`}`
`210`	`210`	/// Populates `values` with proposed values.
`211`		`- fn propose(&mut self, _prefix: &Tuple, values: &mut Vec<&'leap ()>) {`
`212`		`- values.push(&())`
	`211`	`+ fn propose(&mut self, _prefix: &Tuple, values: &mut Vec<()>) {`
	`212`	`+ values.push(())`
`213`	`213`	`}`
`214`	`214`	/// Restricts `values` to proposed values.
`215`		`- fn intersect(&mut self, _prefix: &Tuple, _values: &mut Vec<&'leap ()>) {`
	`215`	`+ fn intersect(&mut self, _prefix: &Tuple, _values: &mut Vec<()>) {`
`216`	`216`	// `Passthrough` never removes values (although if we're here it indicates that the user
`217`	`217`	// didn't need a `Passthrough` in the first place)
`218`	`218`	`}`
`@@ -250,7 +250,7 @@ pub(crate) mod filters {`
`250`	`250`	`predicate: Func,`
`251`	`251`	`}`
`252`	`252`
`253`		`- impl<'leap, Tuple, Val, Func> ValueFilter<Tuple, Val, Func>`
	`253`	`+ impl<Tuple, Val, Func> ValueFilter<Tuple, Val, Func>`
`254`	`254`	`where`
`255`	`255`	`Func: Fn(&Tuple, &Val) -> bool,`
`256`	`256`	`{`
`@@ -263,7 +263,7 @@ pub(crate) mod filters {`
`263`	`263`	`}`
`264`	`264`	`}`
`265`	`265`
`266`		`- impl<'leap, Tuple, Val, Func> Leaper<'leap, Tuple, Val> for ValueFilter<Tuple, Val, Func>`
	`266`	`+ impl<Tuple, Val, Func> Leaper<Tuple, Val> for ValueFilter<Tuple, Val, Func>`
`267`	`267`	`where`
`268`	`268`	`Func: Fn(&Tuple, &Val) -> bool,`
`269`	`269`	`{`
`@@ -272,11 +272,11 @@ pub(crate) mod filters {`
`272`	`272`	`usize::max_value()`
`273`	`273`	`}`
`274`	`274`	/// Populates `values` with proposed values.
`275`		`- fn propose(&mut self, _prefix: &Tuple, _values: &mut Vec<&'leap Val>) {`
	`275`	`+ fn propose(&mut self, _prefix: &Tuple, _values: &mut Vec<Val>) {`
`276`	`276`	`panic!("PrefixFilter::propose(): variable apparently unbound");`
`277`	`277`	`}`
`278`	`278`	/// Restricts `values` to proposed values.
`279`		`- fn intersect(&mut self, prefix: &Tuple, values: &mut Vec<&'leap Val>) {`
	`279`	`+ fn intersect(&mut self, prefix: &Tuple, values: &mut Vec<Val>) {`
`280`	`280`	`values.retain(\|val\| (self.predicate)(prefix, val));`
`281`	`281`	`}`
`282`	`282`	`}`
`@@ -372,11 +372,11 @@ pub(crate) mod extend_with {`
`372`	`372`	`}`
`373`	`373`	`}`
`374`	`374`
`375`		`- impl<'leap, Key, Val, Tuple, Func> Leaper<'leap, Tuple, Val>`
	`375`	`+ impl<'leap, Key, Val, Tuple, Func> Leaper<Tuple, Val>`
`376`	`376`	`for ExtendWith<'leap, Key, Val, Tuple, Func>`
`377`	`377`	`where`
`378`	`378`	`Key: Ord + 'leap,`
`379`		`- Val: Ord + 'leap,`
	`379`	`+ Val: Clone + Ord + 'leap,`
`380`	`380`	`Tuple: Ord,`
`381`	`381`	`Func: Fn(&Tuple) -> Key,`
`382`	`382`	`{`
`@@ -393,11 +393,11 @@ pub(crate) mod extend_with {`
`393`	`393`
`394`	`394`	`self.end - self.start`
`395`	`395`	`}`
`396`		`- fn propose(&mut self, _prefix: &Tuple, values: &mut Vec<&'leap Val>) {`
	`396`	`+ fn propose(&mut self, _prefix: &Tuple, values: &mut Vec<Val>) {`
`397`	`397`	`let slice = &self.relation[self.start..self.end];`
`398`		`- values.extend(slice.iter().map(\|&(_, ref val)\| val));`
	`398`	`+ values.extend(slice.iter().map(\|&(_, ref val)\| val.clone()));`
`399`	`399`	`}`
`400`		`- fn intersect(&mut self, _prefix: &Tuple, values: &mut Vec<&'leap Val>) {`
	`400`	`+ fn intersect(&mut self, _prefix: &Tuple, values: &mut Vec<Val>) {`
`401`	`401`	`let mut slice = &self.relation[self.start..self.end];`
`402`	`402`	`values.retain(\|v\| {`
`403`	`403`	`slice = gallop(slice, \|kv\| &kv.1 < v);`
`@@ -406,24 +406,24 @@ pub(crate) mod extend_with {`
`406`	`406`	`}`
`407`	`407`	`}`
`408`	`408`
`409`		`- impl<'leap, Key, Val, Tuple, Func> Leapers<'leap, Tuple, Val>`
	`409`	`+ impl<'leap, Key, Val, Tuple, Func> Leapers<Tuple, Val>`
`410`	`410`	`for ExtendWith<'leap, Key, Val, Tuple, Func>`
`411`	`411`	`where`
`412`	`412`	`Key: Ord + 'leap,`
`413`		`- Val: Ord + 'leap,`
	`413`	`+ Val: Clone + Ord + 'leap,`
`414`	`414`	`Tuple: Ord,`
`415`	`415`	`Func: Fn(&Tuple) -> Key,`
`416`	`416`	`{`
`417`	`417`	`fn for_each_count(&mut self, tuple: &Tuple, mut op: impl FnMut(usize, usize)) {`
`418`	`418`	`op(0, self.count(tuple))`
`419`	`419`	`}`
`420`	`420`
`421`		`- fn propose(&mut self, tuple: &Tuple, min_index: usize, values: &mut Vec<&'leap Val>) {`
	`421`	`+ fn propose(&mut self, tuple: &Tuple, min_index: usize, values: &mut Vec<Val>) {`
`422`	`422`	`assert_eq!(min_index, 0);`
`423`	`423`	`Leaper::propose(self, tuple, values);`
`424`	`424`	`}`
`425`	`425`
`426`		`- fn intersect(&mut self, _: &Tuple, min_index: usize, _: &mut Vec<&'leap Val>) {`
	`426`	`+ fn intersect(&mut self, _: &Tuple, min_index: usize, _: &mut Vec<Val>) {`
`427`	`427`	`assert_eq!(min_index, 0);`
`428`	`428`	`}`
`429`	`429`	`}`
`@@ -467,7 +467,7 @@ pub(crate) mod extend_anti {`
`467`	`467`	`}`
`468`	`468`	`}`
`469`	`469`
`470`		`- impl<'leap, Key: Ord, Val: Ord + 'leap, Tuple: Ord, Func> Leaper<'leap, Tuple, Val>`
	`470`	`+ impl<'leap, Key: Ord, Val: Ord + 'leap, Tuple: Ord, Func> Leaper<Tuple, Val>`
`471`	`471`	`for ExtendAnti<'leap, Key, Val, Tuple, Func>`
`472`	`472`	`where`
`473`	`473`	`Key: Ord + 'leap,`
`@@ -478,10 +478,10 @@ pub(crate) mod extend_anti {`
`478`	`478`	`fn count(&mut self, _prefix: &Tuple) -> usize {`
`479`	`479`	`usize::max_value()`
`480`	`480`	`}`
`481`		`- fn propose(&mut self, _prefix: &Tuple, _values: &mut Vec<&'leap Val>) {`
	`481`	`+ fn propose(&mut self, _prefix: &Tuple, _values: &mut Vec<Val>) {`
`482`	`482`	`panic!("ExtendAnti::propose(): variable apparently unbound.");`
`483`	`483`	`}`
`484`		`- fn intersect(&mut self, prefix: &Tuple, values: &mut Vec<&'leap Val>) {`
	`484`	`+ fn intersect(&mut self, prefix: &Tuple, values: &mut Vec<Val>) {`
`485`	`485`	`let key = (self.key_func)(prefix);`
`486`	`486`
`487`	`487`	`let range = match self.old_key.as_ref() {`
`@@ -546,7 +546,7 @@ pub(crate) mod filter_with {`
`546`	`546`	`}`
`547`	`547`	`}`
`548`	`548`
`549`		`- impl<'leap, Key, Val, Val2, Tuple, Func> Leaper<'leap, Tuple, Val2>`
	`549`	`+ impl<'leap, Key, Val, Val2, Tuple, Func> Leaper<Tuple, Val2>`
`550`	`550`	`for FilterWith<'leap, Key, Val, Tuple, Func>`
`551`	`551`	`where`
`552`	`552`	`Key: Ord + 'leap,`
`@@ -567,15 +567,15 @@ pub(crate) mod filter_with {`
`567`	`567`	`self.old_key_val = Some((key_val, is_present));`
`568`	`568`	`if is_present { usize::MAX } else { 0 }`
`569`	`569`	`}`
`570`		`- fn propose(&mut self, _prefix: &Tuple, _values: &mut Vec<&'leap Val2>) {`
	`570`	`+ fn propose(&mut self, _prefix: &Tuple, _values: &mut Vec<Val2>) {`
`571`	`571`	`panic!("FilterWith::propose(): variable apparently unbound.");`
`572`	`572`	`}`
`573`		`- fn intersect(&mut self, _prefix: &Tuple, _values: &mut Vec<&'leap Val2>) {`
	`573`	`+ fn intersect(&mut self, _prefix: &Tuple, _values: &mut Vec<Val2>) {`
`574`	`574`	`// Only here because we didn't return zero above, right?`
`575`	`575`	`}`
`576`	`576`	`}`
`577`	`577`
`578`		`- impl<'leap, Key, Val, Tuple, Func> Leapers<'leap, Tuple, ()>`
	`578`	`+ impl<'leap, Key, Val, Tuple, Func> Leapers<Tuple, ()>`
`579`	`579`	`for FilterWith<'leap, Key, Val, Tuple, Func>`
`580`	`580`	`where`
`581`	`581`	`Key: Ord + 'leap,`
`@@ -591,12 +591,12 @@ pub(crate) mod filter_with {`
`591`	`591`	`}`
`592`	`592`	`}`
`593`	`593`
`594`		`- fn propose(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<&'leap ()>) {`
	`594`	`+ fn propose(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<()>) {`
`595`	`595`	`assert_eq!(min_index, 0);`
`596`		`- values.push(&());`
	`596`	`+ values.push(());`
`597`	`597`	`}`
`598`	`598`
`599`		`- fn intersect(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<&'leap ()>) {`
	`599`	`+ fn intersect(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<()>) {`
`600`	`600`	`assert_eq!(min_index, 0);`
`601`	`601`	`assert_eq!(values.len(), 1);`
`602`	`602`	`}`
`@@ -639,7 +639,7 @@ pub(crate) mod filter_anti {`
`639`	`639`	`}`
`640`	`640`	`}`
`641`	`641`
`642`		`- impl<'leap, Key: Ord, Val: Ord + 'leap, Val2, Tuple: Ord, Func> Leaper<'leap, Tuple, Val2>`
	`642`	`+ impl<'leap, Key: Ord, Val: Ord + 'leap, Val2, Tuple: Ord, Func> Leaper<Tuple, Val2>`
`643`	`643`	`for FilterAnti<'leap, Key, Val, Tuple, Func>`
`644`	`644`	`where`
`645`	`645`	`Key: Ord + 'leap,`
`@@ -660,15 +660,15 @@ pub(crate) mod filter_anti {`
`660`	`660`	`self.old_key_val = Some((key_val, is_present));`
`661`	`661`	`if is_present { 0 } else { usize::MAX }`
`662`	`662`	`}`
`663`		`- fn propose(&mut self, _prefix: &Tuple, _values: &mut Vec<&'leap Val2>) {`
	`663`	`+ fn propose(&mut self, _prefix: &Tuple, _values: &mut Vec<Val2>) {`
`664`	`664`	`panic!("FilterAnti::propose(): variable apparently unbound.");`
`665`	`665`	`}`
`666`		`- fn intersect(&mut self, _prefix: &Tuple, _values: &mut Vec<&'leap Val2>) {`
	`666`	`+ fn intersect(&mut self, _prefix: &Tuple, _values: &mut Vec<Val2>) {`
`667`	`667`	`// Only here because we didn't return zero above, right?`
`668`	`668`	`}`
`669`	`669`	`}`
`670`	`670`
`671`		`- impl<'leap, Key, Val, Tuple, Func> Leapers<'leap, Tuple, ()>`
	`671`	`+ impl<'leap, Key, Val, Tuple, Func> Leapers<Tuple, ()>`
`672`	`672`	`for FilterAnti<'leap, Key, Val, Tuple, Func>`
`673`	`673`	`where`
`674`	`674`	`Key: Ord + 'leap,`
`@@ -684,13 +684,13 @@ pub(crate) mod filter_anti {`
`684`	`684`	`}`
`685`	`685`	`}`
`686`	`686`
`687`		`- fn propose(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<&'leap ()>) {`
	`687`	`+ fn propose(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<()>) {`
`688`	`688`	// We only get here if `tuple` is not a member of `self.relation`
`689`	`689`	`assert_eq!(min_index, 0);`
`690`		`- values.push(&());`
	`690`	`+ values.push(());`
`691`	`691`	`}`
`692`	`692`
`693`		`- fn intersect(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<&'leap ()>) {`
	`693`	`+ fn intersect(&mut self, _: &Tuple, min_index: usize, values: &mut Vec<()>) {`
`694`	`694`	// We only get here if `tuple` is not a member of `self.relation`
`695`	`695`	`assert_eq!(min_index, 0);`
`696`	`696`	`assert_eq!(values.len(), 1);`