clean-up

frankmcsherry · Dec 3, 2023 · ae9073c · ae9073c
1 parent d8c855e
commit ae9073c
Show file tree

Hide file tree

Showing 18 changed files with 124 additions and 130 deletions.
diff --git a/dogsdogsdogs/src/operators/lookup_map.rs b/dogsdogsdogs/src/operators/lookup_map.rs
@@ -31,8 +31,6 @@ where
     G::Timestamp: Lattice,
     Tr: TraceReader<Time=G::Timestamp>+Clone+'static,
     Tr::KeyOwned: Hashable,
-    // Tr::Key: Ord+Hashable+Sized,
-    // Tr::Val: Clone,
     Tr::Diff: Monoid+ExchangeData,
     F: FnMut(&D, &mut Tr::KeyOwned)+Clone+'static,
     D: ExchangeData,

diff --git a/examples/cursors.rs b/examples/cursors.rs
@@ -139,7 +139,6 @@ where
     Tr::ValOwned: Debug + Clone,
     Tr::Time: Debug + Clone,
     Tr::Diff: Debug + Clone,
-    <Tr::Cursor as Cursor>::ValOwned: Debug,
 {
     let (mut cursor, storage) = trace.cursor();
     for ((k, v), diffs) in cursor.to_vec(&storage).iter() {

diff --git a/examples/spines.rs b/examples/spines.rs
@@ -30,20 +30,20 @@ fn main() {
             let (keys_input, keys) = scope.new_collection::<String, isize>();
 
             match mode.as_str() {
-                // "new" => {
-                //     use differential_dataflow::trace::implementations::ord_neu::ColKeySpine;
-                //     let data = data.arrange::<ColKeySpine<_,_,_>>();
-                //     let keys = keys.arrange::<ColKeySpine<_,_,_>>();
-                //     keys.join_core(&data, |_k, &(), &()| Option::<()>::None)
-                //         .probe_with(&mut probe);
-                // },
-                // "old" => {
-                //     use differential_dataflow::trace::implementations::ord_neu::OrdKeySpine;
-                //     let data = data.arrange::<OrdKeySpine<_,_,_>>();
-                //     let keys = keys.arrange::<OrdKeySpine<_,_,_>>();
-                //     keys.join_core(&data, |_k, &(), &()| Option::<()>::None)
-                //         .probe_with(&mut probe);
-                // },
+                "new" => {
+                    use differential_dataflow::trace::implementations::ord_neu::ColKeySpine;
+                    let data = data.arrange::<ColKeySpine<_,_,_>>();
+                    let keys = keys.arrange::<ColKeySpine<_,_,_>>();
+                    keys.join_core(&data, |_k, &(), &()| Option::<()>::None)
+                        .probe_with(&mut probe);
+                },
+                "old" => {
+                    use differential_dataflow::trace::implementations::ord_neu::OrdKeySpine;
+                    let data = data.arrange::<OrdKeySpine<_,_,_>>();
+                    let keys = keys.arrange::<OrdKeySpine<_,_,_>>();
+                    keys.join_core(&data, |_k, &(), &()| Option::<()>::None)
+                        .probe_with(&mut probe);
+                },
                 // "rhh" => {
                 //     use differential_dataflow::trace::implementations::rhh::{HashWrapper, VecSpine};
                 //     let data = data.map(|x| HashWrapper { inner: x }).arrange::<VecSpine<_,(),_,_>>();

diff --git a/src/operators/arrange/arrangement.rs b/src/operators/arrange/arrangement.rs
@@ -128,7 +128,7 @@ where
             Tr::Diff: 'static,
             G::Timestamp: Clone+'static,
             TInner: Refines<G::Timestamp>+Lattice+Timestamp+Clone+'static,
-            F: for <'b> FnMut(Tr::Key<'b>, Tr::Val<'b>, &G::Timestamp)->TInner+Clone+'static,
+            F: FnMut(Tr::Key<'_>, Tr::Val<'_>, &G::Timestamp)->TInner+Clone+'static,
             P: FnMut(&TInner)->Tr::Time+Clone+'static,
         {
         let logic1 = logic.clone();
@@ -175,7 +175,7 @@ where
         where
             Tr::Diff: 'static,
             G::Timestamp: Clone+'static,
-            F: for<'a> FnMut(Tr::Key<'a>, Tr::Val<'a>)->bool+Clone+'static,
+            F: FnMut(Tr::Key<'_>, Tr::Val<'_>)->bool+Clone+'static,
     {
         let logic1 = logic.clone();
         let logic2 = logic.clone();
@@ -192,7 +192,7 @@ where
     pub fn as_collection<D: Data, L>(&self, mut logic: L) -> Collection<G, D, Tr::Diff>
         where
             Tr::Diff: Semigroup,
-            L: for<'a> FnMut(Tr::Key<'a>, Tr::Val<'a>) -> D+'static,
+            L: FnMut(Tr::Key<'_>, Tr::Val<'_>) -> D+'static,
     {
         self.flat_map_ref(move |key, val| Some(logic(key,val)))
     }
@@ -206,7 +206,7 @@ where
             Tr::Diff: Semigroup,
             I: IntoIterator,
             I::Item: Data,
-            L: for<'a> FnMut(Tr::Key<'a>, Tr::Val<'a>) -> I+'static,
+            L: FnMut(Tr::Key<'_>, Tr::Val<'_>) -> I+'static,
     {
         Self::flat_map_batches(&self.stream, logic)
     }
@@ -223,7 +223,7 @@ where
         Tr::Diff: Semigroup,
         I: IntoIterator,
         I::Item: Data,
-        L: for<'a> FnMut(Tr::Key<'a>, Tr::Val<'a>) -> I+'static,
+        L: FnMut(Tr::Key<'_>, Tr::Val<'_>) -> I+'static,
     {
         stream.unary(Pipeline, "AsCollection", move |_,_| move |input, output| {
             input.for_each(|time, data| {

diff --git a/src/operators/count.rs b/src/operators/count.rs
@@ -55,14 +55,14 @@ where G::Timestamp: TotalOrder+Lattice+Ord {
     }
 }
 
-impl<G: Scope, K, T1> CountTotal<G, K, T1::Diff> for Arranged<G, T1>
+impl<G: Scope, T1> CountTotal<G, T1::KeyOwned, T1::Diff> for Arranged<G, T1>
 where
     G::Timestamp: TotalOrder+Lattice+Ord,
-    T1: for<'a> TraceReader<Key<'a>=&'a K, Val<'a>=&'a (), Time=G::Timestamp>+Clone+'static,
-    K: ExchangeData,
+    T1: for<'a> TraceReader<Val<'a>=&'a (), Time=G::Timestamp>+Clone+'static,
+    T1::KeyOwned: ExchangeData,
     T1::Diff: ExchangeData+Semigroup,
 {
-    fn count_total_core<R2: Semigroup + From<i8>>(&self) -> Collection<G, (K, T1::Diff), R2> {
+    fn count_total_core<R2: Semigroup + From<i8>>(&self) -> Collection<G, (T1::KeyOwned, T1::Diff), R2> {
 
         let mut trace = self.trace.clone();
         let mut buffer = Vec::new();
@@ -74,6 +74,7 @@ where
 
             move |input, output| {
 
+                use trace::cursor::MyTrait;
                 input.for_each(|capability, batches| {
                     batches.swap(&mut buffer);
                     let mut session = output.session(&capability);
@@ -97,14 +98,14 @@ where
 
                                 if let Some(count) = count.as_ref() {
                                     if !count.is_zero() {
-                                        session.give(((key.clone(), count.clone()), time.clone(), R2::from(-1i8)));
+                                        session.give(((key.into_owned(), count.clone()), time.clone(), R2::from(-1i8)));
                                     }
                                 }
                                 count.as_mut().map(|c| c.plus_equals(diff));
                                 if count.is_none() { count = Some(diff.clone()); }
                                 if let Some(count) = count.as_ref() {
                                     if !count.is_zero() {
-                                        session.give(((key.clone(), count.clone()), time.clone(), R2::from(1i8)));
+                                        session.give(((key.into_owned(), count.clone()), time.clone(), R2::from(1i8)));
                                     }
                                 }
                             });

diff --git a/src/operators/join.rs b/src/operators/join.rs
@@ -357,8 +357,8 @@ impl<G, K, V, T1> JoinCore<G, K, V, T1::Diff> for Arranged<G,T1>
         G: Scope,
         G::Timestamp: Lattice+Ord,
         T1: for<'a> TraceReader<Key<'a> = &'a K, Val<'a> = &'a V, Time=G::Timestamp>+Clone+'static,
-        K: Ord+'static + ?Sized,
-        V: Ord+'static + ?Sized,
+        K: Ord+'static,
+        V: Ord+'static,
         T1::Diff: Semigroup,
 {
     fn join_core<Tr2,I,L>(&self, other: &Arranged<G,Tr2>, mut result: L) -> Collection<G,I::Item,<T1::Diff as Multiply<Tr2::Diff>>::Output>
@@ -796,7 +796,7 @@ where
         }
     }
 
-    fn think<'b, F: FnMut(C1::Val<'a>,C2::Val<'a>,C1::Time,&C1::Diff,&C2::Diff)>(&'b mut self, mut results: F) {
+    fn think<F: FnMut(C1::Val<'a>,C2::Val<'a>,C1::Time,&C1::Diff,&C2::Diff)>(&mut self, mut results: F) {
 
         // for reasonably sized edits, do the dead-simple thing.
         if self.history1.edits.len() < 10 || self.history2.edits.len() < 10 {

diff --git a/src/operators/mod.rs b/src/operators/mod.rs
@@ -91,7 +91,6 @@ struct ValueHistory<'storage, C: Cursor> where C::Time: Sized, C::Diff: Sized {
 
 impl<'storage, C: Cursor> ValueHistory<'storage, C>
 where
-    // C::Val: Ord+'storage,
     C::Time: Lattice+Ord+Clone,
     C::Diff: Semigroup,
 {
@@ -136,7 +135,7 @@ where
     }
 
     /// Organizes history based on current contents of edits.
-    fn replay<'history>(&'history mut self) -> HistoryReplay<'storage, 'history, C> where 'storage: 'history {
+    fn replay<'history>(&'history mut self) -> HistoryReplay<'storage, 'history, C> {
 
         self.buffer.clear();
         self.history.clear();
@@ -164,7 +163,6 @@ struct HistoryReplay<'storage, 'history, C>
 where
     'storage: 'history,
     C: Cursor,
-    // C::Val: Ord+'storage,
     C::Time: Lattice+Ord+Clone+'history,
     C::Diff: Semigroup+'history,
 {
@@ -175,13 +173,12 @@ impl<'storage, 'history, C> HistoryReplay<'storage, 'history, C>
 where
     'storage: 'history,
     C: Cursor,
-    // C::Val: Ord+'storage,
     C::Time: Lattice+Ord+Clone+'history,
     C::Diff: Semigroup+'history,
 {
     fn time(&self) -> Option<&C::Time> { self.replay.history.last().map(|x| &x.0) }
     fn meet(&self) -> Option<&C::Time> { self.replay.history.last().map(|x| &x.1) }
-    fn edit<'s>(&'s self) -> Option<(C::Val<'storage>, &'s C::Time, &'s C::Diff)> {
+    fn edit(&self) -> Option<(C::Val<'storage>, &C::Time, &C::Diff)> {
         self.replay.history.last().map(|&(ref t, _, v, e)| (self.replay.edits.values[v].0, t, &self.replay.edits.edits[e].1))
     }
 

diff --git a/src/trace/cursor/cursor_list.rs b/src/trace/cursor/cursor_list.rs
@@ -130,7 +130,7 @@ impl<C: Cursor> Cursor for CursorList<C> {
         self.minimize_keys(storage);
     }
     #[inline]
-    fn seek_key<'a>(&mut self, storage: &Vec<C::Storage>, key: Self::Key<'a>) {
+    fn seek_key(&mut self, storage: &Vec<C::Storage>, key: Self::Key<'_>) {
         for index in 0 .. self.cursors.len() {
             self.cursors[index].seek_key(&storage[index], key);
         }
@@ -146,7 +146,7 @@ impl<C: Cursor> Cursor for CursorList<C> {
         self.minimize_vals(storage);
     }
     #[inline]
-    fn seek_val<'a>(&mut self, storage: &Vec<C::Storage>, val: Self::Val<'a>) {
+    fn seek_val(&mut self, storage: &Vec<C::Storage>, val: Self::Val<'_>) {
         for &index in self.min_key.iter() {
             self.cursors[index].seek_val(&storage[index], val);
         }

diff --git a/src/trace/cursor/mod.rs b/src/trace/cursor/mod.rs
@@ -102,7 +102,7 @@ pub trait Cursor {
     /// Advances the cursor to the next key.
     fn step_key(&mut self, storage: &Self::Storage);
     /// Advances the cursor to the specified key.
-    fn seek_key<'a>(&mut self, storage: &Self::Storage, key: Self::Key<'a>);
+    fn seek_key(&mut self, storage: &Self::Storage, key: Self::Key<'_>);
     /// Convenience method to get access by reference to an owned key.
     fn seek_key_owned<'a>(&mut self, storage: &Self::Storage, key: &'a Self::KeyOwned) {
         self.seek_key(storage, <Self::Key<'a> as MyTrait<'a>>::borrow_as(key));
@@ -111,7 +111,7 @@ pub trait Cursor {
     /// Advances the cursor to the next value.
     fn step_val(&mut self, storage: &Self::Storage);
     /// Advances the cursor to the specified value.
-    fn seek_val<'a>(&mut self, storage: &Self::Storage, val: Self::Val<'a>);
+    fn seek_val(&mut self, storage: &Self::Storage, val: Self::Val<'_>);
 
     /// Rewinds the cursor to the first key.
     fn rewind_keys(&mut self, storage: &Self::Storage);

diff --git a/src/trace/implementations/ord.rs b/src/trace/implementations/ord.rs
@@ -363,7 +363,7 @@ where
     fn step_key(&mut self, storage: &OrdValBatch<L>){ self.cursor.step(&storage.layer); }
     fn seek_key(&mut self, storage: &OrdValBatch<L>, key: &Self::Key) { self.cursor.seek(&storage.layer, key); }
     fn step_val(&mut self, storage: &OrdValBatch<L>) { self.cursor.child.step(&storage.layer.vals); }
-    fn seek_val<'a>(&mut self, storage: &OrdValBatch<L>, val: Self::Val<'a>) { self.cursor.child.seek(&storage.layer.vals, val); }
+    fn seek_val(&mut self, storage: &OrdValBatch<L>, val: Self::Val<'a>) { self.cursor.child.seek(&storage.layer.vals, val); }
     fn rewind_keys(&mut self, storage: &OrdValBatch<L>) { self.cursor.rewind(&storage.layer); }
     fn rewind_vals(&mut self, storage: &OrdValBatch<L>) { self.cursor.child.rewind(&storage.layer.vals); }
 }

diff --git a/src/trace/implementations/ord_neu.rs b/src/trace/implementations/ord_neu.rs
@@ -470,7 +470,7 @@ mod val_batch {
                 self.key_cursor = storage.storage.keys.len();
             }
         }
-        fn seek_key<'a>(&mut self, storage: &OrdValBatch<L>, key: Self::Key<'a>) {
+        fn seek_key(&mut self, storage: &OrdValBatch<L>, key: Self::Key<'_>) {
             self.key_cursor += storage.storage.keys.advance(self.key_cursor, storage.storage.keys.len(), |x| x.lt(&key));
             if self.key_valid(storage) {
                 self.rewind_vals(storage);
@@ -482,7 +482,7 @@ mod val_batch {
                 self.val_cursor = storage.storage.values_for_key(self.key_cursor).1;
             }
         }
-        fn seek_val<'a>(&mut self, storage: &OrdValBatch<L>, val: Self::Val<'a>) {
+        fn seek_val(&mut self, storage: &OrdValBatch<L>, val: Self::Val<'_>) {
             self.val_cursor += storage.storage.vals.advance(self.val_cursor, storage.storage.values_for_key(self.key_cursor).1, |x| x.lt(&val));
         }
         fn rewind_keys(&mut self, storage: &OrdValBatch<L>) {
@@ -940,7 +940,7 @@ mod key_batch {
                 self.key_cursor = storage.storage.keys.len();
             }
         }
-        fn seek_key<'a>(&mut self, storage: &Self::Storage, key: Self::Key<'a>) {
+        fn seek_key(&mut self, storage: &Self::Storage, key: Self::Key<'_>) {
             self.key_cursor += storage.storage.keys.advance(self.key_cursor, storage.storage.keys.len(), |x| x.lt(&key));
             if self.key_valid(storage) {
                 self.rewind_vals(storage);
@@ -949,7 +949,7 @@ mod key_batch {
         fn step_val(&mut self, _storage: &Self::Storage) {
             self.val_stepped = true;
         }
-        fn seek_val<'a>(&mut self, _storage: &Self::Storage, _val: Self::Val<'a>) { }
+        fn seek_val(&mut self, _storage: &Self::Storage, _val: Self::Val<'_>) { }
         fn rewind_keys(&mut self, storage: &Self::Storage) {
             self.key_cursor = 0;
             if self.key_valid(storage) {

diff --git a/src/trace/implementations/rhh.rs b/src/trace/implementations/rhh.rs
@@ -633,7 +633,7 @@ mod val_batch {
                 self.key_cursor = storage.storage.keys.len();
             }
         }
-        fn seek_key<'a>(&mut self, storage: &RhhValBatch<L>, key: Self::Key<'a>) {
+        fn seek_key(&mut self, storage: &RhhValBatch<L>, key: Self::Key<'_>) {
             // self.key_cursor += storage.storage.keys.advance(self.key_cursor, storage.storage.keys.len(), |x| x.lt(key));
             let desired = storage.storage.desired_location(&key);
             // Advance the cursor, if `desired` is ahead of it.
@@ -659,7 +659,7 @@ mod val_batch {
                 self.val_cursor = storage.storage.values_for_key(self.key_cursor).1;
             }
         }
-        fn seek_val<'a>(&mut self, storage: &RhhValBatch<L>, val: Self::Val<'a>) {
+        fn seek_val(&mut self, storage: &RhhValBatch<L>, val: Self::Val<'_>) {
             self.val_cursor += storage.storage.vals.advance(self.val_cursor, storage.storage.values_for_key(self.key_cursor).1, |x| x.lt(&val));
         }
         fn rewind_keys(&mut self, storage: &RhhValBatch<L>) {