various code style changes

Author: frankmcsherry

src/algorithms/graphs/bfs.rs

@@ -44,4 +44,4 @@ where
              .concat(&nodes)
              .reduce(|_, s, t| t.push((s[0].0.clone(), 1)))
      })
-}
+}

src/operators/arrange/arrangement.rs

@@ -404,7 +404,7 @@ where
                 let frontier = IntoIterator::into_iter([
                     capability.as_ref().map(|c| c.time().clone()),
                     input1.frontier().frontier().get(0).cloned(),
-                ]).flatten().min();
+                ]).filter_map(|t| t).min();
 
                 if let Some(frontier) = frontier {
                     trace.as_mut().map(|t| t.set_logical_compaction(AntichainRef::new(&[frontier])));

src/operators/mod.rs

@@ -40,12 +40,7 @@ impl<'a, V:'a, T, R> EditList<'a, V, T, R> where T: Ord+Clone, R: Semigroup {
     }
     /// Loads the contents of a cursor.
     fn load<C, L>(&mut self, cursor: &mut C, storage: &'a C::Storage, logic: L)
-    where
-        C: Cursor<Val=V, Time=T, R=R>,
-        L: Fn(&T)->T,
-        C::Key: Eq,
-        V: Clone,
-    {
+    where V: Clone, C: Cursor<Val=V, Time=T, R=R>, C::Key: Eq, L: Fn(&T)->T {
         self.clear();
         while cursor.val_valid(storage) {
             cursor.map_times(storage, |time1, diff1| self.push(logic(time1), diff1.clone()));
@@ -108,10 +103,7 @@ impl<'storage, V: Ord+Clone+'storage, T: Lattice+Ord+Clone, R: Semigroup> ValueH
         self.buffer.clear();
     }
     fn load<C, L>(&mut self, cursor: &mut C, storage: &'storage C::Storage, logic: L)
-    where C: Cursor<Val=V, Time=T, R=R>,
-          C::Key: Eq,
-          L: Fn(&T)->T,
-    {
+    where C: Cursor<Val=V, Time=T, R=R>, C::Key: Eq, L: Fn(&T)->T {
         self.edits.load(cursor, storage, logic);
     }
 
@@ -125,9 +117,7 @@ impl<'storage, V: Ord+Clone+'storage, T: Lattice+Ord+Clone, R: Semigroup> ValueH
         key: &C::Key,
         logic: L
     ) -> HistoryReplay<'storage, 'history, V, T, R>
-    where C: Cursor<Val=V, Time=T, R=R>,
-          C::Key: Eq,
-          L: Fn(&T)->T,
+    where C: Cursor<Val=V, Time=T, R=R>, C::Key: Eq, L: Fn(&T)->T
     {
         self.clear();
         cursor.seek_key(storage, key);

src/operators/reduce.rs

@@ -670,9 +670,9 @@ where
         new_interesting: &mut Vec<T>) -> (usize, usize)
     where
         K: Eq+Clone,
-        C1: Cursor<Key=K, Val=V1, Time=T, R=R1>,
-        C2: Cursor<Key=K, Val=V2, Time=T, R=R2>,
-        C3: Cursor<Key=K, Val=V1, Time=T, R=R1>,
+        C1: Cursor<Key = K, Val = V1, Time = T, R = R1>,
+        C2: Cursor<Key = K, Val = V2, Time = T, R = R2>,
+        C3: Cursor<Key = K, Val = V1, Time = T, R = R1>,
         L: FnMut(&K, &[(&V1, R1)], &mut Vec<(V2, R2)>, &mut Vec<(V2, R2)>);
 }
 
@@ -748,9 +748,9 @@ mod history_replay {
             new_interesting: &mut Vec<T>) -> (usize, usize)
         where
             K: Eq+Clone,
-            C1: Cursor<Key=K, Val=V1, Time=T, R=R1>,
-            C2: Cursor<Key=K, Val=V2, Time=T, R=R2>,
-            C3: Cursor<Key=K, Val=V1, Time=T, R=R1>,
+            C1: Cursor<Key = K, Val = V1, Time = T, R = R1>,
+            C2: Cursor<Key = K, Val = V2, Time = T, R = R2>,
+            C3: Cursor<Key = K, Val = V1, Time = T, R = R1>,
             L: FnMut(&K, &[(&V1, R1)], &mut Vec<(V2, R2)>, &mut Vec<(V2, R2)>)
         {
 

src/trace/cursor/cursor_list.rs

@@ -13,10 +13,7 @@ pub struct CursorList<C: Cursor> {
     min_val: Vec<usize>,
 }
 
-impl<C: Cursor> CursorList<C>
-where C::Key: Ord,
-      C::Val: Ord
-{
+impl<C: Cursor> CursorList<C> where C::Key: Ord, C::Val: Ord {
     /// Creates a new cursor list from pre-existing cursors.
     pub fn new(cursors: Vec<C>, storage: &[C::Storage]) -> Self {
 
@@ -44,7 +41,7 @@ where C::Key: Ord,
         self.min_key.clear();
 
         // Determine the index of the cursor with minimum key.
-        let mut min_key_opt: Option<&C::Key> = None;
+        let mut min_key_opt = None;
         for (index, cursor) in self.cursors.iter().enumerate() {
             let key = cursor.get_key(&storage[index]);
             if key.is_some() {
@@ -72,7 +69,7 @@ where C::Key: Ord,
         self.min_val.clear();
 
         // Determine the index of the cursor with minimum value.
-        let mut min_val: Option<&C::Val> = None;
+        let mut min_val = None;
         for &index in self.min_key.iter() {
             let val = self.cursors[index].get_val(&storage[index]);
             if val.is_some() {
@@ -91,12 +88,13 @@ where C::Key: Ord,
 impl<C: Cursor> Cursor for CursorList<C>
 where
     C::Key: Ord,
-    C::Val: Ord
+    C::Val: Ord,
 {
     type Key = C::Key;
     type Val = C::Val;
     type Time = C::Time;
     type R = C::R;
+
     type Storage = Vec<C::Storage>;
 
     // validation methods

src/trace/cursor/cursor_pair.rs

@@ -19,13 +19,14 @@ impl<K, V, T, R, C1, C2> Cursor for CursorPair<C1, C2>
 where
     K: Ord,
     V: Ord,
-    C1: Cursor<Key=K, Val=V, Time=T, R=R>,
-    C2: Cursor<Key=K, Val=V, Time=T, R=R>,
+    C1: Cursor<Key = K, Val = V, Time = T, R = R>,
+    C2: Cursor<Key = K, Val = V, Time = T, R = R>,
 {
     type Key = K;
     type Val = V;
     type Time = T;
     type R = R;
+
     type Storage = (C1::Storage, C2::Storage);
 
     // validation methods
@@ -135,4 +136,4 @@ where
         if self.key_order != Ordering::Greater { self.cursor1.rewind_vals(&storage.0); }
         if self.key_order != Ordering::Less { self.cursor2.rewind_vals(&storage.1); }
     }
-}
+}

src/trace/cursor/mod.rs

@@ -13,6 +13,7 @@ pub use self::cursor_list::CursorList;
 
 /// A cursor for navigating ordered `(key, val, time, diff)` updates.
 pub trait Cursor {
+
     /// Key by which updates are indexed.
     type Key;
     /// Values associated with keys.
@@ -21,6 +22,7 @@ pub trait Cursor {
     type Time;
     /// Associated update.
     type R;
+
     /// Type the cursor addresses data in.
     type Storage;
 

src/trace/implementations/ord.rs

@@ -334,6 +334,7 @@ where
     type Val = V;
     type Time = T;
     type R = R;
+
     type Storage = OrdValBatch<K, V, T, R, O>;
 
     fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K { &self.cursor.key(&storage.layer) }
@@ -643,6 +644,7 @@ where
     }
 }
 
+
 /// A cursor for navigating a single layer.
 #[derive(Debug)]
 pub struct OrdKeyCursor<K, T: Lattice+Ord+Clone, R: Semigroup, O=usize> {
@@ -658,13 +660,11 @@ where
     R: Semigroup,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-
     type Key = K;
     type Val = ();
     type Time = T;
     type R = R;
 
-
     type Storage = OrdKeyBatch<K, T, R, O>;
 
     fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K { &self.cursor.key(&storage.layer) }

src/trace/mod.rs

@@ -41,6 +41,7 @@ pub use self::description::Description;
 /// to update the contents of the trace. These methods are used to examine the contents, and to update the reader's
 /// capabilities (which may release restrictions on the mutations to the underlying trace and cause work to happen).
 pub trait TraceReader {
+
     /// Key by which updates are indexed.
     type Key;
     /// Values associated with keys.
@@ -51,10 +52,10 @@ pub trait TraceReader {
     type R;
 
     /// The type of an immutable collection of updates.
-    type Batch: BatchReader<Key=Self::Key, Val=Self::Val, Time=Self::Time, R=Self::R>+Clone+'static;
+    type Batch: BatchReader<Key = Self::Key, Val = Self::Val, Time = Self::Time, R = Self::R>+Clone+'static;
 
     /// The type used to enumerate the collections contents.
-    type Cursor: Cursor<Key=Self::Key, Val=Self::Val, Time=Self::Time, R=Self::R>;
+    type Cursor: Cursor<Key = Self::Key, Val = Self::Val, Time = Self::Time, R = Self::R>;
 
     /// Provides a cursor over updates contained in the trace.
     fn cursor(&mut self) -> (Self::Cursor, <Self::Cursor as Cursor>::Storage) {
@@ -195,7 +196,9 @@ pub trait TraceReader {
 ///
 /// The trace must be constructable from, and navigable by the `Key`, `Val`, `Time` types, but does not need
 /// to return them.
-pub trait Trace: TraceReader {
+pub trait Trace : TraceReader
+where <Self as TraceReader>::Batch: Batch {
+
     /// Allocates a new empty trace.
     fn new(
         info: ::timely::dataflow::operators::generic::OperatorInfo,
@@ -243,7 +246,7 @@ where
     type R;
 
     /// The type used to enumerate the batch's contents.
-    type Cursor: Cursor<Key=Self::Key, Val=Self::Val, Time=Self::Time, R=Self::R, Storage=Self>;
+    type Cursor: Cursor<Key = Self::Key, Val = Self::Val, Time = Self::Time, R = Self::R, Storage=Self>;
     /// Acquires a cursor to the batch's contents.
     fn cursor(&self) -> Self::Cursor;
     /// The number of updates in the batch.
@@ -370,10 +373,12 @@ pub mod rc_blanket_impls {
     }
 
     impl<B: BatchReader> Cursor for RcBatchCursor<B> {
+
         type Key = B::Key;
         type Val = B::Val;
         type Time = B::Time;
         type R = B::R;
+
         type Storage = Rc<B>;
 
         #[inline] fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.key_valid(storage) }
@@ -450,6 +455,7 @@ pub mod abomonated_blanket_impls {
     use super::{Batch, BatchReader, Batcher, Builder, Merger, Cursor, Description};
 
     impl<B: BatchReader+Abomonation> BatchReader for Abomonated<B, Vec<u8>> {
+
         type Key = B::Key;
         type Val = B::Val;
         type Time = B::Time;
@@ -482,10 +488,12 @@ pub mod abomonated_blanket_impls {
     }
 
     impl<B: BatchReader+Abomonation> Cursor for AbomonatedBatchCursor<B> {
+
         type Key = B::Key;
         type Val = B::Val;
         type Time = B::Time;
         type R = B::R;
+
         type Storage = Abomonated<B, Vec<u8>>;
 
         #[inline] fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.key_valid(storage) }

src/trace/wrappers/enter.rs

@@ -136,7 +136,7 @@ where
         BatchCursorEnter::new(self.batch.cursor())
     }
     fn len(&self) -> usize { self.batch.len() }
-    fn description(&self) -> &Description<Self::Time> { &self.description }
+    fn description(&self) -> &Description<TInner> { &self.description }
 }
 
 impl<B, TInner> BatchEnter<B, TInner>
@@ -152,7 +152,7 @@ where
         let since: Vec<_> = batch.description().since().elements().iter().map(|x| TInner::to_inner(x.clone())).collect();
 
         BatchEnter {
-            batch,
+            batch: batch,
             description: Description::new(Antichain::from(lower), Antichain::from(upper), Antichain::from(since))
         }
     }
@@ -168,20 +168,22 @@ impl<C: Cursor, TInner> CursorEnter<C, TInner> {
     fn new(cursor: C) -> Self {
         CursorEnter {
             phantom: ::std::marker::PhantomData,
-            cursor,
+            cursor: cursor,
         }
     }
 }
 
-impl<C: Cursor, TInner> Cursor for CursorEnter<C, TInner>
+impl<C, TInner> Cursor for CursorEnter<C, TInner>
 where
+    C: Cursor,
     C::Time: Timestamp,
     TInner: Refines<C::Time>+Lattice,
 {
     type Key = C::Key;
     type Val = C::Val;
     type Time = TInner;
     type R = C::R;
+
     type Storage = C::Storage;
 
     #[inline] fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.key_valid(storage) }
@@ -207,6 +209,8 @@ where
     #[inline] fn rewind_vals(&mut self, storage: &Self::Storage) { self.cursor.rewind_vals(storage) }
 }
 
+
+
 /// Wrapper to provide cursor to nested scope.
 pub struct BatchCursorEnter<B: BatchReader, TInner> {
     phantom: ::std::marker::PhantomData<TInner>,
@@ -222,7 +226,7 @@ impl<B: BatchReader, TInner> BatchCursorEnter<B, TInner> {
     }
 }
 
-impl<B: BatchReader, TInner> Cursor for BatchCursorEnter<B, TInner>
+impl<TInner, B: BatchReader> Cursor for BatchCursorEnter<B, TInner>
 where
     B::Time: Timestamp,
     TInner: Refines<B::Time>+Lattice,
@@ -231,6 +235,7 @@ where
     type Val = B::Val;
     type Time = TInner;
     type R = B::R;
+
     type Storage = BatchEnter<B, TInner>;
 
     #[inline] fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.key_valid(&storage.batch) }

src/trace/wrappers/enter_at.rs

@@ -62,8 +62,8 @@ where
     type Time = TInner;
     type R = Tr::R;
 
-    type Batch = BatchEnter<Tr::Batch, TInner, F>;
-    type Cursor = CursorEnter<Tr::Cursor, TInner, F>;
+    type Batch = BatchEnter<Tr::Batch, TInner,F>;
+    type Cursor = CursorEnter<Tr::Cursor, TInner,F>;
 
     fn map_batches<F2: FnMut(&Self::Batch)>(&self, mut f: F2) {
         let logic = self.logic.clone();
@@ -120,7 +120,7 @@ where
     /// Makes a new trace wrapper
     pub fn make_from(trace: Tr, logic: F, prior: G) -> Self {
         TraceEnter {
-            trace,
+            trace: trace,
             stash1: Antichain::new(),
             stash2: Antichain::new(),
             logic,
@@ -207,6 +207,7 @@ where
     type Val = C::Val;
     type Time = TInner;
     type R = C::R;
+
     type Storage = C::Storage;
 
     #[inline] fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.key_valid(storage) }
@@ -235,6 +236,8 @@ where
     #[inline] fn rewind_vals(&mut self, storage: &Self::Storage) { self.cursor.rewind_vals(storage) }
 }
 
+
+
 /// Wrapper to provide cursor to nested scope.
 pub struct BatchCursorEnter<B: BatchReader, TInner, F> {
     phantom: ::std::marker::PhantomData<TInner>,
@@ -252,7 +255,7 @@ impl<B: BatchReader, TInner, F> BatchCursorEnter<B, TInner, F> {
     }
 }
 
-impl<B: BatchReader, TInner, F> Cursor for BatchCursorEnter<B, TInner, F>
+impl<TInner, B: BatchReader, F> Cursor for BatchCursorEnter<B, TInner, F>
 where
     B::Time: Timestamp,
     TInner: Refines<B::Time>+Lattice,
@@ -262,6 +265,7 @@ where
     type Val = B::Val;
     type Time = TInner;
     type R = B::R;
+
     type Storage = BatchEnter<B, TInner, F>;
 
     #[inline] fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.key_valid(&storage.batch) }