Modernize many where constraints (#610)

* Modernize many where constraints

* set MSV to 1.79

* Work around MSVC regression

Author: frankmcsherry

.github/workflows/test.yml

@@ -12,10 +12,10 @@ jobs:
         os:
           - ubuntu
           - macos
-          - windows
+          # - windows
         toolchain:
           - stable
-          - 1.78
+          - 1.79
     name: cargo test on ${{ matrix.os }}, rust ${{ matrix.toolchain }}
     runs-on: ${{ matrix.os }}-latest
     steps:

advent_of_code_2017/src/bin/day_09.rs

@@ -97,8 +97,7 @@ fn main() {
 /// Accumulate data in `collection` into all powers-of-two intervals containing them.
 fn pp_aggregate<G, D, F>(collection: Collection<G, (usize, D)>, combine: F) -> Collection<G, ((usize, usize), D)>
 where
-    G: Scope,
-    G::Timestamp: Lattice,
+    G: Scope<Timestamp: Lattice>,
     D: Data,
     F: Fn(D, &D) -> D + 'static,
 {
@@ -132,8 +131,7 @@ fn pp_broadcast<G, D, B, F>(
     zero: D,
     combine: F) -> Collection<G, (usize, B)>
 where
-    G: Scope,
-    G::Timestamp: Lattice+Ord+::std::fmt::Debug,
+    G: Scope<Timestamp: Lattice+Ord+::std::fmt::Debug>,
     D: Data,
     B: Data+::std::hash::Hash,
     F: Fn(&B, &D) -> B + 'static,

differential-dataflow/examples/bfs.rs

@@ -91,9 +91,10 @@ fn main() {
 }
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn bfs<G: Scope>(edges: &Collection<G, Edge>, roots: &Collection<G, Node>) -> Collection<G, (Node, u32)>
-where G::Timestamp: Lattice+Ord {
-
+fn bfs<G>(edges: &Collection<G, Edge>, roots: &Collection<G, Node>) -> Collection<G, (Node, u32)>
+where
+    G: Scope<Timestamp: Lattice+Ord>, 
+{
     // initialize roots as reaching themselves at distance 0
     let nodes = roots.map(|x| (x, 0));
 

differential-dataflow/examples/columnar.rs

@@ -139,7 +139,7 @@ mod container {
         fn default() -> Self { Self::Typed(Default::default()) }
     }
 
-    impl<C: Columnar> Clone for Column<C> where C::Container: Clone {
+    impl<C: Columnar<Container: Clone>> Clone for Column<C> {
         fn clone(&self) -> Self {
             match self {
                 Column::Typed(t) => Column::Typed(t.clone()),
@@ -213,7 +213,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;
@@ -286,7 +286,7 @@ mod builder {
     }
 
     use timely::container::PushInto;
-    impl<C: Columnar, T> PushInto<T> for ColumnBuilder<C> where C::Container: columnar::Push<T> {
+    impl<T, C: Columnar<Container: columnar::Push<T>>> PushInto<T> for ColumnBuilder<C> {
         #[inline]
         fn push_into(&mut self, item: T) {
             self.current.push(item);
@@ -314,7 +314,7 @@ mod builder {
     }
 
     use timely::container::{ContainerBuilder, LengthPreservingContainerBuilder};
-    impl<C: Columnar> ContainerBuilder for ColumnBuilder<C> where C::Container: Clone {
+    impl<C: Columnar<Container: Clone>> ContainerBuilder for ColumnBuilder<C> {
         type Container = Column<C>;
 
         #[inline]
@@ -342,7 +342,7 @@ mod builder {
         }
     }
 
-    impl<C: Columnar> LengthPreservingContainerBuilder for ColumnBuilder<C> where C::Container: Clone { }
+    impl<C: Columnar<Container: Clone>> LengthPreservingContainerBuilder for ColumnBuilder<C> { }
 }
 
 
@@ -396,12 +396,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> PushInto<&'b (D, T, R)>,
     {
         fn push_into(&mut self, container: &'a mut Column<(D, T, R)>) {

differential-dataflow/examples/dynamic.rs

@@ -91,9 +91,10 @@ fn main() {
 }
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn bfs<G: Scope>(edges: &Collection<G, Edge>, roots: &Collection<G, Node>) -> Collection<G, (Node, u32)>
-where G::Timestamp: Lattice+Ord {
-
+fn bfs<G>(edges: &Collection<G, Edge>, roots: &Collection<G, Node>) -> Collection<G, (Node, u32)>
+where
+    G: Scope<Timestamp: Lattice+Ord>, 
+{
     use timely::order::Product;
     use iterate::Variable;
     use differential_dataflow::dynamic::{feedback_summary, pointstamp::PointStamp};

differential-dataflow/examples/graspan.rs

@@ -82,14 +82,14 @@ type Arrange<G,K,V,R> = Arranged<G, TraceValHandle<K, V, <G as ScopeParent>::Tim
 ///
 /// An edge variable provides arranged representations of its contents, even before they are
 /// completely defined, in support of recursively defined productions.
-pub struct EdgeVariable<G: Scope> where G::Timestamp : Lattice {
+pub struct EdgeVariable<G: Scope<Timestamp: Lattice>> {
     variable: Variable<G, Edge, Diff>,
     current: Collection<G, Edge, Diff>,
     forward: Option<Arrange<G, Node, Node, Diff>>,
     reverse: Option<Arrange<G, Node, Node, Diff>>,
 }
 
-impl<G: Scope> EdgeVariable<G> where G::Timestamp : Lattice {
+impl<G: Scope<Timestamp: Lattice>> EdgeVariable<G> {
     /// Creates a new variable initialized with `source`.
     pub fn from(source: &Collection<G, Edge>, step: <G::Timestamp as Timestamp>::Summary) -> Self {
         let variable = Variable::new(&mut source.scope(), step);
@@ -152,9 +152,10 @@ impl Query {
     }
 
     /// Creates a dataflow implementing the query, and returns input and trace handles.
-    pub fn render_in<G: Scope>(&self, scope: &mut G) -> IndexMap<String, RelationHandles<G::Timestamp>>
-    where G::Timestamp: Lattice+::timely::order::TotalOrder {
-
+    pub fn render_in<G>(&self, scope: &mut G) -> IndexMap<String, RelationHandles<G::Timestamp>>
+    where 
+        G: Scope<Timestamp: Lattice+::timely::order::TotalOrder>,
+    {
         // Create new input (handle, stream) pairs
         let mut input_map = IndexMap::new();
         for production in self.productions.iter() {

differential-dataflow/examples/interpreted.rs

@@ -41,8 +41,10 @@ fn main() {
     }).unwrap();
 }
 
-fn interpret<G: Scope>(edges: &Collection<G, Edge>, relations: &[(usize, usize)]) -> Collection<G, Vec<Node>>
-where G::Timestamp: Lattice+Hash+Ord {
+fn interpret<G>(edges: &Collection<G, Edge>, relations: &[(usize, usize)]) -> Collection<G, Vec<Node>>
+where 
+    G: Scope<Timestamp: Lattice+Hash+Ord>,
+{
 
     // arrange the edge relation three ways.
     let as_self = edges.arrange_by_self();

differential-dataflow/examples/itembased_cf.rs

@@ -144,7 +144,7 @@ impl CRP {
         CRP { alpha, discount, weight: 0.0, weights: Vec::new() }
     }
 
-    fn sample<R>(&mut self, rng: &mut R) -> u32 where R: Rng {
+    fn sample<R: Rng>(&mut self, rng: &mut R) -> u32 {
         let mut u = rng.gen::<f64>() * (self.alpha + self.weight);
         for j in 0 .. self.weights.len() {
             if u < self.weights[j] - self.discount {
@@ -164,7 +164,7 @@ impl CRP {
 }
 
 // Generate synthetic interactions with a skewed distribution
-fn generate_interactions<R>(how_many: usize, rng: &mut R) -> Vec<(u32,u32)> where R: Rng {
+fn generate_interactions<R: Rng>(how_many: usize, rng: &mut R) -> Vec<(u32,u32)> {
     let mut interactions = Vec::with_capacity(how_many);
 
     let mut user_sampler = CRP::new(6000.0, 0.35);

differential-dataflow/examples/monoid-bfs.rs

@@ -123,9 +123,10 @@ fn main() {
 }
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn bfs<G: Scope>(edges: &Collection<G, Edge, MinSum>, roots: &Collection<G, Node, MinSum>) -> Collection<G, Node, MinSum>
-where G::Timestamp: Lattice+Ord {
-
+fn bfs<G>(edges: &Collection<G, Edge, MinSum>, roots: &Collection<G, Node, MinSum>) -> Collection<G, Node, MinSum>
+where
+    G: Scope<Timestamp: Lattice+Ord>,
+{
     // repeatedly update minimal distances each node can be reached from each root
     roots.scope().iterative::<u32,_,_>(|scope| {
 

differential-dataflow/examples/pagerank.rs

@@ -79,8 +79,7 @@ fn main() {
 // to its PageRank in the input graph `edges`.
 fn pagerank<G>(iters: Iter, edges: &Collection<G, Edge, Diff>) -> Collection<G, Node, Diff>
 where
-    G: Scope,
-    G::Timestamp: Lattice,
+    G: Scope<Timestamp: Lattice>,
 {
     // initialize many surfers at each node.
     let nodes =