Spring cleaning

advent_of_code_2017/src/bin/day_09.rs

@@ -107,7 +107,7 @@ where
     unit_ranges
         .iterate(|scope, ranges|
 
-            // Each available range, of size less than usize::max_value(), advertises itself as the range
+            // Each available range, of size less than usize::MAX, advertises itself as the range
             // twice as large, aligned to integer multiples of its size. Each range, which may contain at
             // most two elements, then summarizes itself using the `combine` function. Finally, we re-add
             // the initial `unit_ranges` intervals, so that the set of ranges grows monotonically.

differential-dataflow/src/algorithms/graphs/bfs.rs

@@ -11,7 +11,7 @@ use crate::lattice::Lattice;
 /// Returns pairs (node, dist) indicating distance of each node from a root.
 pub fn bfs<'scope, T, N>(edges: VecCollection<'scope, T, (N,N)>, roots: VecCollection<'scope, T, N>) -> VecCollection<'scope, T, (N,u32)>
 where
-    T: Timestamp + Lattice + Ord,
+    T: Timestamp + Lattice,
     N: ExchangeData+Hash,
 {
     let edges = edges.arrange_by_key();

differential-dataflow/src/algorithms/graphs/bijkstra.rs

@@ -21,7 +21,7 @@ use crate::operators::iterate::Variable;
 /// could be good insurance here.
 pub fn bidijkstra<'scope, T, N>(edges: VecCollection<'scope, T, (N,N)>, goals: VecCollection<'scope, T, (N,N)>) -> VecCollection<'scope, T, ((N,N), u32)>
 where
-    T: Timestamp + Lattice + Ord,
+    T: Timestamp + Lattice,
     N: ExchangeData+Hash,
 {
     let forward = edges.clone().arrange_by_key();

differential-dataflow/src/algorithms/graphs/propagate.rs

@@ -15,7 +15,7 @@ use crate::difference::{Abelian, Multiply};
 /// method to limit the introduction of labels.
 pub fn propagate<'scope, T, N, L, R>(edges: VecCollection<'scope, T, (N,N), R>, nodes: VecCollection<'scope, T,(N,L),R>) -> VecCollection<'scope, T,(N,L),R>
 where
-    T: Timestamp + Lattice + Ord + Hash,
+    T: Timestamp + Lattice + Hash,
     N: ExchangeData+Hash,
     R: ExchangeData+Abelian,
     R: Multiply<R, Output=R>,
@@ -32,7 +32,7 @@ where
 /// method to limit the introduction of labels.
 pub fn propagate_at<'scope, T, N, L, F, R>(edges: VecCollection<'scope, T, (N,N), R>, nodes: VecCollection<'scope, T,(N,L),R>, logic: F) -> VecCollection<'scope, T,(N,L),R>
 where
-    T: Timestamp + Lattice + Ord + Hash,
+    T: Timestamp + Lattice + Hash,
     N: ExchangeData+Hash,
     R: ExchangeData+Abelian,
     R: Multiply<R, Output=R>,

differential-dataflow/src/algorithms/graphs/scc.rs

@@ -14,7 +14,7 @@ use super::propagate::propagate;
 /// Returns the subset of edges in the same strongly connected component.
 pub fn strongly_connected<'scope, T, N, R>(graph: VecCollection<'scope, T, (N,N), R>) -> VecCollection<'scope, T, (N,N), R>
 where
-    T: Timestamp + Lattice + Ord + Hash,
+    T: Timestamp + Lattice + Hash,
     N: ExchangeData + Hash,
     R: ExchangeData + Abelian,
     R: Multiply<R, Output=R>,
@@ -39,7 +39,7 @@ where
 fn trim_edges<'scope, T, N, R>(cycle: VecCollection<'scope, T, (N,N), R>, edges: VecCollection<'scope, T, (N,N), R>)
     -> VecCollection<'scope, T, (N,N), R>
 where
-    T: Timestamp + Lattice + Ord + Hash,
+    T: Timestamp + Lattice + Hash,
     N: ExchangeData + Hash,
     R: ExchangeData + Abelian,
     R: Multiply<R, Output=R>,

differential-dataflow/src/algorithms/graphs/sequential.rs

@@ -11,12 +11,12 @@ use crate::hashable::Hashable;
 
 fn _color<'scope, T, N>(edges: VecCollection<'scope, T, (N,N)>) -> VecCollection<'scope, T,(N,Option<u32>)>
 where
-    T: Timestamp + Lattice + Ord + Hash,
+    T: Timestamp + Lattice + Hash,
     N: ExchangeData+Hash,
 {
     // need some bogus initial values.
     let start = edges.clone()
-                     .map(|(x,_y)| (x,u32::max_value()))
+                     .map(|(x,_y)| (x,u32::MAX))
                      .distinct();
 
     // repeatedly apply color-picking logic.
@@ -45,7 +45,7 @@ pub fn sequence<'scope, T, N, V, F>(
     edges: VecCollection<'scope, T, (N,N)>,
     logic: F) -> VecCollection<'scope, T, (N,Option<V>)>
 where
-    T: Timestamp + Lattice + Hash + Ord,
+    T: Timestamp + Lattice + Hash,
     N: ExchangeData+Hashable,
     V: ExchangeData,
     F: Fn(&N, &[(&V, isize)])->V+'static

differential-dataflow/src/algorithms/prefix_sum.rs

@@ -32,7 +32,7 @@ where
     fn prefix_sum_at<F>(self, locations: VecCollection<'scope, T, (usize, K)>, zero: D, combine: F) -> Self where F: Fn(&K,&D,&D)->D + 'static {
 
         let combine1 = ::std::rc::Rc::new(combine);
-        let combine2 = combine1.clone();
+        let combine2 = ::std::rc::Rc::clone(&combine1);
 
         let ranges = aggregate(self.clone(), move |k,x,y| (*combine1)(k,x,y));
         broadcast(ranges, locations, zero, move |k,x,y| (*combine2)(k,x,y))
@@ -54,7 +54,7 @@ where
         .clone()
         .iterate(|scope, ranges| {
 
-            // Each available range, of size less than usize::max_value(), advertises itself as the range
+            // Each available range, of size less than usize::MAX, advertises itself as the range
             // twice as large, aligned to integer multiples of its size. Each range, which may contain at
             // most two elements, then summarizes itself using the `combine` function. Finally, we re-add
             // the initial `unit_ranges` intervals, so that the set of ranges grows monotonically.
@@ -79,7 +79,7 @@ pub fn broadcast<'scope, T, K, D, F>(
     zero: D,
     combine: F) -> VecCollection<'scope, T, ((usize, K), D)>
 where
-    T: Timestamp + Lattice + Ord + ::std::fmt::Debug,
+    T: Timestamp + Lattice,
     K: ExchangeData + ::std::hash::Hash,
     D: ExchangeData + ::std::hash::Hash,
     F: Fn(&K,&D,&D)->D + 'static,