Simplify constraints

Author: frankmcsherry

differential-dataflow/examples/columnar.rs

@@ -23,8 +23,8 @@ fn main() {
         worker: timely::WorkerConfig::default(),
     };
 
-    let keys: usize = std::env::args().nth(1).unwrap().parse().unwrap();
-    let size: usize = std::env::args().nth(2).unwrap().parse().unwrap();
+    let keys: usize = std::env::args().nth(1).expect("missing argument 1").parse().unwrap();
+    let size: usize = std::env::args().nth(2).expect("missing argument 2").parse().unwrap();
 
     let timer1 = ::std::time::Instant::now();
     let timer2 = timer1.clone();
@@ -226,7 +226,7 @@ mod container {
     }
 
     use timely::container::PushInto;
-    impl<C: Columnar, T> PushInto<T> for Column<C> where C::Container: columnar::Push<T> {
+    impl<T, C: Columnar<Container: columnar::Push<T>>> PushInto<T> for Column<C> {
         #[inline]
         fn push_into(&mut self, item: T) {
             use columnar::Push;
@@ -408,12 +408,9 @@ pub mod batcher {
 
     impl<'a, D, T, R, C2> PushInto<&'a mut Column<(D, T, R)>> for Chunker<C2>
     where
-        D: Columnar,
-        for<'b> D::Ref<'b>: Ord + Copy,
-        T: Columnar,
-        for<'b> T::Ref<'b>: Ord + Copy,
-        R: Columnar + Semigroup + for<'b> Semigroup<R::Ref<'b>>,
-        for<'b> R::Ref<'b>: Ord,
+        D: for<'b> Columnar<Ref<'b>: Ord>,
+        T: for<'b> Columnar<Ref<'b>: Ord>,
+        R: for<'b> Columnar<Ref<'b>: Ord> + for<'b> Semigroup<R::Ref<'b>>,
         C2: Container + for<'b, 'c> PushInto<(D::Ref<'b>, T::Ref<'b>, &'c R)>,
     {
         fn push_into(&mut self, container: &'a mut Column<(D, T, R)>) {
@@ -485,7 +482,12 @@ pub mod batcher {
             head: usize,
         }
 
-        impl<D: Ord + Columnar, T: Ord + Columnar, R: Columnar> ContainerQueue<Column<(D, T, R)>> for ColumnQueue<(D, T, R)> {
+        impl<D, T, R> ContainerQueue<Column<(D, T, R)>> for ColumnQueue<(D, T, R)>
+        where
+            D: for<'a> Columnar<Ref<'a>: Ord>,
+            T: for<'a> Columnar<Ref<'a>: Ord>,
+            R: Columnar,
+        {
             fn next_or_alloc(&mut self) -> Result<<(D, T, R) as Columnar>::Ref<'_>, Column<(D, T, R)>> {
                 if self.is_empty() {
                     Err(std::mem::take(&mut self.list))
@@ -502,11 +504,6 @@ pub mod batcher {
                 let (data1, time1, _) = self.peek();
                 let (data2, time2, _) = other.peek();
 
-                let data1 = <D as Columnar>::into_owned(data1);
-                let data2 = <D as Columnar>::into_owned(data2);
-                let time1 = <T as Columnar>::into_owned(time1);
-                let time2 = <T as Columnar>::into_owned(time2);
-
                 (data1, time1).cmp(&(data2, time2))
             }
             fn from(list: Column<(D, T, R)>) -> Self {
@@ -527,17 +524,15 @@ pub mod batcher {
 
         impl<D, T, R> MergerChunk for Column<(D, T, R)> 
         where
-            D: Ord + Columnar + 'static,
-            T: Ord + timely::PartialOrder + Clone + Columnar + 'static,
-            for<'a> <T as Columnar>::Ref<'a> : Copy,
+            D: Columnar + 'static,
+            T: timely::PartialOrder + Clone + Columnar + 'static,
             R: Default + Semigroup + Columnar + 'static
         {
             type TimeOwned = T;
             type DiffOwned = R;
 
             fn time_kept((_, time, _): &Self::Item<'_>, upper: &AntichainRef<Self::TimeOwned>, frontier: &mut Antichain<Self::TimeOwned>) -> bool {
                 let time = T::into_owned(*time);
-                // let time = unimplemented!();
                 if upper.less_equal(&time) {
                     frontier.insert(time);
                     true