diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index fbf40b2ca9..64a9f1ae2f 100644
--- a/.github/workflows/test.yml
+++ b/.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:
diff --git a/advent_of_code_2017/src/bin/day_09.rs b/advent_of_code_2017/src/bin/day_09.rs
index 7642750b25..058ef7291b 100644
--- a/advent_of_code_2017/src/bin/day_09.rs
+++ b/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,
diff --git a/differential-dataflow/examples/bfs.rs b/differential-dataflow/examples/bfs.rs
index e023d01bb7..037ace6ac0 100644
--- a/differential-dataflow/examples/bfs.rs
+++ b/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));
 
diff --git a/differential-dataflow/examples/columnar.rs b/differential-dataflow/examples/columnar.rs
index 3ab0376662..026c7f2c06 100644
--- a/differential-dataflow/examples/columnar.rs
+++ b/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)>) {
diff --git a/differential-dataflow/examples/dynamic.rs b/differential-dataflow/examples/dynamic.rs
index cfa01461e2..e83de369f4 100644
--- a/differential-dataflow/examples/dynamic.rs
+++ b/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};
diff --git a/differential-dataflow/examples/graspan.rs b/differential-dataflow/examples/graspan.rs
index 3d70096d00..5d1e4f95e3 100644
--- a/differential-dataflow/examples/graspan.rs
+++ b/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() {
diff --git a/differential-dataflow/examples/interpreted.rs b/differential-dataflow/examples/interpreted.rs
index 3a04edaeb6..646ea6c2e2 100644
--- a/differential-dataflow/examples/interpreted.rs
+++ b/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();
diff --git a/differential-dataflow/examples/itembased_cf.rs b/differential-dataflow/examples/itembased_cf.rs
index 814abd4c30..90384fa56b 100644
--- a/differential-dataflow/examples/itembased_cf.rs
+++ b/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);
diff --git a/differential-dataflow/examples/monoid-bfs.rs b/differential-dataflow/examples/monoid-bfs.rs
index 59eddc6084..394b14e69f 100644
--- a/differential-dataflow/examples/monoid-bfs.rs
+++ b/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| {
 
diff --git a/differential-dataflow/examples/pagerank.rs b/differential-dataflow/examples/pagerank.rs
index 417c5c3f9d..107e340923 100644
--- a/differential-dataflow/examples/pagerank.rs
+++ b/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 =
diff --git a/differential-dataflow/examples/progress.rs b/differential-dataflow/examples/progress.rs
index 3bfbec76c0..8ee1d6f291 100644
--- a/differential-dataflow/examples/progress.rs
+++ b/differential-dataflow/examples/progress.rs
@@ -114,14 +114,14 @@ fn main() {
 ///
 /// The computation to determine this, and to maintain it as times change, is an iterative
 /// computation that propagates times and maintains the minimal elements at each location.
-fn frontier<G: Scope, T: Timestamp>(
+fn frontier<G, T>(
     nodes: Collection<G, (Target, Source, T::Summary)>,
     edges: Collection<G, (Source, Target)>,
     times: Collection<G, (Location, T)>,
 ) -> Collection<G, (Location, T)>
 where
-    G::Timestamp: Lattice+Ord,
-    T::Summary: differential_dataflow::ExchangeData,
+    G: Scope<Timestamp: Lattice+Ord>,
+    T: Timestamp<Summary: differential_dataflow::ExchangeData>,
 {
     // Translate node and edge transitions into a common Location to Location edge with an associated Summary.
     let nodes = nodes.map(|(target, source, summary)| (Location::from(target), (Location::from(source), summary)));
@@ -148,13 +148,13 @@ where
 }
 
 /// Summary paths from locations to operator zero inputs.
-fn summarize<G: Scope, T: Timestamp>(
+fn summarize<G, T>(
     nodes: Collection<G, (Target, Source, T::Summary)>,
     edges: Collection<G, (Source, Target)>,
 ) -> Collection<G, (Location, (Location, T::Summary))>
 where
-    G::Timestamp: Lattice+Ord,
-    T::Summary: differential_dataflow::ExchangeData+std::hash::Hash,
+    G: Scope<Timestamp: Lattice+Ord>,
+    T: Timestamp<Summary: differential_dataflow::ExchangeData+std::hash::Hash>,
 {
     // Start from trivial reachability from each input to itself.
     let zero_inputs =
@@ -196,8 +196,8 @@ fn find_cycles<G: Scope, T: Timestamp>(
     edges: Collection<G, (Source, Target)>,
 ) -> Collection<G, (Location, Location)>
 where
-    G::Timestamp: Lattice+Ord,
-    T::Summary: differential_dataflow::ExchangeData,
+    G: Scope<Timestamp: Lattice+Ord>,
+    T: Timestamp<Summary: differential_dataflow::ExchangeData>,
 {
     // Retain node connections along "default" timestamp summaries.
     let nodes = nodes.flat_map(|(target, source, summary)| {
diff --git a/differential-dataflow/examples/stackoverflow.rs b/differential-dataflow/examples/stackoverflow.rs
index b2489c0d87..ab64c51a01 100644
--- a/differential-dataflow/examples/stackoverflow.rs
+++ b/differential-dataflow/examples/stackoverflow.rs
@@ -105,9 +105,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));
 
diff --git a/differential-dataflow/src/algorithms/graphs/bfs.rs b/differential-dataflow/src/algorithms/graphs/bfs.rs
index 2211a52769..9e792e0821 100644
--- a/differential-dataflow/src/algorithms/graphs/bfs.rs
+++ b/differential-dataflow/src/algorithms/graphs/bfs.rs
@@ -11,8 +11,7 @@ use crate::lattice::Lattice;
 /// Returns pairs (node, dist) indicating distance of each node from a root.
 pub fn bfs<G, N>(edges: &Collection<G, (N,N)>, roots: &Collection<G, N>) -> Collection<G, (N,u32)>
 where
-    G: Scope,
-    G::Timestamp: Lattice+Ord,
+    G: Scope<Timestamp: Lattice+Ord>,
     N: ExchangeData+Hash,
 {
     use crate::operators::arrange::arrangement::ArrangeByKey;
diff --git a/differential-dataflow/src/algorithms/graphs/bijkstra.rs b/differential-dataflow/src/algorithms/graphs/bijkstra.rs
index 7dc11c1d94..171563c4e7 100644
--- a/differential-dataflow/src/algorithms/graphs/bijkstra.rs
+++ b/differential-dataflow/src/algorithms/graphs/bijkstra.rs
@@ -22,8 +22,7 @@ use crate::operators::iterate::Variable;
 /// could be good insurance here.
 pub fn bidijkstra<G, N>(edges: &Collection<G, (N,N)>, goals: &Collection<G, (N,N)>) -> Collection<G, ((N,N), u32)>
 where
-    G: Scope,
-    G::Timestamp: Lattice+Ord,
+    G: Scope<Timestamp: Lattice+Ord>,
     N: ExchangeData+Hash,
 {
     use crate::operators::arrange::arrangement::ArrangeByKey;
diff --git a/differential-dataflow/src/algorithms/graphs/propagate.rs b/differential-dataflow/src/algorithms/graphs/propagate.rs
index aeb57b9223..1ba7ad746f 100644
--- a/differential-dataflow/src/algorithms/graphs/propagate.rs
+++ b/differential-dataflow/src/algorithms/graphs/propagate.rs
@@ -16,8 +16,7 @@ use crate::operators::arrange::arrangement::ArrangeByKey;
 /// method to limit the introduction of labels.
 pub fn propagate<G, N, L, R>(edges: &Collection<G, (N,N), R>, nodes: &Collection<G,(N,L),R>) -> Collection<G,(N,L),R>
 where
-    G: Scope,
-    G::Timestamp: Lattice+Ord,
+    G: Scope<Timestamp: Lattice+Ord>,
     N: ExchangeData+Hash,
     R: ExchangeData+Abelian,
     R: Multiply<R, Output=R>,
@@ -34,8 +33,7 @@ where
 /// method to limit the introduction of labels.
 pub fn propagate_at<G, N, L, F, R>(edges: &Collection<G, (N,N), R>, nodes: &Collection<G,(N,L),R>, logic: F) -> Collection<G,(N,L),R>
 where
-    G: Scope,
-    G::Timestamp: Lattice+Ord,
+    G: Scope<Timestamp: Lattice+Ord>,
     N: ExchangeData+Hash,
     R: ExchangeData+Abelian,
     R: Multiply<R, Output=R>,
diff --git a/differential-dataflow/src/algorithms/graphs/scc.rs b/differential-dataflow/src/algorithms/graphs/scc.rs
index 3c4453cd7f..3c784060c0 100644
--- a/differential-dataflow/src/algorithms/graphs/scc.rs
+++ b/differential-dataflow/src/algorithms/graphs/scc.rs
@@ -15,9 +15,8 @@ use super::propagate::propagate;
 /// Iteratively removes nodes with no in-edges.
 pub fn trim<G, N, R>(graph: &Collection<G, (N,N), R>) -> Collection<G, (N,N), R>
 where
-    G: Scope,
-    G::Timestamp: Lattice+Ord,
-    N: ExchangeData+Hash,
+    G: Scope<Timestamp: Lattice+Ord>,
+    N: ExchangeData + Hash,
     R: ExchangeData + Abelian,
     R: Multiply<R, Output=R>,
     R: From<i8>,
@@ -36,9 +35,8 @@ where
 /// Returns the subset of edges in the same strongly connected component.
 pub fn strongly_connected<G, N, R>(graph: &Collection<G, (N,N), R>) -> Collection<G, (N,N), R>
 where
-    G: Scope,
-    G::Timestamp: Lattice+Ord,
-    N: ExchangeData+Hash,
+    G: Scope<Timestamp: Lattice + Ord>,
+    N: ExchangeData + Hash,
     R: ExchangeData + Abelian,
     R: Multiply<R, Output=R>,
     R: From<i8>
@@ -53,9 +51,8 @@ where
 fn trim_edges<G, N, R>(cycle: &Collection<G, (N,N), R>, edges: &Collection<G, (N,N), R>)
     -> Collection<G, (N,N), R>
 where
-    G: Scope,
-    G::Timestamp: Lattice+Ord,
-    N: ExchangeData+Hash,
+    G: Scope<Timestamp: Lattice+Ord>,
+    N: ExchangeData + Hash,
     R: ExchangeData + Abelian,
     R: Multiply<R, Output=R>,
     R: From<i8>
diff --git a/differential-dataflow/src/algorithms/graphs/sequential.rs b/differential-dataflow/src/algorithms/graphs/sequential.rs
index f5a730638c..9ee8d52adf 100644
--- a/differential-dataflow/src/algorithms/graphs/sequential.rs
+++ b/differential-dataflow/src/algorithms/graphs/sequential.rs
@@ -11,8 +11,7 @@ use crate::hashable::Hashable;
 
 fn _color<G, N>(edges: &Collection<G, (N,N)>) -> Collection<G,(N,Option<u32>)>
 where
-    G: Scope,
-    G::Timestamp: Lattice+Ord,
+    G: Scope<Timestamp: Lattice+Ord>,
     N: ExchangeData+Hash,
 {
     // need some bogus initial values.
@@ -45,8 +44,7 @@ pub fn sequence<G, N, V, F>(
     edges: &Collection<G, (N,N)>,
     logic: F) -> Collection<G, (N,Option<V>)>
 where
-    G: Scope,
-    G::Timestamp: Lattice+Hash+Ord,
+    G: Scope<Timestamp: Lattice+Hash+Ord>,
     N: ExchangeData+Hashable,
     V: ExchangeData,
     F: Fn(&N, &[(&V, isize)])->V+'static
diff --git a/differential-dataflow/src/algorithms/identifiers.rs b/differential-dataflow/src/algorithms/identifiers.rs
index 91e18647ca..f5f17522e6 100644
--- a/differential-dataflow/src/algorithms/identifiers.rs
+++ b/differential-dataflow/src/algorithms/identifiers.rs
@@ -33,10 +33,9 @@ pub trait Identifiers<G: Scope, D: ExchangeData, R: ExchangeData+Abelian> {
 
 impl<G, D, R> Identifiers<G, D, R> for Collection<G, D, R>
 where
-    G: Scope,
-    G::Timestamp: Lattice,
-    D: ExchangeData+::std::hash::Hash,
-    R: ExchangeData+Abelian,
+    G: Scope<Timestamp: Lattice>,
+    D: ExchangeData + ::std::hash::Hash,
+    R: ExchangeData + Abelian,
 {
     fn identifiers(&self) -> Collection<G, (D, u64), R> {
 
diff --git a/differential-dataflow/src/algorithms/prefix_sum.rs b/differential-dataflow/src/algorithms/prefix_sum.rs
index 8664c5db2f..57f8d1e7b2 100644
--- a/differential-dataflow/src/algorithms/prefix_sum.rs
+++ b/differential-dataflow/src/algorithms/prefix_sum.rs
@@ -21,10 +21,9 @@ pub trait PrefixSum<G: Scope, K, D> {
 
 impl<G, K, D> PrefixSum<G, K, D> for Collection<G, ((usize, K), D)>
 where
-    G: Scope,
-    G::Timestamp: Lattice,
-    K: ExchangeData+::std::hash::Hash,
-    D: ExchangeData+::std::hash::Hash,
+    G: Scope<Timestamp: Lattice>,
+    K: ExchangeData + ::std::hash::Hash,
+    D: ExchangeData + ::std::hash::Hash,
 {
     fn prefix_sum<F>(&self, zero: D, combine: F) -> Self where F: Fn(&K,&D,&D)->D + 'static {
         self.prefix_sum_at(self.map(|(x,_)| x), zero, combine)
@@ -43,10 +42,9 @@ where
 /// Accumulate data in `collection` into all powers-of-two intervals containing them.
 pub fn aggregate<G, K, D, F>(collection: Collection<G, ((usize, K), D)>, combine: F) -> Collection<G, ((usize, usize, K), D)>
 where
-    G: Scope,
-    G::Timestamp: Lattice,
-    K: ExchangeData+::std::hash::Hash,
-    D: ExchangeData+::std::hash::Hash,
+    G: Scope<Timestamp: Lattice>,
+    K: ExchangeData + ::std::hash::Hash,
+    D: ExchangeData + ::std::hash::Hash,
     F: Fn(&K,&D,&D)->D + 'static,
 {
     // initial ranges are at each index, and with width 2^0.
@@ -79,10 +77,9 @@ pub fn broadcast<G, K, D, F>(
     zero: D,
     combine: F) -> Collection<G, ((usize, K), D)>
 where
-    G: Scope,
-    G::Timestamp: Lattice+Ord+::std::fmt::Debug,
-    K: ExchangeData+::std::hash::Hash,
-    D: ExchangeData+::std::hash::Hash,
+    G: Scope<Timestamp: Lattice + Ord + ::std::fmt::Debug>,
+    K: ExchangeData + ::std::hash::Hash,
+    D: ExchangeData + ::std::hash::Hash,
     F: Fn(&K,&D,&D)->D + 'static,
 {
 
diff --git a/differential-dataflow/src/collection.rs b/differential-dataflow/src/collection.rs
index 5952aed654..e901fc747b 100644
--- a/differential-dataflow/src/collection.rs
+++ b/differential-dataflow/src/collection.rs
@@ -153,7 +153,9 @@ impl<G: Scope, D, R, C: Container + Clone + 'static> Collection<G, D, R, C> {
     /// });
     /// ```
     pub fn inspect_container<F>(&self, func: F) -> Self
-    where F: FnMut(Result<(&G::Timestamp, &C), &[G::Timestamp]>)+'static {
+    where
+        F: FnMut(Result<(&G::Timestamp, &C), &[G::Timestamp]>)+'static,
+    {
         self.inner
             .inspect_container(func)
             .as_collection()
@@ -205,7 +207,10 @@ impl<G: Scope, D, R, C: Container + Clone + 'static> Collection<G, D, R, C> {
     /// ```
     // TODO: Removing this function is possible, but breaks existing callers of `negate` who expect
     //       an inherent method on `Collection`.
-    pub fn negate(&self) -> Collection<G, D, R, C> where StreamCore<G, C>: crate::operators::Negate<G, C> {
+    pub fn negate(&self) -> Collection<G, D, R, C>
+    where 
+        StreamCore<G, C>: crate::operators::Negate<G, C>
+    {
         crate::operators::Negate::negate(&self.inner).as_collection()
     }
 }
@@ -226,8 +231,9 @@ impl<G: Scope, D: Clone+'static, R: Clone+'static> Collection<G, D, R> {
     /// });
     /// ```
     pub fn map<D2, L>(&self, mut logic: L) -> Collection<G, D2, R>
-    where D2: Data,
-          L: FnMut(D) -> D2 + 'static
+    where
+        D2: Data,
+        L: FnMut(D) -> D2 + 'static,
     {
         self.inner
             .map(move |(data, time, delta)| (logic(data), time, delta))
@@ -252,7 +258,9 @@ impl<G: Scope, D: Clone+'static, R: Clone+'static> Collection<G, D, R> {
     /// });
     /// ```
     pub fn map_in_place<L>(&self, mut logic: L) -> Collection<G, D, R>
-    where L: FnMut(&mut D) + 'static {
+    where
+        L: FnMut(&mut D) + 'static,
+    {
         self.inner
             .map_in_place(move |&mut (ref mut data, _, _)| logic(data))
             .as_collection()
@@ -274,10 +282,11 @@ impl<G: Scope, D: Clone+'static, R: Clone+'static> Collection<G, D, R> {
     /// });
     /// ```
     pub fn flat_map<I, L>(&self, mut logic: L) -> Collection<G, I::Item, R>
-        where G::Timestamp: Clone,
-              I: IntoIterator,
-              I::Item: Data,
-              L: FnMut(D) -> I + 'static {
+    where
+        G::Timestamp: Clone,
+        I: IntoIterator<Item: Data>,
+        L: FnMut(D) -> I + 'static,
+    {
         self.inner
             .flat_map(move |(data, time, delta)| logic(data).into_iter().map(move |x| (x, time.clone(), delta.clone())))
             .as_collection()
@@ -297,7 +306,9 @@ impl<G: Scope, D: Clone+'static, R: Clone+'static> Collection<G, D, R> {
     /// });
     /// ```
     pub fn filter<L>(&self, mut logic: L) -> Collection<G, D, R>
-    where L: FnMut(&D) -> bool + 'static {
+    where
+        L: FnMut(&D) -> bool + 'static,
+    {
         self.inner
             .filter(move |(data, _, _)| logic(data))
             .as_collection()
@@ -323,11 +334,11 @@ impl<G: Scope, D: Clone+'static, R: Clone+'static> Collection<G, D, R> {
     /// });
     /// ```
     pub fn explode<D2, R2, I, L>(&self, mut logic: L) -> Collection<G, D2, <R2 as Multiply<R>>::Output>
-    where D2: Data,
-          R2: Semigroup+Multiply<R>,
-          <R2 as Multiply<R>>::Output: Semigroup+'static,
-          I: IntoIterator<Item=(D2,R2)>,
-          L: FnMut(D)->I+'static,
+    where
+        D2: Data,
+        R2: Semigroup+Multiply<R, Output: Semigroup+'static>,
+        I: IntoIterator<Item=(D2,R2)>,
+        L: FnMut(D)->I+'static,
     {
         self.inner
             .flat_map(move |(x, t, d)| logic(x).into_iter().map(move |(x,d2)| (x, t.clone(), d2.multiply(&d))))
@@ -357,12 +368,12 @@ impl<G: Scope, D: Clone+'static, R: Clone+'static> Collection<G, D, R> {
     /// });
     /// ```
     pub fn join_function<D2, R2, I, L>(&self, mut logic: L) -> Collection<G, D2, <R2 as Multiply<R>>::Output>
-    where G::Timestamp: Lattice,
-          D2: Data,
-          R2: Semigroup+Multiply<R>,
-          <R2 as Multiply<R>>::Output: Semigroup+'static,
-          I: IntoIterator<Item=(D2,G::Timestamp,R2)>,
-          L: FnMut(D)->I+'static,
+    where
+        G::Timestamp: Lattice,
+        D2: Data,
+        R2: Semigroup+Multiply<R, Output: Semigroup+'static>,
+        I: IntoIterator<Item=(D2,G::Timestamp,R2)>,
+        L: FnMut(D)->I+'static,
     {
         self.inner
             .flat_map(move |(x, t, d)| logic(x).into_iter().map(move |(x,t2,d2)| (x, t.join(&t2), d2.multiply(&d))))
@@ -444,8 +455,9 @@ impl<G: Scope, D: Clone+'static, R: Clone+'static> Collection<G, D, R> {
     /// is because we advance the timely capability with the same logic, and it must remain `less_equal`
     /// to all of the data timestamps).
     pub fn delay<F>(&self, func: F) -> Collection<G, D, R>
-    where F: FnMut(&G::Timestamp) -> G::Timestamp + Clone + 'static {
-
+    where
+        F: FnMut(&G::Timestamp) -> G::Timestamp + Clone + 'static,
+    {
         let mut func1 = func.clone();
         let mut func2 = func.clone();
 
@@ -479,7 +491,9 @@ impl<G: Scope, D: Clone+'static, R: Clone+'static> Collection<G, D, R> {
     /// });
     /// ```
     pub fn inspect<F>(&self, func: F) -> Collection<G, D, R>
-    where F: FnMut(&(D, G::Timestamp, R))+'static {
+    where
+        F: FnMut(&(D, G::Timestamp, R))+'static,
+    {
         self.inner
             .inspect(func)
             .as_collection()
@@ -503,7 +517,9 @@ impl<G: Scope, D: Clone+'static, R: Clone+'static> Collection<G, D, R> {
     /// });
     /// ```
     pub fn inspect_batch<F>(&self, mut func: F) -> Collection<G, D, R>
-    where F: FnMut(&G::Timestamp, &[(D, G::Timestamp, R)])+'static {
+    where
+        F: FnMut(&G::Timestamp, &[(D, G::Timestamp, R)])+'static,
+    {
         self.inner
             .inspect_batch(move |time, data| func(time, data))
             .as_collection()
@@ -529,9 +545,10 @@ impl<G: Scope, D: Clone+'static, R: Clone+'static> Collection<G, D, R> {
     /// });
     /// ```
     pub fn assert_empty(&self)
-    where D: crate::ExchangeData+Hashable,
-          R: crate::ExchangeData+Hashable + Semigroup,
-          G::Timestamp: Lattice+Ord,
+    where
+        D: crate::ExchangeData+Hashable,
+        R: crate::ExchangeData+Hashable + Semigroup,
+        G::Timestamp: Lattice+Ord,
     {
         self.consolidate()
             .inspect(|x| panic!("Assertion failed: non-empty collection: {:?}", x));
@@ -589,7 +606,7 @@ impl<G: Scope, D, R, C: Container+Data> Collection<Child<'_, G, G::Timestamp>, D
 }
 
 /// Methods requiring an Abelian difference, to support negation.
-impl<G: Scope, D: Clone+'static, R: Abelian+'static> Collection<G, D, R> where G::Timestamp: Data {
+impl<G: Scope<Timestamp: Data>, D: Clone+'static, R: Abelian+'static> Collection<G, D, R> {
     /// Assert if the collections are ever different.
     ///
     /// Because this is a dataflow fragment, the test is only applied as the computation is run. If the computation
@@ -614,9 +631,10 @@ impl<G: Scope, D: Clone+'static, R: Abelian+'static> Collection<G, D, R> where G
     /// });
     /// ```
     pub fn assert_eq(&self, other: &Self)
-    where D: crate::ExchangeData+Hashable,
-          R: crate::ExchangeData+Hashable,
-          G::Timestamp: Lattice+Ord
+    where
+        D: crate::ExchangeData+Hashable,
+        R: crate::ExchangeData+Hashable,
+        G::Timestamp: Lattice+Ord,
     {
         self.negate()
             .concat(other)
@@ -665,7 +683,7 @@ pub fn concatenate<G, D, R, C, I>(scope: &mut G, iterator: I) -> Collection<G, D
 where
     G: Scope,
     D: Data,
-    R: Semigroup+'static,
+    R: Semigroup + 'static,
     C: Container + Clone + 'static,
     I: IntoIterator<Item=Collection<G, D, R, C>>,
 {
diff --git a/differential-dataflow/src/consolidation.rs b/differential-dataflow/src/consolidation.rs
index 9c1ed008e9..1fbb283b13 100644
--- a/differential-dataflow/src/consolidation.rs
+++ b/differential-dataflow/src/consolidation.rs
@@ -293,7 +293,7 @@ impl<D, T, R> ConsolidateLayout for Vec<(D, T, R)>
 where
     D: Ord + Clone + 'static,
     T: Ord + Clone + 'static,
-    for<'a> R: Semigroup + IntoOwned<'a, Owned = R> + Clone + 'static,
+    R: Semigroup + for<'a> IntoOwned<'a, Owned = R> + Clone + 'static,
 {
     type Key<'a> = (D, T) where Self: 'a;
     type Diff<'a> = R where Self: 'a;
diff --git a/differential-dataflow/src/containers.rs b/differential-dataflow/src/containers.rs
index 84d10017f6..9d974104c1 100644
--- a/differential-dataflow/src/containers.rs
+++ b/differential-dataflow/src/containers.rs
@@ -38,7 +38,7 @@ impl<T: Columnation> TimelyStack<T> {
     #[inline(always)]
     pub fn reserve_items<'a, I>(&mut self, items: I)
     where
-        I: Iterator<Item= &'a T>+Clone,
+        I: Iterator<Item= &'a T> + Clone,
         T: 'a,
     {
         self.local.reserve(items.clone().count());
@@ -53,7 +53,7 @@ impl<T: Columnation> TimelyStack<T> {
     pub fn reserve_regions<'a, I>(&mut self, regions: I)
     where
         Self: 'a,
-        I: Iterator<Item= &'a Self>+Clone,
+        I: Iterator<Item= &'a Self> + Clone,
     {
         self.local.reserve(regions.clone().map(|cs| cs.local.len()).sum());
         self.inner.reserve_regions(regions.map(|cs| &cs.inner));
diff --git a/differential-dataflow/src/dynamic/pointstamp.rs b/differential-dataflow/src/dynamic/pointstamp.rs
index 5928da185c..abc2c574da 100644
--- a/differential-dataflow/src/dynamic/pointstamp.rs
+++ b/differential-dataflow/src/dynamic/pointstamp.rs
@@ -263,24 +263,16 @@ mod columnation {
     }
 
     /// Stack for PointStamp. Part of Columnation implementation.
-    pub struct PointStampStack<R: Region>(<Vec<R::Item> as Columnation>::InnerRegion)
-    where
-        <R as Region>::Item: Columnation;
-
-    impl<R: Region> Default for PointStampStack<R>
-    where
-        <R as Region>::Item: Columnation
-    {
+    pub struct PointStampStack<R: Region<Item: Columnation>>(<Vec<R::Item> as Columnation>::InnerRegion);
+
+    impl<R: Region<Item: Columnation>> Default for PointStampStack<R> {
         #[inline]
         fn default() -> Self {
             Self(Default::default())
         }
     }
 
-    impl<R: Region> Region for PointStampStack<R>
-    where
-        <R as Region>::Item: Columnation
-    {
+    impl<R: Region<Item: Columnation>> Region for PointStampStack<R> {
         type Item = PointStamp<R::Item>;
 
         #[inline]
diff --git a/differential-dataflow/src/input.rs b/differential-dataflow/src/input.rs
index 5a73b14a9a..f39402fc3e 100644
--- a/differential-dataflow/src/input.rs
+++ b/differential-dataflow/src/input.rs
@@ -68,7 +68,7 @@ pub trait Input : TimelyInput {
     /// }).unwrap();
     /// ```
     fn new_collection_from<I>(&mut self, data: I) -> (InputSession<<Self as ScopeParent>::Timestamp, I::Item, isize>, Collection<Self, I::Item, isize>)
-    where I: IntoIterator+'static, I::Item: Data;
+    where I: IntoIterator<Item: Data> + 'static;
     /// Create a new collection and input handle from initial data.
     ///
     /// # Examples
@@ -100,7 +100,9 @@ pub trait Input : TimelyInput {
 use crate::lattice::Lattice;
 impl<G: TimelyInput> Input for G where <G as ScopeParent>::Timestamp: Lattice {
     fn new_collection<D, R>(&mut self) -> (InputSession<<G as ScopeParent>::Timestamp, D, R>, Collection<G, D, R>)
-    where D: Data, R: Semigroup+'static{
+    where
+        D: Data, R: Semigroup+'static,
+    {
         let (handle, stream) = self.new_input();
         (InputSession::from(handle), stream.as_collection())
     }
diff --git a/differential-dataflow/src/logging.rs b/differential-dataflow/src/logging.rs
index bf6e6bbd77..4fb6ef4300 100644
--- a/differential-dataflow/src/logging.rs
+++ b/differential-dataflow/src/logging.rs
@@ -13,7 +13,7 @@ pub type Logger = ::timely::logging_core::TypedLogger<DifferentialEventBuilder,
 pub fn enable<A, W>(worker: &mut timely::worker::Worker<A>, writer: W) -> Option<Box<dyn std::any::Any+'static>>
 where
     A: timely::communication::Allocate,
-    W: std::io::Write+'static,
+    W: std::io::Write + 'static,
 {
     worker.log_register().and_then(|mut log_register| {
         let writer = ::timely::dataflow::operators::capture::EventWriter::new(writer);
diff --git a/differential-dataflow/src/operators/arrange/agent.rs b/differential-dataflow/src/operators/arrange/agent.rs
index bc74e82cd4..336fe6c81f 100644
--- a/differential-dataflow/src/operators/arrange/agent.rs
+++ b/differential-dataflow/src/operators/arrange/agent.rs
@@ -10,7 +10,7 @@ use timely::progress::Timestamp;
 use timely::progress::{Antichain, frontier::AntichainRef};
 use timely::dataflow::operators::CapabilitySet;
 
-use crate::trace::{Trace, TraceReader, Batch, BatchReader};
+use crate::trace::{Trace, TraceReader, BatchReader};
 use crate::trace::wrappers::rc::TraceBox;
 
 use timely::scheduling::Activator;
@@ -25,10 +25,7 @@ use crate::trace::wrappers::frontier::{TraceFrontier, BatchFrontier};
 ///
 /// The `TraceAgent` is the default trace type produced by `arranged`, and it can be extracted
 /// from the dataflow in which it was defined, and imported into other dataflows.
-pub struct TraceAgent<Tr>
-where
-    Tr: TraceReader,
-{
+pub struct TraceAgent<Tr: TraceReader> {
     trace: Rc<RefCell<TraceBox<Tr>>>,
     queues: Weak<RefCell<Vec<TraceAgentQueueWriter<Tr>>>>,
     logical_compaction: Antichain<Tr::Time>,
@@ -39,10 +36,7 @@ where
     logging: Option<crate::logging::Logger>,
 }
 
-impl<Tr> TraceReader for TraceAgent<Tr>
-where
-    Tr: TraceReader,
-{
+impl<Tr: TraceReader> TraceReader for TraceAgent<Tr> {
     type Key<'a> = Tr::Key<'a>;
     type Val<'a> = Tr::Val<'a>;
     type Time = Tr::Time;
@@ -87,7 +81,6 @@ impl<Tr: TraceReader> TraceAgent<Tr> {
     pub fn new(trace: Tr, operator: OperatorInfo, logging: Option<crate::logging::Logger>) -> (Self, TraceWriter<Tr>)
     where
         Tr: Trace,
-        Tr::Batch: Batch,
     {
         let trace = Rc::new(RefCell::new(TraceBox::new(trace)));
         let queues = Rc::new(RefCell::new(Vec::new()));
@@ -167,10 +160,7 @@ impl<Tr: TraceReader> TraceAgent<Tr> {
     }
 }
 
-impl<Tr> TraceAgent<Tr>
-where
-    Tr: TraceReader+'static,
-{
+impl<Tr: TraceReader+'static> TraceAgent<Tr> {
     /// Copies an existing collection into the supplied scope.
     ///
     /// This method creates an `Arranged` collection that should appear indistinguishable from applying `arrange`
@@ -525,10 +515,7 @@ impl<T> Drop for ShutdownDeadmans<T> {
     }
 }
 
-impl<Tr> Clone for TraceAgent<Tr>
-where
-    Tr: TraceReader,
-{
+impl<Tr: TraceReader> Clone for TraceAgent<Tr> {
     fn clone(&self) -> Self {
 
         if let Some(logging) = &self.logging {
@@ -554,10 +541,7 @@ where
     }
 }
 
-impl<Tr> Drop for TraceAgent<Tr>
-where
-    Tr: TraceReader,
-{
+impl<Tr: TraceReader> Drop for TraceAgent<Tr> {
     fn drop(&mut self) {
 
         if let Some(logging) = &self.logging {
diff --git a/differential-dataflow/src/operators/arrange/arrangement.rs b/differential-dataflow/src/operators/arrange/arrangement.rs
index d1387c742f..189cf7dd26 100644
--- a/differential-dataflow/src/operators/arrange/arrangement.rs
+++ b/differential-dataflow/src/operators/arrange/arrangement.rs
@@ -29,7 +29,7 @@ use timely::dataflow::operators::Capability;
 use crate::{Data, ExchangeData, Collection, AsCollection, Hashable, IntoOwned};
 use crate::difference::Semigroup;
 use crate::lattice::Lattice;
-use crate::trace::{self, Trace, TraceReader, Batch, BatchReader, Batcher, Builder, Cursor};
+use crate::trace::{self, Trace, TraceReader, BatchReader, Batcher, Builder, Cursor};
 use crate::trace::implementations::{KeyBatcher, KeyBuilder, KeySpine, ValBatcher, ValBuilder, ValSpine};
 
 use trace::wrappers::enter::{TraceEnter, BatchEnter,};
@@ -43,9 +43,9 @@ use super::TraceAgent;
 ///
 /// An `Arranged` allows multiple differential operators to share the resources (communication,
 /// computation, memory) required to produce and maintain an indexed representation of a collection.
-pub struct Arranged<G: Scope, Tr>
+pub struct Arranged<G, Tr>
 where
-    G::Timestamp: Lattice+Ord,
+    G: Scope<Timestamp: Lattice+Ord>,
     Tr: TraceReader+Clone,
 {
     /// A stream containing arranged updates.
@@ -187,8 +187,7 @@ where
     /// filtering or flat mapping as part of the extraction.
     pub fn flat_map_ref<I, L>(&self, logic: L) -> Collection<G, I::Item, Tr::Diff>
         where
-            I: IntoIterator,
-            I::Item: Data,
+            I: IntoIterator<Item: Data>,
             L: FnMut(Tr::Key<'_>, Tr::Val<'_>) -> I+'static,
     {
         Self::flat_map_batches(&self.stream, logic)
@@ -203,8 +202,7 @@ where
     /// If you have the arrangement, its `flat_map_ref` method is equivalent to this.
     pub fn flat_map_batches<I, L>(stream: &Stream<G, Tr::Batch>, mut logic: L) -> Collection<G, I::Item, Tr::Diff>
     where
-        I: IntoIterator,
-        I::Item: Data,
+        I: IntoIterator<Item: Data>,
         L: FnMut(Tr::Key<'_>, Tr::Val<'_>) -> I+'static,
     {
         stream.unary(Pipeline, "AsCollection", move |_,_| move |input, output| {
@@ -243,10 +241,8 @@ where
     pub fn join_core<T2,I,L>(&self, other: &Arranged<G,T2>, mut result: L) -> Collection<G,I::Item,<T1::Diff as Multiply<T2::Diff>>::Output>
     where
         T2: for<'a> TraceReader<Key<'a>=T1::Key<'a>,Time=T1::Time>+Clone+'static,
-        T1::Diff: Multiply<T2::Diff>,
-        <T1::Diff as Multiply<T2::Diff>>::Output: Semigroup+'static,
-        I: IntoIterator,
-        I::Item: Data,
+        T1::Diff: Multiply<T2::Diff, Output: Semigroup+'static>,
+        I: IntoIterator<Item: Data>,
         L: FnMut(T1::Key<'_>,T1::Val<'_>,T2::Val<'_>)->I+'static
     {
         let result = move |k: T1::Key<'_>, v1: T1::Val<'_>, v2: T2::Val<'_>, t: &G::Timestamp, r1: &T1::Diff, r2: &T2::Diff| {
@@ -290,14 +286,15 @@ where
     pub fn reduce_abelian<L, K, V, Bu, T2>(&self, name: &str, mut logic: L) -> Arranged<G, TraceAgent<T2>>
     where
         for<'a> T1::Key<'a>: IntoOwned<'a, Owned = K>,
-        T2: for<'a> Trace<Key<'a>= T1::Key<'a>, Time=T1::Time>+'static,
+        T2: for<'a> Trace<
+            Key<'a>= T1::Key<'a>,
+            Val<'a> : IntoOwned<'a, Owned = V>,
+            Time=T1::Time,
+            Diff: Abelian,
+        >+'static,
         K: Ord + 'static,
         V: Data,
-        for<'a> T2::Val<'a> : IntoOwned<'a, Owned = V>,
-        T2::Diff: Abelian,
-        T2::Batch: Batch,
-        Bu: Builder<Time=G::Timestamp, Output = T2::Batch>,
-        Bu::Input: Container + PushInto<((K, V), T2::Time, T2::Diff)>,
+        Bu: Builder<Time=G::Timestamp, Output = T2::Batch, Input: Container + PushInto<((K, V), T2::Time, T2::Diff)>>,
         L: FnMut(T1::Key<'_>, &[(T1::Val<'_>, T1::Diff)], &mut Vec<(V, T2::Diff)>)+'static,
     {
         self.reduce_core::<_,K,V,Bu,T2>(name, move |key, input, output, change| {
@@ -313,13 +310,14 @@ where
     pub fn reduce_core<L, K, V, Bu, T2>(&self, name: &str, logic: L) -> Arranged<G, TraceAgent<T2>>
     where
         for<'a> T1::Key<'a>: IntoOwned<'a, Owned = K>,
-        T2: for<'a> Trace<Key<'a>=T1::Key<'a>, Time=T1::Time>+'static,
+        T2: for<'a> Trace<
+            Key<'a>=T1::Key<'a>,
+            Val<'a> : IntoOwned<'a, Owned = V>,
+            Time=T1::Time,
+        >+'static,
         K: Ord + 'static,
         V: Data,
-        for<'a> T2::Val<'a> : IntoOwned<'a, Owned = V>,
-        T2::Batch: Batch,
-        Bu: Builder<Time=G::Timestamp, Output = T2::Batch>,
-        Bu::Input: Container + PushInto<((K, V), T2::Time, T2::Diff)>,
+        Bu: Builder<Time=G::Timestamp, Output = T2::Batch, Input: Container + PushInto<((K, V), T2::Time, T2::Diff)>>,
         L: FnMut(T1::Key<'_>, &[(T1::Val<'_>, T1::Diff)], &mut Vec<(V, T2::Diff)>, &mut Vec<(V, T2::Diff)>)+'static,
     {
         use crate::operators::reduce::reduce_trace;
@@ -349,8 +347,7 @@ where
 /// A type that can be arranged as if a collection of updates.
 pub trait Arrange<G, C>
 where
-    G: Scope,
-    G::Timestamp: Lattice,
+    G: Scope<Timestamp: Lattice>,
 {
     /// Arranges updates into a shared trace.
     fn arrange<Ba, Bu, Tr>(&self) -> Arranged<G, TraceAgent<Tr>>
@@ -358,7 +355,6 @@ where
         Ba: Batcher<Input=C, Time=G::Timestamp> + 'static,
         Bu: Builder<Time=G::Timestamp, Input=Ba::Output, Output = Tr::Batch>,
         Tr: Trace<Time=G::Timestamp> + 'static,
-        Tr::Batch: Batch,
     {
         self.arrange_named::<Ba, Bu, Tr>("Arrange")
     }
@@ -369,14 +365,12 @@ where
         Ba: Batcher<Input=C, Time=G::Timestamp> + 'static,
         Bu: Builder<Time=G::Timestamp, Input=Ba::Output, Output = Tr::Batch>,
         Tr: Trace<Time=G::Timestamp> + 'static,
-        Tr::Batch: Batch,
     ;
 }
 
 impl<G, K, V, R> Arrange<G, Vec<((K, V), G::Timestamp, R)>> for Collection<G, (K, V), R>
 where
-    G: Scope,
-    G::Timestamp: Lattice,
+    G: Scope<Timestamp: Lattice>,
     K: ExchangeData + Hashable,
     V: ExchangeData,
     R: ExchangeData + Semigroup,
@@ -386,7 +380,6 @@ where
         Ba: Batcher<Input=Vec<((K, V), G::Timestamp, R)>, Time=G::Timestamp> + 'static,
         Bu: Builder<Time=G::Timestamp, Input=Ba::Output, Output = Tr::Batch>,
         Tr: Trace<Time=G::Timestamp> + 'static,
-        Tr::Batch: Batch,
     {
         let exchange = Exchange::new(move |update: &((K,V),G::Timestamp,R)| (update.0).0.hashed().into());
         arrange_core::<_, _, Ba, Bu, _>(&self.inner, exchange, name)
@@ -400,14 +393,11 @@ where
 /// be consistently by key (though this is the most common).
 pub fn arrange_core<G, P, Ba, Bu, Tr>(stream: &StreamCore<G, Ba::Input>, pact: P, name: &str) -> Arranged<G, TraceAgent<Tr>>
 where
-    G: Scope,
-    G::Timestamp: Lattice,
+    G: Scope<Timestamp: Lattice>,
     P: ParallelizationContract<G::Timestamp, Ba::Input>,
-    Ba: Batcher<Time=G::Timestamp> + 'static,
-    Ba::Input: Container + Clone + 'static,
+    Ba: Batcher<Time=G::Timestamp,Input: Container + Clone + 'static> + 'static,
     Bu: Builder<Time=G::Timestamp, Input=Ba::Output, Output = Tr::Batch>,
     Tr: Trace<Time=G::Timestamp>+'static,
-    Tr::Batch: Batch,
 {
     // The `Arrange` operator is tasked with reacting to an advancing input
     // frontier by producing the sequence of batches whose lower and upper
@@ -555,16 +545,15 @@ where
     Arranged { stream, trace: reader.unwrap() }
 }
 
-impl<G: Scope, K: ExchangeData+Hashable, R: ExchangeData+Semigroup> Arrange<G, Vec<((K, ()), G::Timestamp, R)>> for Collection<G, K, R>
+impl<G, K: ExchangeData+Hashable, R: ExchangeData+Semigroup> Arrange<G, Vec<((K, ()), G::Timestamp, R)>> for Collection<G, K, R>
 where
-    G::Timestamp: Lattice+Ord,
+    G: Scope<Timestamp: Lattice+Ord>,
 {
     fn arrange_named<Ba, Bu, Tr>(&self, name: &str) -> Arranged<G, TraceAgent<Tr>>
     where
         Ba: Batcher<Input=Vec<((K,()),G::Timestamp,R)>, Time=G::Timestamp> + 'static,
         Bu: Builder<Time=G::Timestamp, Input=Ba::Output, Output = Tr::Batch>,
         Tr: Trace<Time=G::Timestamp> + 'static,
-        Tr::Batch: Batch,
     {
         let exchange = Exchange::new(move |update: &((K,()),G::Timestamp,R)| (update.0).0.hashed().into());
         arrange_core::<_,_,Ba,Bu,_>(&self.map(|k| (k, ())).inner, exchange, name)
@@ -577,7 +566,9 @@ where
 /// map. This can result in many hash calls, and in some cases it may help to first transform `K` to the
 /// pair `(u64, K)` of hash value and key.
 pub trait ArrangeByKey<G: Scope, K: Data+Hashable, V: Data, R: Ord+Semigroup+'static>
-where G::Timestamp: Lattice+Ord {
+where
+    G: Scope<Timestamp: Lattice+Ord>,
+{
     /// Arranges a collection of `(Key, Val)` records by `Key`.
     ///
     /// This operator arranges a stream of values into a shared trace, whose contents it maintains.
@@ -589,9 +580,9 @@ where G::Timestamp: Lattice+Ord {
     fn arrange_by_key_named(&self, name: &str) -> Arranged<G, TraceAgent<ValSpine<K, V, G::Timestamp, R>>>;
 }
 
-impl<G: Scope, K: ExchangeData+Hashable, V: ExchangeData, R: ExchangeData+Semigroup> ArrangeByKey<G, K, V, R> for Collection<G, (K,V), R>
+impl<G, K: ExchangeData+Hashable, V: ExchangeData, R: ExchangeData+Semigroup> ArrangeByKey<G, K, V, R> for Collection<G, (K,V), R>
 where
-    G::Timestamp: Lattice+Ord
+    G: Scope<Timestamp: Lattice+Ord>,
 {
     fn arrange_by_key(&self) -> Arranged<G, TraceAgent<ValSpine<K, V, G::Timestamp, R>>> {
         self.arrange_by_key_named("ArrangeByKey")
@@ -607,9 +598,9 @@ where
 /// This arrangement requires `Key: Hashable`, and uses the `hashed()` method to place keys in a hashed
 /// map. This can result in many hash calls, and in some cases it may help to first transform `K` to the
 /// pair `(u64, K)` of hash value and key.
-pub trait ArrangeBySelf<G: Scope, K: Data+Hashable, R: Ord+Semigroup+'static>
+pub trait ArrangeBySelf<G, K: Data+Hashable, R: Ord+Semigroup+'static>
 where
-    G::Timestamp: Lattice+Ord
+    G: Scope<Timestamp: Lattice+Ord>,
 {
     /// Arranges a collection of `Key` records by `Key`.
     ///
@@ -623,9 +614,9 @@ where
 }
 
 
-impl<G: Scope, K: ExchangeData+Hashable, R: ExchangeData+Semigroup> ArrangeBySelf<G, K, R> for Collection<G, K, R>
+impl<G, K: ExchangeData+Hashable, R: ExchangeData+Semigroup> ArrangeBySelf<G, K, R> for Collection<G, K, R>
 where
-    G::Timestamp: Lattice+Ord
+    G: Scope<Timestamp: Lattice+Ord>,
 {
     fn arrange_by_self(&self) -> Arranged<G, TraceAgent<KeySpine<K, G::Timestamp, R>>> {
         self.arrange_by_self_named("ArrangeBySelf")
diff --git a/differential-dataflow/src/operators/arrange/mod.rs b/differential-dataflow/src/operators/arrange/mod.rs
index 2ea9319ca3..2b7f4ba9ae 100644
--- a/differential-dataflow/src/operators/arrange/mod.rs
+++ b/differential-dataflow/src/operators/arrange/mod.rs
@@ -48,10 +48,7 @@ use timely::progress::Antichain;
 use crate::trace::TraceReader;
 
 /// Operating instructions on how to replay a trace.
-pub enum TraceReplayInstruction<Tr>
-where
-    Tr: TraceReader,
-{
+pub enum TraceReplayInstruction<Tr: TraceReader> {
     /// Describes a frontier advance.
     Frontier(Antichain<Tr::Time>),
     /// Describes a batch of data and a capability hint.
diff --git a/differential-dataflow/src/operators/arrange/upsert.rs b/differential-dataflow/src/operators/arrange/upsert.rs
index 5a48e2ebdd..725321edf0 100644
--- a/differential-dataflow/src/operators/arrange/upsert.rs
+++ b/differential-dataflow/src/operators/arrange/upsert.rs
@@ -110,7 +110,7 @@ use timely::dataflow::operators::Capability;
 
 use crate::operators::arrange::arrangement::Arranged;
 use crate::trace::{Builder, Description};
-use crate::trace::{self, Trace, TraceReader, Batch, Cursor};
+use crate::trace::{self, Trace, TraceReader, Cursor};
 use crate::{ExchangeData, Hashable, IntoOwned};
 
 use super::TraceAgent;
@@ -131,13 +131,14 @@ pub fn arrange_from_upsert<G, K, V, Bu, Tr>(
 ) -> Arranged<G, TraceAgent<Tr>>
 where
     G: Scope<Timestamp=Tr::Time>,
-    Tr: Trace+TraceReader<Diff=isize>+'static,
-    for<'a> Tr::Key<'a> : IntoOwned<'a, Owned = K>,
+    Tr: Trace + for<'a> TraceReader<
+        Key<'a> : IntoOwned<'a, Owned = K>,
+        Val<'a> : IntoOwned<'a, Owned = V>,
+        Time: TotalOrder+ExchangeData,
+        Diff=isize,
+    >+'static,
     K: ExchangeData+Hashable+std::hash::Hash,
     V: ExchangeData,
-    for<'a> Tr::Val<'a> : IntoOwned<'a, Owned = V>,
-    Tr::Time: TotalOrder+ExchangeData,
-    Tr::Batch: Batch,
     Bu: Builder<Time=G::Timestamp, Input = Vec<((K, V), Tr::Time, Tr::Diff)>, Output = Tr::Batch>,
 {
     let mut reader: Option<TraceAgent<Tr>> = None;
diff --git a/differential-dataflow/src/operators/arrange/writer.rs b/differential-dataflow/src/operators/arrange/writer.rs
index 5a2f720039..8df11690c2 100644
--- a/differential-dataflow/src/operators/arrange/writer.rs
+++ b/differential-dataflow/src/operators/arrange/writer.rs
@@ -19,11 +19,7 @@ use super::TraceReplayInstruction;
 ///
 /// A `TraceWriter` accepts a sequence of batches and distributes them
 /// to both a shared trace and to a sequence of private queues.
-pub struct TraceWriter<Tr>
-where
-    Tr: Trace,
-    Tr::Batch: Batch,
-{
+pub struct TraceWriter<Tr: Trace> {
     /// Current upper limit.
     upper: Antichain<Tr::Time>,
     /// Shared trace, possibly absent (due to weakness).
@@ -32,11 +28,7 @@ where
     queues: Rc<RefCell<Vec<TraceAgentQueueWriter<Tr>>>>,
 }
 
-impl<Tr> TraceWriter<Tr>
-where
-    Tr: Trace,
-    Tr::Batch: Batch,
-{
+impl<Tr: Trace> TraceWriter<Tr> {
     /// Creates a new `TraceWriter`.
     pub fn new(
         upper: Vec<Tr::Time>,
@@ -98,11 +90,7 @@ where
     }
 }
 
-impl<Tr> Drop for TraceWriter<Tr>
-where
-    Tr: Trace,
-    Tr::Batch: Batch,
-{
+impl<Tr: Trace> Drop for TraceWriter<Tr> {
     fn drop(&mut self) {
         self.seal(Antichain::new())
     }
diff --git a/differential-dataflow/src/operators/consolidate.rs b/differential-dataflow/src/operators/consolidate.rs
index 602f58f872..c70498b717 100644
--- a/differential-dataflow/src/operators/consolidate.rs
+++ b/differential-dataflow/src/operators/consolidate.rs
@@ -19,8 +19,7 @@ use crate::trace::{Batcher, Builder};
 /// Methods which require data be arrangeable.
 impl<G, D, R> Collection<G, D, R>
 where
-    G: Scope,
-    G::Timestamp: Data+Lattice,
+    G: Scope<Timestamp: Data+Lattice>,
     D: ExchangeData+Hashable,
     R: Semigroup+ExchangeData,
 {
@@ -53,9 +52,7 @@ where
     pub fn consolidate_named<Ba, Bu, Tr>(&self, name: &str) -> Self
     where
         Ba: Batcher<Input=Vec<((D,()),G::Timestamp,R)>, Time=G::Timestamp> + 'static,
-        Tr: crate::trace::Trace<Time=G::Timestamp,Diff=R>+'static,
-        for<'a> Tr::Key<'a>: IntoOwned<'a, Owned = D>,
-        Tr::Batch: crate::trace::Batch,
+        Tr: for<'a> crate::trace::Trace<Key<'a>: IntoOwned<'a, Owned = D>,Time=G::Timestamp,Diff=R>+'static,
         Bu: Builder<Time=Tr::Time, Input=Ba::Output, Output=Tr::Batch>,
     {
         use crate::operators::arrange::arrangement::Arrange;
diff --git a/differential-dataflow/src/operators/count.rs b/differential-dataflow/src/operators/count.rs
index 15d06b42b5..53098979c8 100644
--- a/differential-dataflow/src/operators/count.rs
+++ b/differential-dataflow/src/operators/count.rs
@@ -14,7 +14,7 @@ use crate::operators::arrange::{Arranged, ArrangeBySelf};
 use crate::trace::{BatchReader, Cursor, TraceReader};
 
 /// Extension trait for the `count` differential dataflow method.
-pub trait CountTotal<G: Scope, K: ExchangeData, R: Semigroup> where G::Timestamp: TotalOrder+Lattice+Ord {
+pub trait CountTotal<G: Scope<Timestamp: TotalOrder+Lattice+Ord>, K: ExchangeData, R: Semigroup> {
     /// Counts the number of occurrences of each element.
     ///
     /// # Examples
@@ -42,8 +42,10 @@ pub trait CountTotal<G: Scope, K: ExchangeData, R: Semigroup> where G::Timestamp
     fn count_total_core<R2: Semigroup + From<i8> + 'static>(&self) -> Collection<G, (K, R), R2>;
 }
 
-impl<G: Scope, K: ExchangeData+Hashable, R: ExchangeData+Semigroup> CountTotal<G, K, R> for Collection<G, K, R>
-where G::Timestamp: TotalOrder+Lattice+Ord {
+impl<G, K: ExchangeData+Hashable, R: ExchangeData+Semigroup> CountTotal<G, K, R> for Collection<G, K, R>
+where
+    G: Scope<Timestamp: TotalOrder+Lattice+Ord>,
+{
     fn count_total_core<R2: Semigroup + From<i8> + 'static>(&self) -> Collection<G, (K, R), R2> {
         self.arrange_by_self_named("Arrange: CountTotal")
             .count_total_core()
@@ -53,12 +55,13 @@ where G::Timestamp: TotalOrder+Lattice+Ord {
 impl<G, K, T1> CountTotal<G, K, T1::Diff> for Arranged<G, T1>
 where
     G: Scope<Timestamp=T1::Time>,
-    T1: for<'a> TraceReader<Val<'a>=&'a ()>+Clone+'static,
-    for<'a> T1::Key<'a>: IntoOwned<'a, Owned = K>,
-    for<'a> T1::Diff : Semigroup<T1::DiffGat<'a>>,
+    T1: for<'a> TraceReader<
+        Key<'a>: IntoOwned<'a, Owned = K>,
+        Val<'a>=&'a (),
+        Time: TotalOrder,
+        Diff: ExchangeData+Semigroup<T1::DiffGat<'a>>
+    >+Clone+'static,
     K: ExchangeData,
-    T1::Time: TotalOrder,
-    T1::Diff: ExchangeData,
 {
     fn count_total_core<R2: Semigroup + From<i8> + 'static>(&self) -> Collection<G, (K, T1::Diff), R2> {
 
diff --git a/differential-dataflow/src/operators/iterate.rs b/differential-dataflow/src/operators/iterate.rs
index 6056ad8cdb..85bec781b2 100644
--- a/differential-dataflow/src/operators/iterate.rs
+++ b/differential-dataflow/src/operators/iterate.rs
@@ -47,7 +47,7 @@ use crate::difference::{Semigroup, Abelian};
 use crate::lattice::Lattice;
 
 /// An extension trait for the `iterate` method.
-pub trait Iterate<G: Scope, D: Data, R: Semigroup> {
+pub trait Iterate<G: Scope<Timestamp: Lattice>, D: Data, R: Semigroup> {
     /// Iteratively apply `logic` to the source collection until convergence.
     ///
     /// Importantly, this method does not automatically consolidate results.
@@ -72,16 +72,15 @@ pub trait Iterate<G: Scope, D: Data, R: Semigroup> {
     /// });
     /// ```
     fn iterate<F>(&self, logic: F) -> Collection<G, D, R>
-        where
-            G::Timestamp: Lattice,
-            for<'a> F: FnOnce(&Collection<Iterative<'a, G, u64>, D, R>)->Collection<Iterative<'a, G, u64>, D, R>;
+    where
+        for<'a> F: FnOnce(&Collection<Iterative<'a, G, u64>, D, R>)->Collection<Iterative<'a, G, u64>, D, R>;
 }
 
-impl<G: Scope, D: Ord+Data+Debug, R: Abelian+'static> Iterate<G, D, R> for Collection<G, D, R> {
+impl<G: Scope<Timestamp: Lattice>, D: Ord+Data+Debug, R: Abelian+'static> Iterate<G, D, R> for Collection<G, D, R> {
     fn iterate<F>(&self, logic: F) -> Collection<G, D, R>
-        where G::Timestamp: Lattice,
-              for<'a> F: FnOnce(&Collection<Iterative<'a, G, u64>, D, R>)->Collection<Iterative<'a, G, u64>, D, R> {
-
+    where
+        for<'a> F: FnOnce(&Collection<Iterative<'a, G, u64>, D, R>)->Collection<Iterative<'a, G, u64>, D, R>,
+    {
         self.inner.scope().scoped("Iterate", |subgraph| {
             // create a new variable, apply logic, bind variable, return.
             //
@@ -97,11 +96,11 @@ impl<G: Scope, D: Ord+Data+Debug, R: Abelian+'static> Iterate<G, D, R> for Colle
     }
 }
 
-impl<G: Scope, D: Ord+Data+Debug, R: Semigroup+'static> Iterate<G, D, R> for G {
+impl<G: Scope<Timestamp: Lattice>, D: Ord+Data+Debug, R: Semigroup+'static> Iterate<G, D, R> for G {
     fn iterate<F>(&self, logic: F) -> Collection<G, D, R>
-        where G::Timestamp: Lattice,
-              for<'a> F: FnOnce(&Collection<Iterative<'a, G, u64>, D, R>)->Collection<Iterative<'a, G, u64>, D, R> {
-
+    where
+        for<'a> F: FnOnce(&Collection<Iterative<'a, G, u64>, D, R>)->Collection<Iterative<'a, G, u64>, D, R>,
+    {
         // TODO: This makes me think we have the wrong ownership pattern here.
         let mut clone = self.clone();
         clone
@@ -154,8 +153,7 @@ impl<G: Scope, D: Ord+Data+Debug, R: Semigroup+'static> Iterate<G, D, R> for G {
 /// ```
 pub struct Variable<G, D, R, C = Vec<(D, <G as ScopeParent>::Timestamp, R)>>
 where
-    G: Scope,
-    G::Timestamp: Lattice,
+    G: Scope<Timestamp: Lattice>,
     D: Data,
     R: Abelian + 'static,
     C: Container + Clone + 'static,
@@ -166,9 +164,9 @@ where
     step: <G::Timestamp as Timestamp>::Summary,
 }
 
-impl<G: Scope, D: Data, R: Abelian, C: Container + Clone + 'static> Variable<G, D, R, C>
+impl<G, D: Data, R: Abelian, C: Container + Clone + 'static> Variable<G, D, R, C>
 where
-    G::Timestamp: Lattice,
+    G: Scope<Timestamp: Lattice>,
     StreamCore<G, C>: crate::operators::Negate<G, C> + ResultsIn<G, C>,
 {
     /// Creates a new initially empty `Variable`.
@@ -220,7 +218,7 @@ where
     }
 }
 
-impl<G: Scope, D: Data, R: Abelian, C: Container + Clone + 'static> Deref for Variable<G, D, R, C> where G::Timestamp: Lattice {
+impl<G: Scope<Timestamp: Lattice>, D: Data, R: Abelian, C: Container + Clone + 'static> Deref for Variable<G, D, R, C> {
     type Target = Collection<G, D, R, C>;
     fn deref(&self) -> &Self::Target {
         &self.collection
@@ -235,8 +233,7 @@ impl<G: Scope, D: Data, R: Abelian, C: Container + Clone + 'static> Deref for Va
 /// negation.
 pub struct SemigroupVariable<G, D, R, C = Vec<(D, <G as ScopeParent>::Timestamp, R)>>
 where
-    G::Timestamp: Lattice,
-    G: Scope,
+    G: Scope<Timestamp: Lattice>,
     D: Data,
     R: Semigroup + 'static,
     C: Container + Clone + 'static,
@@ -246,9 +243,9 @@ where
     step: <G::Timestamp as Timestamp>::Summary,
 }
 
-impl<G: Scope, D: Data, R: Semigroup, C: Container+Clone> SemigroupVariable<G, D, R, C>
+impl<G, D: Data, R: Semigroup, C: Container+Clone> SemigroupVariable<G, D, R, C>
 where
-    G::Timestamp: Lattice,
+    G: Scope<Timestamp: Lattice>,
     StreamCore<G, C>: ResultsIn<G, C>,
 {
     /// Creates a new initially empty `SemigroupVariable`.
diff --git a/differential-dataflow/src/operators/join.rs b/differential-dataflow/src/operators/join.rs
index 68da44d5a8..25be349c63 100644
--- a/differential-dataflow/src/operators/join.rs
+++ b/differential-dataflow/src/operators/join.rs
@@ -55,8 +55,7 @@ pub trait Join<G: Scope, K: Data, V: Data, R: Semigroup> {
         K: ExchangeData,
         V2: ExchangeData,
         R2: ExchangeData+Semigroup,
-        R: Multiply<R2>,
-        <R as Multiply<R2>>::Output: Semigroup+'static
+        R: Multiply<R2, Output: Semigroup+'static>,
     {
         self.join_map(other, |k,v,v2| (k.clone(),(v.clone(),v2.clone())))
     }
@@ -80,7 +79,7 @@ pub trait Join<G: Scope, K: Data, V: Data, R: Semigroup> {
     /// });
     /// ```
     fn join_map<V2, R2, D, L>(&self, other: &Collection<G, (K,V2), R2>, logic: L) -> Collection<G, D, <R as Multiply<R2>>::Output>
-    where K: ExchangeData, V2: ExchangeData, R2: ExchangeData+Semigroup, R: Multiply<R2>, <R as Multiply<R2>>::Output: Semigroup+'static, D: Data, L: FnMut(&K, &V, &V2)->D+'static;
+    where K: ExchangeData, V2: ExchangeData, R2: ExchangeData+Semigroup, R: Multiply<R2, Output: Semigroup+'static>, D: Data, L: FnMut(&K, &V, &V2)->D+'static;
 
     /// Matches pairs `(key, val)` and `key` based on `key`, producing the former with frequencies multiplied.
     ///
@@ -105,7 +104,7 @@ pub trait Join<G: Scope, K: Data, V: Data, R: Semigroup> {
     /// });
     /// ```
     fn semijoin<R2>(&self, other: &Collection<G, K, R2>) -> Collection<G, (K, V), <R as Multiply<R2>>::Output>
-    where K: ExchangeData, R2: ExchangeData+Semigroup, R: Multiply<R2>, <R as Multiply<R2>>::Output: Semigroup+'static;
+    where K: ExchangeData, R2: ExchangeData+Semigroup, R: Multiply<R2, Output: Semigroup+'static>;
 
     /// Subtracts the semijoin with `other` from `self`.
     ///
@@ -139,21 +138,20 @@ pub trait Join<G: Scope, K: Data, V: Data, R: Semigroup> {
 
 impl<G, K, V, R> Join<G, K, V, R> for Collection<G, (K, V), R>
 where
-    G: Scope,
+    G: Scope<Timestamp: Lattice+Ord>,
     K: ExchangeData+Hashable,
     V: ExchangeData,
     R: ExchangeData+Semigroup,
-    G::Timestamp: Lattice+Ord,
 {
     fn join_map<V2: ExchangeData, R2: ExchangeData+Semigroup, D: Data, L>(&self, other: &Collection<G, (K, V2), R2>, mut logic: L) -> Collection<G, D, <R as Multiply<R2>>::Output>
-    where R: Multiply<R2>, <R as Multiply<R2>>::Output: Semigroup+'static, L: FnMut(&K, &V, &V2)->D+'static {
+    where R: Multiply<R2, Output: Semigroup+'static>, L: FnMut(&K, &V, &V2)->D+'static {
         let arranged1 = self.arrange_by_key();
         let arranged2 = other.arrange_by_key();
         arranged1.join_core(&arranged2, move |k,v1,v2| Some(logic(k,v1,v2)))
     }
 
     fn semijoin<R2: ExchangeData+Semigroup>(&self, other: &Collection<G, K, R2>) -> Collection<G, (K, V), <R as Multiply<R2>>::Output>
-    where R: Multiply<R2>, <R as Multiply<R2>>::Output: Semigroup+'static {
+    where R: Multiply<R2, Output: Semigroup+'static> {
         let arranged1 = self.arrange_by_key();
         let arranged2 = other.arrange_by_self();
         arranged1.join_core(&arranged2, |k,v,_| Some((k.clone(), v.clone())))
@@ -174,8 +172,7 @@ where
 {
     fn join_map<V2: ExchangeData, R2: ExchangeData+Semigroup, D: Data, L>(&self, other: &Collection<G, (K, V2), R2>, mut logic: L) -> Collection<G, D, <Tr::Diff as Multiply<R2>>::Output>
     where 
-        Tr::Diff: Multiply<R2>,
-        <Tr::Diff as Multiply<R2>>::Output: Semigroup+'static,
+        Tr::Diff: Multiply<R2, Output: Semigroup+'static>,
         L: for<'a> FnMut(Tr::Key<'a>, Tr::Val<'a>, &V2)->D+'static,
     {
         let arranged2 = other.arrange_by_key();
@@ -183,7 +180,7 @@ where
     }
 
     fn semijoin<R2: ExchangeData+Semigroup>(&self, other: &Collection<G, K, R2>) -> Collection<G, (K, V), <Tr::Diff as Multiply<R2>>::Output>
-    where Tr::Diff: Multiply<R2>, <Tr::Diff as Multiply<R2>>::Output: Semigroup+'static {
+    where Tr::Diff: Multiply<R2, Output: Semigroup+'static> {
         let arranged2 = other.arrange_by_self();
         self.join_core(&arranged2, |k,v,_| Some((k.clone(), v.clone())))
     }
@@ -200,7 +197,7 @@ where
 /// This method is used by the various `join` implementations, but it can also be used
 /// directly in the event that one has a handle to an `Arranged<G,T>`, perhaps because
 /// the arrangement is available for re-use, or from the output of a `reduce` operator.
-pub trait JoinCore<G: Scope, K: 'static + ?Sized, V: 'static + ?Sized, R: Semigroup> where G::Timestamp: Lattice+Ord {
+pub trait JoinCore<G: Scope<Timestamp: Lattice+Ord>, K: 'static + ?Sized, V: 'static + ?Sized, R: Semigroup> {
 
     /// Joins two arranged collections with the same key type.
     ///
@@ -235,10 +232,8 @@ pub trait JoinCore<G: Scope, K: 'static + ?Sized, V: 'static + ?Sized, R: Semigr
     fn join_core<Tr2,I,L> (&self, stream2: &Arranged<G,Tr2>, result: L) -> Collection<G,I::Item,<R as Multiply<Tr2::Diff>>::Output>
     where
         Tr2: for<'a> TraceReader<Key<'a>=&'a K, Time=G::Timestamp>+Clone+'static,
-        R: Multiply<Tr2::Diff>,
-        <R as Multiply<Tr2::Diff>>::Output: Semigroup+'static,
-        I: IntoIterator,
-        I::Item: Data,
+        R: Multiply<Tr2::Diff, Output: Semigroup+'static>,
+        I: IntoIterator<Item: Data>,
         L: FnMut(&K,&V,Tr2::Val<'_>)->I+'static,
         ;
 
@@ -288,19 +283,16 @@ pub trait JoinCore<G: Scope, K: 'static + ?Sized, V: 'static + ?Sized, R: Semigr
 
 impl<G, K, V, R> JoinCore<G, K, V, R> for Collection<G, (K, V), R>
 where
-    G: Scope,
+    G: Scope<Timestamp: Lattice+Ord>,
     K: ExchangeData+Hashable,
     V: ExchangeData,
     R: ExchangeData+Semigroup,
-    G::Timestamp: Lattice+Ord,
 {
     fn join_core<Tr2,I,L> (&self, stream2: &Arranged<G,Tr2>, result: L) -> Collection<G,I::Item,<R as Multiply<Tr2::Diff>>::Output>
     where
         Tr2: for<'a> TraceReader<Key<'a>=&'a K, Time=G::Timestamp>+Clone+'static,
-        R: Multiply<Tr2::Diff>,
-        <R as Multiply<Tr2::Diff>>::Output: Semigroup+'static,
-        I: IntoIterator,
-        I::Item: Data,
+        R: Multiply<Tr2::Diff, Output: Semigroup+'static>,
+        I: IntoIterator<Item: Data>,
         L: FnMut(&K,&V,Tr2::Val<'_>)->I+'static,
     {
         self.arrange_by_key()
diff --git a/differential-dataflow/src/operators/reduce.rs b/differential-dataflow/src/operators/reduce.rs
index 6a22ab2eab..2267268ff4 100644
--- a/differential-dataflow/src/operators/reduce.rs
+++ b/differential-dataflow/src/operators/reduce.rs
@@ -21,14 +21,14 @@ use timely::dataflow::operators::Capability;
 
 use crate::operators::arrange::{Arranged, ArrangeByKey, ArrangeBySelf, TraceAgent};
 use crate::lattice::Lattice;
-use crate::trace::{Batch, BatchReader, Cursor, Trace, Builder, ExertionLogic, Description};
+use crate::trace::{BatchReader, Cursor, Trace, Builder, ExertionLogic, Description};
 use crate::trace::cursor::CursorList;
 use crate::trace::implementations::{KeySpine, KeyBuilder, ValSpine, ValBuilder};
 
 use crate::trace::TraceReader;
 
 /// Extension trait for the `reduce` differential dataflow method.
-pub trait Reduce<G: Scope, K: Data, V: Data, R: Semigroup> where G::Timestamp: Lattice+Ord {
+pub trait Reduce<G: Scope<Timestamp: Lattice+Ord>, K: Data, V: Data, R: Semigroup> {
     /// Applies a reduction function on records grouped by key.
     ///
     /// Input data must be structured as `(key, val)` pairs.
@@ -69,8 +69,7 @@ pub trait Reduce<G: Scope, K: Data, V: Data, R: Semigroup> where G::Timestamp: L
 
 impl<G, K, V, R> Reduce<G, K, V, R> for Collection<G, (K, V), R>
     where
-        G: Scope,
-        G::Timestamp: Lattice+Ord,
+        G: Scope<Timestamp: Lattice+Ord>,
         K: ExchangeData+Hashable,
         V: ExchangeData,
         R: ExchangeData+Semigroup,
@@ -86,8 +85,6 @@ impl<G, K: Data, V: Data, T1, R: Ord+Semigroup+'static> Reduce<G, K, V, R> for A
 where
     G: Scope<Timestamp=T1::Time>,
     T1: for<'a> TraceReader<Key<'a>=&'a K, Val<'a>=&'a V, Diff=R>+Clone+'static,
-    for<'a> T1::Key<'a> : IntoOwned<'a, Owned = K>,
-    for<'a> T1::Val<'a> : IntoOwned<'a, Owned = V>,
 {
     fn reduce_named<L, V2: Data, R2: Ord+Abelian+'static>(&self, name: &str, logic: L) -> Collection<G, (K, V2), R2>
         where L: FnMut(&K, &[(&V, R)], &mut Vec<(V2, R2)>)+'static {
@@ -97,7 +94,7 @@ where
 }
 
 /// Extension trait for the `threshold` and `distinct` differential dataflow methods.
-pub trait Threshold<G: Scope, K: Data, R1: Semigroup> where G::Timestamp: Lattice+Ord {
+pub trait Threshold<G: Scope<Timestamp: Lattice+Ord>, K: Data, R1: Semigroup> {
     /// Transforms the multiplicity of records.
     ///
     /// The `threshold` function is obliged to map `R1::zero` to `R2::zero`, or at
@@ -153,8 +150,7 @@ pub trait Threshold<G: Scope, K: Data, R1: Semigroup> where G::Timestamp: Lattic
     }
 }
 
-impl<G: Scope, K: ExchangeData+Hashable, R1: ExchangeData+Semigroup> Threshold<G, K, R1> for Collection<G, K, R1>
-where G::Timestamp: Lattice+Ord {
+impl<G: Scope<Timestamp: Lattice+Ord>, K: ExchangeData+Hashable, R1: ExchangeData+Semigroup> Threshold<G, K, R1> for Collection<G, K, R1> {
     fn threshold_named<R2: Ord+Abelian+'static, F: FnMut(&K,&R1)->R2+'static>(&self, name: &str, thresh: F) -> Collection<G, K, R2> {
         self.arrange_by_self_named(&format!("Arrange: {}", name))
             .threshold_named(name, thresh)
@@ -165,7 +161,6 @@ impl<G, K: Data, T1, R1: Semigroup> Threshold<G, K, R1> for Arranged<G, T1>
 where
     G: Scope<Timestamp=T1::Time>,
     T1: for<'a> TraceReader<Key<'a>=&'a K, Val<'a>=&'a (), Diff=R1>+Clone+'static,
-    for<'a> T1::Key<'a>: IntoOwned<'a, Owned = K>,
 {
     fn threshold_named<R2: Ord+Abelian+'static, F: FnMut(&K,&R1)->R2+'static>(&self, name: &str, mut thresh: F) -> Collection<G, K, R2> {
         self.reduce_abelian::<_,K,(),KeyBuilder<K,G::Timestamp,R2>,KeySpine<K,G::Timestamp,R2>>(name, move |k,s,t| t.push(((), thresh(k, &s[0].1))))
@@ -174,7 +169,7 @@ where
 }
 
 /// Extension trait for the `count` differential dataflow method.
-pub trait Count<G: Scope, K: Data, R: Semigroup> where G::Timestamp: Lattice+Ord {
+pub trait Count<G: Scope<Timestamp: Lattice+Ord>, K: Data, R: Semigroup> {
     /// Counts the number of occurrences of each element.
     ///
     /// # Examples
@@ -202,10 +197,7 @@ pub trait Count<G: Scope, K: Data, R: Semigroup> where G::Timestamp: Lattice+Ord
     fn count_core<R2: Ord + Abelian + From<i8> + 'static>(&self) -> Collection<G, (K, R), R2>;
 }
 
-impl<G: Scope, K: ExchangeData+Hashable, R: ExchangeData+Semigroup> Count<G, K, R> for Collection<G, K, R>
-where
-    G::Timestamp: Lattice+Ord,
-{
+impl<G: Scope<Timestamp: Lattice+Ord>, K: ExchangeData+Hashable, R: ExchangeData+Semigroup> Count<G, K, R> for Collection<G, K, R> {
     fn count_core<R2: Ord + Abelian + From<i8> + 'static>(&self) -> Collection<G, (K, R), R2> {
         self.arrange_by_self_named("Arrange: Count")
             .count_core()
@@ -216,7 +208,6 @@ impl<G, K: Data, T1, R: Data+Semigroup> Count<G, K, R> for Arranged<G, T1>
 where
     G: Scope<Timestamp=T1::Time>,
     T1: for<'a> TraceReader<Key<'a>=&'a K, Val<'a>=&'a (), Diff=R>+Clone+'static,
-    for<'a> T1::Key<'a>: IntoOwned<'a, Owned = K>,
 {
     fn count_core<R2: Ord + Abelian + From<i8> + 'static>(&self) -> Collection<G, (K, R), R2> {
         self.reduce_abelian::<_,K,R,ValBuilder<K,R,G::Timestamp,R2>,ValSpine<K,R,G::Timestamp,R2>>("Count", |_k,s,t| t.push((s[0].1.clone(), R2::from(1i8))))
@@ -225,7 +216,7 @@ where
 }
 
 /// Extension trait for the `reduce_core` differential dataflow method.
-pub trait ReduceCore<G: Scope, K: ToOwned + ?Sized, V: Data, R: Semigroup> where G::Timestamp: Lattice+Ord {
+pub trait ReduceCore<G: Scope<Timestamp: Lattice+Ord>, K: ToOwned + ?Sized, V: Data, R: Semigroup> {
     /// Applies `reduce` to arranged data, and returns an arrangement of output data.
     ///
     /// This method is used by the more ergonomic `reduce`, `distinct`, and `count` methods, although
@@ -253,10 +244,12 @@ pub trait ReduceCore<G: Scope, K: ToOwned + ?Sized, V: Data, R: Semigroup> where
     /// ```
     fn reduce_abelian<L, Bu, T2>(&self, name: &str, mut logic: L) -> Arranged<G, TraceAgent<T2>>
         where
-            T2: for<'a> Trace<Key<'a>= &'a K, Time=G::Timestamp>+'static,
-            for<'a> T2::Val<'a> : IntoOwned<'a, Owned = V>,
-            T2::Diff: Abelian,
-            T2::Batch: Batch,
+            T2: for<'a> Trace<
+                Key<'a>= &'a K,
+                Val<'a> : IntoOwned<'a, Owned = V>,
+                Time=G::Timestamp,
+                Diff: Abelian,
+            >+'static,
             Bu: Builder<Time=T2::Time, Input = Vec<((K::Owned, V), T2::Time, T2::Diff)>, Output = T2::Batch>,
             L: FnMut(&K, &[(&V, R)], &mut Vec<(V, T2::Diff)>)+'static,
         {
@@ -276,9 +269,11 @@ pub trait ReduceCore<G: Scope, K: ToOwned + ?Sized, V: Data, R: Semigroup> where
     /// At least one of the two collections will be non-empty.
     fn reduce_core<L, Bu, T2>(&self, name: &str, logic: L) -> Arranged<G, TraceAgent<T2>>
         where
-            T2: for<'a> Trace<Key<'a>=&'a K, Time=G::Timestamp>+'static,
-            for<'a> T2::Val<'a> : IntoOwned<'a, Owned = V>,
-            T2::Batch: Batch,
+            T2: for<'a> Trace<
+                Key<'a>=&'a K,
+                Val<'a> : IntoOwned<'a, Owned = V>,
+                Time=G::Timestamp,
+            >+'static,
             Bu: Builder<Time=T2::Time, Input = Vec<((K::Owned, V), T2::Time, T2::Diff)>, Output = T2::Batch>,
             L: FnMut(&K, &[(&V, R)], &mut Vec<(V,T2::Diff)>, &mut Vec<(V, T2::Diff)>)+'static,
             ;
@@ -295,9 +290,11 @@ where
     fn reduce_core<L, Bu, T2>(&self, name: &str, logic: L) -> Arranged<G, TraceAgent<T2>>
         where
             V: Data,
-            T2: for<'a> Trace<Key<'a>=&'a K, Time=G::Timestamp>+'static,
-            for<'a> T2::Val<'a> : IntoOwned<'a, Owned = V>,
-            T2::Batch: Batch,
+            T2: for<'a> Trace<
+                Key<'a>=&'a K,
+                Val<'a> : IntoOwned<'a, Owned = V>,
+                Time=G::Timestamp,
+            >+'static,
             Bu: Builder<Time=T2::Time, Input = Vec<((K, V), T2::Time, T2::Diff)>, Output = T2::Batch>,
             L: FnMut(&K, &[(&V, R)], &mut Vec<(V,T2::Diff)>, &mut Vec<(V, T2::Diff)>)+'static,
     {
@@ -312,15 +309,11 @@ where
 pub fn reduce_trace<G, T1, Bu, T2, K, V, L>(trace: &Arranged<G, T1>, name: &str, mut logic: L) -> Arranged<G, TraceAgent<T2>>
 where
     G: Scope<Timestamp=T1::Time>,
-    T1: TraceReader + Clone + 'static,
-    for<'a> T1::Key<'a> : IntoOwned<'a, Owned = K>,
-    T2: for<'a> Trace<Key<'a>=T1::Key<'a>, Time=T1::Time> + 'static,
+    T1: for<'a> TraceReader<Key<'a> : IntoOwned<'a, Owned = K>> + Clone + 'static,
+    T2: for<'a> Trace<Key<'a>=T1::Key<'a>, Val<'a> : IntoOwned<'a, Owned = V>, Time=T1::Time> + 'static,
     K: Ord + 'static,
     V: Data,
-    for<'a> T2::Val<'a> : IntoOwned<'a, Owned = V>,
-    T2::Batch: Batch,
-    Bu: Builder<Time=T2::Time, Output = T2::Batch>,
-    Bu::Input: Container + PushInto<((K, V), T2::Time, T2::Diff)>,
+    Bu: Builder<Time=T2::Time, Output = T2::Batch, Input: Container + PushInto<((K, V), T2::Time, T2::Diff)>>,
     L: FnMut(T1::Key<'_>, &[(T1::Val<'_>, T1::Diff)], &mut Vec<(V,T2::Diff)>, &mut Vec<(V, T2::Diff)>)+'static,
 {
     let mut result_trace = None;
@@ -633,10 +626,9 @@ fn sort_dedup<T: Ord>(list: &mut Vec<T>) {
 trait PerKeyCompute<'a, C1, C2, C3, V>
 where
     C1: Cursor,
-    C2: Cursor<Key<'a> = C1::Key<'a>, Time = C1::Time>,
+    C2: for<'b> Cursor<Key<'a> = C1::Key<'a>, Val<'b> : IntoOwned<'b, Owned = V>, Time = C1::Time>,
     C3: Cursor<Key<'a> = C1::Key<'a>, Val<'a> = C1::Val<'a>, Time = C1::Time, Diff = C1::Diff>,
     V: Clone + Ord,
-    for<'b> C2::Val<'b> : IntoOwned<'b, Owned = V>,
 {
     fn new() -> Self;
     fn compute<L>(
@@ -698,10 +690,9 @@ mod history_replay {
     impl<'a, C1, C2, C3, V> PerKeyCompute<'a, C1, C2, C3, V> for HistoryReplayer<'a, C1, C2, C3, V>
     where
         C1: Cursor,
-        C2: Cursor<Key<'a> = C1::Key<'a>, Time = C1::Time>,
+        C2: for<'b> Cursor<Key<'a> = C1::Key<'a>, Val<'b> : IntoOwned<'b, Owned = V>, Time = C1::Time>,
         C3: Cursor<Key<'a> = C1::Key<'a>, Val<'a> = C1::Val<'a>, Time = C1::Time, Diff = C1::Diff>,
         V: Clone + Ord,
-        for<'b> C2::Val<'b> : IntoOwned<'b, Owned = V>,
     {
         fn new() -> Self {
             HistoryReplayer {
diff --git a/differential-dataflow/src/operators/threshold.rs b/differential-dataflow/src/operators/threshold.rs
index 187a94704a..6476b19b98 100644
--- a/differential-dataflow/src/operators/threshold.rs
+++ b/differential-dataflow/src/operators/threshold.rs
@@ -17,7 +17,7 @@ use crate::operators::arrange::{Arranged, ArrangeBySelf};
 use crate::trace::{BatchReader, Cursor, TraceReader};
 
 /// Extension trait for the `distinct` differential dataflow method.
-pub trait ThresholdTotal<G: Scope, K: ExchangeData, R: ExchangeData+Semigroup> where G::Timestamp: TotalOrder+Lattice+Ord {
+pub trait ThresholdTotal<G: Scope<Timestamp: TotalOrder+Lattice+Ord>, K: ExchangeData, R: ExchangeData+Semigroup> {
     /// Reduces the collection to one occurrence of each distinct element.
     fn threshold_semigroup<R2, F>(&self, thresh: F) -> Collection<G, K, R2>
     where
@@ -85,7 +85,9 @@ pub trait ThresholdTotal<G: Scope, K: ExchangeData, R: ExchangeData+Semigroup> w
 }
 
 impl<G: Scope, K: ExchangeData+Hashable, R: ExchangeData+Semigroup> ThresholdTotal<G, K, R> for Collection<G, K, R>
-where G::Timestamp: TotalOrder+Lattice+Ord {
+where
+    G: Scope<Timestamp: TotalOrder+Lattice+Ord>,
+{
     fn threshold_semigroup<R2, F>(&self, thresh: F) -> Collection<G, K, R2>
     where
         R2: Semigroup+'static,
@@ -99,11 +101,13 @@ where G::Timestamp: TotalOrder+Lattice+Ord {
 impl<G, K, T1> ThresholdTotal<G, K, T1::Diff> for Arranged<G, T1>
 where
     G: Scope<Timestamp=T1::Time>,
-    T1: for<'a> TraceReader<Key<'a>=&'a K, Val<'a>=&'a ()>+Clone+'static,
-    for<'a> T1::Diff : Semigroup<T1::DiffGat<'a>>,
+    T1: for<'a> TraceReader<
+        Key<'a>=&'a K, 
+        Val<'a>=&'a (),
+        Time: TotalOrder,
+        Diff : ExchangeData + Semigroup<T1::DiffGat<'a>>,
+    >+Clone+'static,
     K: ExchangeData,
-    T1::Time: TotalOrder,
-    T1::Diff: ExchangeData,
 {
     fn threshold_semigroup<R2, F>(&self, mut thresh: F) -> Collection<G, K, R2>
     where
diff --git a/differential-dataflow/src/trace/implementations/chunker.rs b/differential-dataflow/src/trace/implementations/chunker.rs
index 0eef4d7797..c47bd95cd1 100644
--- a/differential-dataflow/src/trace/implementations/chunker.rs
+++ b/differential-dataflow/src/trace/implementations/chunker.rs
@@ -242,10 +242,7 @@ pub struct ContainerChunker<Output> {
     empty: Output,
 }
 
-impl<Output> Default for ContainerChunker<Output>
-where
-    Output: Default,
-{
+impl<Output: Default> Default for ContainerChunker<Output> {
     fn default() -> Self {
         Self {
             pending: Output::default(),
diff --git a/differential-dataflow/src/trace/implementations/huffman_container.rs b/differential-dataflow/src/trace/implementations/huffman_container.rs
index cd8bbbb099..c5d08e6bb8 100644
--- a/differential-dataflow/src/trace/implementations/huffman_container.rs
+++ b/differential-dataflow/src/trace/implementations/huffman_container.rs
@@ -21,10 +21,7 @@ pub struct HuffmanContainer<B: Ord+Clone> {
     stats: BTreeMap<B, i64>
 }
 
-impl<B> HuffmanContainer<B>
-where
-    B: Ord + Clone,
-{
+impl<B: Ord + Clone> HuffmanContainer<B> {
     /// Prints statistics about encoded containers.
     pub fn print(&self) {
         if let Ok((_huff, bytes)) = &self.inner {
@@ -439,10 +436,7 @@ mod huffman {
             }
         }
 
-        impl<'a, T, I> Iterator for Decoder<'a, T, I>
-        where
-            I: Iterator<Item=u8>,
-        {
+        impl<'a, T, I: Iterator<Item=u8>> Iterator for Decoder<'a, T, I> {
             type Item = &'a T;
             fn next(&mut self) -> Option<&'a T> {
                 // We must navigate `self.decode`, restocking bits whenever possible.
diff --git a/differential-dataflow/src/trace/implementations/merge_batcher.rs b/differential-dataflow/src/trace/implementations/merge_batcher.rs
index 4de9435941..47c26e3c7f 100644
--- a/differential-dataflow/src/trace/implementations/merge_batcher.rs
+++ b/differential-dataflow/src/trace/implementations/merge_batcher.rs
@@ -50,8 +50,7 @@ pub struct MergeBatcher<Input, C, M: Merger> {
 impl<Input, C, M> Batcher for MergeBatcher<Input, C, M>
 where
     C: ContainerBuilder<Container=M::Chunk> + Default + for<'a> PushInto<&'a mut Input>,
-    M: Merger,
-    M::Time: Timestamp,
+    M: Merger<Time: Timestamp>,
 {
     type Input = Input;
     type Time = M::Time;
@@ -127,10 +126,7 @@ where
     }
 }
 
-impl<Input, C, M> MergeBatcher<Input, C, M>
-where
-    M: Merger,
-{
+impl<Input, C, M: Merger> MergeBatcher<Input, C, M> {
     /// Insert a chain and maintain chain properties: Chains are geometrically sized and ordered
     /// by decreasing length.
     fn insert_chain(&mut self, chain: Vec<M::Chunk>) {
@@ -194,10 +190,7 @@ where
     }
 }
 
-impl<Input, C, M> Drop for MergeBatcher<Input, C, M>
-where
-    M: Merger,
-{
+impl<Input, C, M: Merger> Drop for MergeBatcher<Input, C, M> {
     fn drop(&mut self) {
         // Cleanup chain to retract accounting information.
         while self.chain_pop().is_some() {}
@@ -330,8 +323,7 @@ pub mod container {
 
     impl<MC, CQ> Merger for ContainerMerger<MC, CQ>
     where
-        for<'a> MC: MergerChunk + Clone + PushInto<<MC as Container>::Item<'a>> + 'static,
-        for<'a> MC::TimeOwned: Ord + PartialOrder + Data,
+        for<'a> MC: MergerChunk<TimeOwned: Ord + PartialOrder + Data> + Clone + PushInto<<MC as Container>::Item<'a>> + 'static,
         CQ: ContainerQueue<MC>,
     {
         type Time = MC::TimeOwned;
diff --git a/differential-dataflow/src/trace/implementations/mod.rs b/differential-dataflow/src/trace/implementations/mod.rs
index 717c9df682..1c9ec7da60 100644
--- a/differential-dataflow/src/trace/implementations/mod.rs
+++ b/differential-dataflow/src/trace/implementations/mod.rs
@@ -114,10 +114,7 @@ pub struct Vector<U: Update> {
     phantom: std::marker::PhantomData<U>,
 }
 
-impl<U: Update> Layout for Vector<U>
-where
-    U::Diff: Ord,
-{
+impl<U: Update<Diff: Ord>> Layout for Vector<U> {
     type Target = U;
     type KeyContainer = Vec<U::Key>;
     type ValContainer = Vec<U::Val>;
@@ -131,12 +128,14 @@ pub struct TStack<U: Update> {
     phantom: std::marker::PhantomData<U>,
 }
 
-impl<U: Update> Layout for TStack<U>
+impl<U> Layout for TStack<U>
 where
-    U::Key: Columnation,
-    U::Val: Columnation,
-    U::Time: Columnation,
-    U::Diff: Columnation + Ord,
+    U: Update<
+        Key: Columnation,
+        Val: Columnation,
+        Time: Columnation,
+        Diff: Columnation + Ord,
+    >,
 {
     type Target = U;
     type KeyContainer = TimelyStack<U::Key>;
@@ -169,10 +168,8 @@ pub struct Preferred<K: ?Sized, V: ?Sized, T, D> {
 
 impl<K,V,T,R> Update for Preferred<K, V, T, R>
 where
-    K: ToOwned + ?Sized,
-    K::Owned: Ord+Clone+'static,
-    V: ToOwned + ?Sized,
-    V::Owned: Ord+Clone+'static,
+    K: ToOwned<Owned: Ord+Clone+'static> + ?Sized,
+    V: ToOwned<Owned: Ord+Clone+'static> + ?Sized,
     T: Ord+Clone+Lattice+timely::progress::Timestamp,
     R: Ord+Clone+Semigroup+'static,
 {
@@ -184,10 +181,8 @@ where
 
 impl<K, V, T, D> Layout for Preferred<K, V, T, D>
 where
-    K: Ord+ToOwned+PreferredContainer + ?Sized,
-    K::Owned: Ord+Clone+'static,
-    V: Ord+ToOwned+PreferredContainer + ?Sized,
-    V::Owned: Ord+Clone+'static,
+    K: Ord+ToOwned<Owned: Ord+Clone+'static>+PreferredContainer + ?Sized,
+    V: Ord+ToOwned<Owned: Ord+Clone+'static>+PreferredContainer + ?Sized,
     T: Ord+Clone+Lattice+timely::progress::Timestamp,
     D: Ord+Clone+Semigroup+'static,
 {
@@ -345,11 +340,9 @@ pub trait BuilderInput<K: BatchContainer, V: BatchContainer>: Container {
 impl<K,KBC,V,VBC,T,R> BuilderInput<KBC, VBC> for Vec<((K, V), T, R)>
 where
     K: Ord + Clone + 'static,
-    KBC: BatchContainer,
-    for<'a> KBC::ReadItem<'a>: PartialEq<&'a K>,
+    KBC: for<'a> BatchContainer<ReadItem<'a>: PartialEq<&'a K>>,
     V: Ord + Clone + 'static,
-    VBC: BatchContainer,
-    for<'a> VBC::ReadItem<'a>: PartialEq<&'a V>,
+    VBC: for<'a> BatchContainer<ReadItem<'a>: PartialEq<&'a V>>,
     T: Timestamp + Lattice + Clone + 'static,
     R: Ord + Semigroup + 'static,
 {
@@ -398,12 +391,14 @@ where
 
 impl<K,V,T,R> BuilderInput<K, V> for TimelyStack<((K::Owned, V::Owned), T, R)>
 where
-    K: BatchContainer,
-    for<'a> K::ReadItem<'a>: PartialEq<&'a K::Owned>,
-    K::Owned: Ord + Columnation + Clone + 'static,
-    V: BatchContainer,
-    for<'a> V::ReadItem<'a>: PartialEq<&'a V::Owned>,
-    V::Owned: Ord + Columnation + Clone + 'static,
+    K: for<'a> BatchContainer<
+        ReadItem<'a>: PartialEq<&'a K::Owned>,
+        Owned: Ord + Columnation + Clone + 'static,
+    >,
+    V: for<'a> BatchContainer<
+        ReadItem<'a>: PartialEq<&'a V::Owned>,
+        Owned: Ord + Columnation + Clone + 'static,
+    >,
     T: Timestamp + Lattice + Columnation + Clone + 'static,
     R: Ord + Clone + Semigroup + Columnation + 'static,
 {
diff --git a/differential-dataflow/src/trace/implementations/ord_neu.rs b/differential-dataflow/src/trace/implementations/ord_neu.rs
index 5035a229c4..c987ddc6cf 100644
--- a/differential-dataflow/src/trace/implementations/ord_neu.rs
+++ b/differential-dataflow/src/trace/implementations/ord_neu.rs
@@ -593,10 +593,11 @@ pub mod val_batch {
 
     impl<L, CI> Builder for OrdValBuilder<L, CI>
     where
-        L: Layout,
+        L: for<'a> Layout<
+            KeyContainer: PushInto<CI::Key<'a>>,
+            ValContainer: PushInto<CI::Val<'a>>,
+        >,
         CI: for<'a> BuilderInput<L::KeyContainer, L::ValContainer, Time=<L::Target as Update>::Time, Diff=<L::Target as Update>::Diff>,
-        for<'a> L::KeyContainer: PushInto<CI::Key<'a>>,
-        for<'a> L::ValContainer: PushInto<CI::Val<'a>>,
         for<'a> <L::TimeContainer as BatchContainer>::ReadItem<'a> : IntoOwned<'a, Owned = <L::Target as Update>::Time>,
         for<'a> <L::DiffContainer as BatchContainer>::ReadItem<'a> : IntoOwned<'a, Owned = <L::Target as Update>::Diff>,
     {
@@ -1095,11 +1096,10 @@ mod key_batch {
 
     impl<L: Layout, CI> Builder for OrdKeyBuilder<L, CI>
     where
-        L: Layout,
-        CI: for<'a> BuilderInput<L::KeyContainer, L::ValContainer, Time=<L::Target as Update>::Time, Diff=<L::Target as Update>::Diff>,
-        for<'a> L::KeyContainer: PushInto<CI::Key<'a>>,
+        L: for<'a> Layout<KeyContainer: PushInto<CI::Key<'a>>>,
         for<'a> <L::TimeContainer as BatchContainer>::ReadItem<'a> : IntoOwned<'a, Owned = <L::Target as Update>::Time>,
         for<'a> <L::DiffContainer as BatchContainer>::ReadItem<'a> : IntoOwned<'a, Owned = <L::Target as Update>::Diff>,
+        CI: BuilderInput<L::KeyContainer, L::ValContainer, Time=<L::Target as Update>::Time, Diff=<L::Target as Update>::Diff>,
     {
 
         type Input = CI;
diff --git a/differential-dataflow/src/trace/implementations/rhh.rs b/differential-dataflow/src/trace/implementations/rhh.rs
index 48ce98899f..911697502c 100644
--- a/differential-dataflow/src/trace/implementations/rhh.rs
+++ b/differential-dataflow/src/trace/implementations/rhh.rs
@@ -53,8 +53,7 @@ pub struct HashWrapper<T: std::hash::Hash + Hashable> {
     pub inner: T
 }
 
-impl<T: PartialOrd + std::hash::Hash + Hashable> PartialOrd for HashWrapper<T>
-where <T as Hashable>::Output: PartialOrd {
+impl<T: PartialOrd + std::hash::Hash + Hashable<Output: PartialOrd>> PartialOrd for HashWrapper<T> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         let this_hash = self.inner.hashed();
         let that_hash = other.inner.hashed();
@@ -62,8 +61,7 @@ where <T as Hashable>::Output: PartialOrd {
     }
 }
 
-impl<T: Ord + PartialOrd + std::hash::Hash + Hashable> Ord for HashWrapper<T> 
-where <T as Hashable>::Output: PartialOrd { 
+impl<T: Ord + PartialOrd + std::hash::Hash + Hashable<Output: PartialOrd>> Ord for HashWrapper<T> {
     fn cmp(&self, other: &Self) -> Ordering {
         self.partial_cmp(other).unwrap()
     }
diff --git a/differential-dataflow/src/trace/implementations/spine_fueled.rs b/differential-dataflow/src/trace/implementations/spine_fueled.rs
index 6b1c02d5c2..ea83f1f7c0 100644
--- a/differential-dataflow/src/trace/implementations/spine_fueled.rs
+++ b/differential-dataflow/src/trace/implementations/spine_fueled.rs
@@ -99,10 +99,7 @@ pub struct Spine<B: Batch> {
     exert_logic: Option<ExertionLogic>,
 }
 
-impl<B> TraceReader for Spine<B>
-where
-    B: Batch+Clone+'static,
-{
+impl<B: Batch+Clone+'static> TraceReader for Spine<B> {
     type Key<'a> = B::Key<'a>;
     type Val<'a> = B::Val<'a>;
     type Time = B::Time;
@@ -245,10 +242,7 @@ where
 
 // A trace implementation for any key type that can be borrowed from or converted into `Key`.
 // TODO: Almost all this implementation seems to be generic with respect to the trace and batch types.
-impl<B> Trace for Spine<B>
-where
-    B: Batch+Clone+'static,
-{
+impl<B: Batch+Clone+'static> Trace for Spine<B> {
     fn new(
         info: ::timely::dataflow::operators::generic::OperatorInfo,
         logging: Option<crate::logging::Logger>,
@@ -765,7 +759,7 @@ enum MergeState<B: Batch> {
     Double(MergeVariant<B>),
 }
 
-impl<B: Batch> MergeState<B> where B::Time: Eq {
+impl<B: Batch<Time: Eq>> MergeState<B> {
 
     /// The number of actual updates contained in the level.
     fn len(&self) -> usize {
diff --git a/differential-dataflow/src/trace/mod.rs b/differential-dataflow/src/trace/mod.rs
index 198f99bb62..86e6c8503a 100644
--- a/differential-dataflow/src/trace/mod.rs
+++ b/differential-dataflow/src/trace/mod.rs
@@ -179,8 +179,7 @@ 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
-where <Self as TraceReader>::Batch: Batch {
+pub trait Trace : TraceReader<Batch: Batch> {
 
     /// Allocates a new empty trace.
     fn new(
@@ -222,10 +221,7 @@ where <Self as TraceReader>::Batch: Batch {
 /// but do not expose ways to construct the batches. This trait is appropriate for views of the batch, and is
 /// especially useful for views derived from other sources in ways that prevent the construction of batches
 /// from the type of data in the view (for example, filtered views, or views with extended time coordinates).
-pub trait BatchReader
-where
-    Self: ::std::marker::Sized,
-{
+pub trait BatchReader : Sized {
     /// Key by which updates are indexed.
     type Key<'a>: Copy + Clone + Ord;
     /// Values associated with keys.
@@ -257,7 +253,7 @@ where
 }
 
 /// An immutable collection of updates.
-pub trait Batch : BatchReader where Self: ::std::marker::Sized {
+pub trait Batch : BatchReader + Sized {
     /// A type used to progressively merge batches.
     type Merger: Merger<Self>;
 
diff --git a/differential-dataflow/src/trace/wrappers/enter.rs b/differential-dataflow/src/trace/wrappers/enter.rs
index 418b3e5735..6c80f380dc 100644
--- a/differential-dataflow/src/trace/wrappers/enter.rs
+++ b/differential-dataflow/src/trace/wrappers/enter.rs
@@ -27,8 +27,7 @@ impl<Tr: TraceReader + Clone, TInner> Clone for TraceEnter<Tr, TInner> {
 
 impl<Tr, TInner> TraceReader for TraceEnter<Tr, TInner>
 where
-    Tr: TraceReader,
-    Tr::Batch: Clone,
+    Tr: TraceReader<Batch: Clone>,
     TInner: Refines<Tr::Time>+Lattice,
 {
     type Key<'a> = Tr::Key<'a>;
diff --git a/differential-dataflow/src/trace/wrappers/enter_at.rs b/differential-dataflow/src/trace/wrappers/enter_at.rs
index 2f27fb70e9..b085d80be1 100644
--- a/differential-dataflow/src/trace/wrappers/enter_at.rs
+++ b/differential-dataflow/src/trace/wrappers/enter_at.rs
@@ -42,8 +42,7 @@ where
 
 impl<Tr, TInner, F, G> TraceReader for TraceEnter<Tr, TInner, F, G>
 where
-    Tr: TraceReader,
-    Tr::Batch: Clone,
+    Tr: TraceReader<Batch: Clone>,
     TInner: Refines<Tr::Time>+Lattice,
     F: 'static,
     F: FnMut(Tr::Key<'_>, Tr::Val<'_>, Tr::TimeGat<'_>)->TInner+Clone,
diff --git a/differential-dataflow/src/trace/wrappers/filter.rs b/differential-dataflow/src/trace/wrappers/filter.rs
index 1fe95b7ffc..a2877402d0 100644
--- a/differential-dataflow/src/trace/wrappers/filter.rs
+++ b/differential-dataflow/src/trace/wrappers/filter.rs
@@ -26,8 +26,7 @@ where
 
 impl<Tr, F> TraceReader for TraceFilter<Tr, F>
 where
-    Tr: TraceReader,
-    Tr::Batch: Clone,
+    Tr: TraceReader<Batch: Clone>,
     F: FnMut(Tr::Key<'_>, Tr::Val<'_>)->bool+Clone+'static,
 {
     type Key<'a> = Tr::Key<'a>;
@@ -58,10 +57,7 @@ where
     }
 }
 
-impl<Tr, F> TraceFilter<Tr, F>
-where
-    Tr: TraceReader,
-{
+impl<Tr: TraceReader, F> TraceFilter<Tr, F> {
     /// Makes a new trace wrapper
     pub fn make_from(trace: Tr, logic: F) -> Self {
         TraceFilter {
@@ -100,10 +96,7 @@ where
     fn description(&self) -> &Description<B::Time> { self.batch.description() }
 }
 
-impl<B, F> BatchFilter<B, F>
-where
-    B: BatchReader,
-{
+impl<B: BatchReader, F> BatchFilter<B, F> {
     /// Makes a new batch wrapper
     pub fn make_from(batch: B, logic: F) -> Self {
         BatchFilter {
diff --git a/differential-dataflow/src/trace/wrappers/freeze.rs b/differential-dataflow/src/trace/wrappers/freeze.rs
index 0bc67b626a..6be7d0663a 100644
--- a/differential-dataflow/src/trace/wrappers/freeze.rs
+++ b/differential-dataflow/src/trace/wrappers/freeze.rs
@@ -72,8 +72,7 @@ where
 
 impl<Tr, F> TraceReader for TraceFreeze<Tr, F>
 where
-    Tr: TraceReader,
-    Tr::Batch: Clone,
+    Tr: TraceReader<Batch: Clone>,
     F: Fn(Tr::TimeGat<'_>)->Option<Tr::Time>+'static,
 {
     type Key<'a> = Tr::Key<'a>;
@@ -109,8 +108,7 @@ where
 
 impl<Tr, F> TraceFreeze<Tr, F>
 where
-    Tr: TraceReader,
-    Tr::Batch: Clone,
+    Tr: TraceReader<Batch: Clone>,
     F: Fn(Tr::TimeGat<'_>)->Option<Tr::Time>,
 {
     /// Makes a new trace wrapper
diff --git a/differential-dataflow/src/trace/wrappers/frontier.rs b/differential-dataflow/src/trace/wrappers/frontier.rs
index 2330cc043f..85f2b95ff2 100644
--- a/differential-dataflow/src/trace/wrappers/frontier.rs
+++ b/differential-dataflow/src/trace/wrappers/frontier.rs
@@ -117,7 +117,7 @@ pub struct CursorFrontier<C, T> {
     until: Antichain<T>
 }
 
-impl<C, T> CursorFrontier<C, T> where T: Clone {
+impl<C, T: Clone> CursorFrontier<C, T> {
     fn new(cursor: C, since: AntichainRef<T>, until: AntichainRef<T>) -> Self {
         CursorFrontier {
             cursor,
@@ -190,10 +190,7 @@ impl<C: Cursor> BatchCursorFrontier<C> {
     }
 }
 
-impl<C: Cursor> Cursor for BatchCursorFrontier<C>
-where
-    C::Storage: BatchReader,
-{
+impl<C: Cursor<Storage: BatchReader>> Cursor for BatchCursorFrontier<C> {
     type Key<'a> = C::Key<'a>;
     type Val<'a> = C::Val<'a>;
     type Time = C::Time;
diff --git a/differential-dataflow/tests/bfs.rs b/differential-dataflow/tests/bfs.rs
index 70d47509d2..509564a352 100644
--- a/differential-dataflow/tests/bfs.rs
+++ b/differential-dataflow/tests/bfs.rs
@@ -202,9 +202,10 @@ fn bfs_differential(
 }
 
 // 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, usize)>
-where G::Timestamp: Lattice+Ord {
-
+fn bfs<G>(edges: &Collection<G, Edge>, roots: &Collection<G, Node>) -> Collection<G, (Node, usize)>
+where
+    G: Scope<Timestamp: Lattice+Ord>,
+{
     // initialize roots as reaching themselves at distance 0
     let nodes = roots.map(|x| (x, 0));
 
diff --git a/differential-dataflow/tests/import.rs b/differential-dataflow/tests/import.rs
index 5fd931837f..4d0582c95a 100644
--- a/differential-dataflow/tests/import.rs
+++ b/differential-dataflow/tests/import.rs
@@ -12,7 +12,8 @@ use itertools::Itertools;
 type Result = std::sync::mpsc::Receiver<timely::dataflow::operators::capture::Event<usize, Vec<((u64, i64), usize, i64)>>>;
 
 fn run_test<T>(test: T, expected: Vec<(usize, Vec<((u64, i64), i64)>)>) -> ()
-        where T: FnOnce(Vec<Vec<((u64, u64), i64)>>)-> Result + ::std::panic::UnwindSafe
+where
+    T: FnOnce(Vec<Vec<((u64, u64), i64)>>)-> Result + ::std::panic::UnwindSafe,
 {
     let input_epochs: Vec<Vec<((u64, u64), i64)>> = vec![
         vec![((2, 0), 1), ((1, 0), 1), ((1, 3), 1), ((4, 2), 1)],
diff --git a/differential-dataflow/tests/scc.rs b/differential-dataflow/tests/scc.rs
index de5002026f..5aeba6a72d 100644
--- a/differential-dataflow/tests/scc.rs
+++ b/differential-dataflow/tests/scc.rs
@@ -215,8 +215,10 @@ fn scc_differential(
         .collect()
 }
 
-fn _strongly_connected<G: Scope>(graph: &Collection<G, Edge>) -> Collection<G, Edge>
-where G::Timestamp: Lattice+Ord+Hash {
+fn _strongly_connected<G>(graph: &Collection<G, Edge>) -> Collection<G, Edge>
+where
+    G: Scope<Timestamp: Lattice+Ord+Hash>,
+{
     graph.iterate(|inner| {
         let edges = graph.enter(&inner.scope());
         let trans = edges.map_in_place(|x| mem::swap(&mut x.0, &mut x.1));
@@ -224,9 +226,10 @@ where G::Timestamp: Lattice+Ord+Hash {
     })
 }
 
-fn _trim_edges<G: Scope>(cycle: &Collection<G, Edge>, edges: &Collection<G, Edge>)
-    -> Collection<G, Edge> where G::Timestamp: Lattice+Ord+Hash {
-
+fn _trim_edges<G>(cycle: &Collection<G, Edge>, edges: &Collection<G, Edge>) -> Collection<G, Edge>
+where
+    G: Scope<Timestamp: Lattice+Ord+Hash>,
+{
     let nodes = edges.map_in_place(|x| x.0 = x.1)
                      .consolidate();
 
@@ -240,9 +243,10 @@ fn _trim_edges<G: Scope>(cycle: &Collection<G, Edge>, edges: &Collection<G, Edge
          .map(|((x1,x2),_)| (x2,x1))
 }
 
-fn _reachability<G: Scope>(edges: &Collection<G, Edge>, nodes: &Collection<G, (Node, Node)>) -> Collection<G, Edge>
-where G::Timestamp: Lattice+Ord+Hash {
-
+fn _reachability<G>(edges: &Collection<G, Edge>, nodes: &Collection<G, (Node, Node)>) -> Collection<G, Edge>
+where
+    G: Scope<Timestamp: Lattice+Ord+Hash>,
+{
     edges.filter(|_| false)
          .iterate(|inner| {
              let edges = edges.enter(&inner.scope());
diff --git a/dogsdogsdogs/examples/ngo.rs b/dogsdogsdogs/examples/ngo.rs
index 76d448fed9..a87ff090f9 100644
--- a/dogsdogsdogs/examples/ngo.rs
+++ b/dogsdogsdogs/examples/ngo.rs
@@ -42,8 +42,9 @@ fn main() {
 }
 
 fn triangles<G: Scope>(edges: &Collection<G, Edge>) -> Collection<G, (Node, Node, Node)>
-where G::Timestamp: Lattice+Hash+Ord {
-
+where
+    G: Scope<Timestamp: Lattice+Hash+Ord>,
+{
     // only use forward-pointing edges.
     let edges = edges.filter(|&(src, dst)| src < dst);
 
diff --git a/dogsdogsdogs/src/lib.rs b/dogsdogsdogs/src/lib.rs
index 3e73994690..c0b93b0990 100644
--- a/dogsdogsdogs/src/lib.rs
+++ b/dogsdogsdogs/src/lib.rs
@@ -181,11 +181,10 @@ where
 
 impl<G, K, V, R, P, F> PrefixExtender<G, R> for CollectionExtender<K, V, G::Timestamp, R, P, F>
 where
-    G: Scope,
+    G: Scope<Timestamp: Lattice+ExchangeData>,
     K: ExchangeData+Hash+Default,
     V: ExchangeData+Hash+Default,
     P: ExchangeData,
-    G::Timestamp: Lattice+ExchangeData,
     R: Monoid+Multiply<Output = R>+ExchangeData,
     F: Fn(&P)->K+Clone+'static,
 {
diff --git a/dogsdogsdogs/src/operators/count.rs b/dogsdogsdogs/src/operators/count.rs
index 6485ba9098..102c65cfad 100644
--- a/dogsdogsdogs/src/operators/count.rs
+++ b/dogsdogsdogs/src/operators/count.rs
@@ -20,8 +20,10 @@ pub fn count<G, Tr, K, R, F, P>(
 ) -> Collection<G, (P, usize, usize), R>
 where
     G: Scope<Timestamp=Tr::Time>,
-    Tr: TraceReader<Diff=isize>+Clone+'static,
-    for<'a> Tr::Key<'a>: IntoOwned<'a, Owned = K>,
+    Tr: for<'a> TraceReader<
+        Key<'a>: IntoOwned<'a, Owned = K>,
+        Diff=isize,
+    >+Clone+'static,
     for<'a> Tr::Diff : Semigroup<Tr::DiffGat<'a>>,
     K: Hashable + Ord + Default + 'static,
     R: Monoid+Multiply<Output = R>+ExchangeData,
diff --git a/dogsdogsdogs/src/operators/half_join.rs b/dogsdogsdogs/src/operators/half_join.rs
index 56d0fcf07d..43d81b00c3 100644
--- a/dogsdogsdogs/src/operators/half_join.rs
+++ b/dogsdogsdogs/src/operators/half_join.rs
@@ -81,10 +81,8 @@ where
     K: Hashable + ExchangeData,
     V: ExchangeData,
     R: ExchangeData + Monoid,
-    Tr: TraceReader+Clone+'static,
-    for<'a> Tr::Key<'a> : IntoOwned<'a, Owned = K>,
-    R: Mul<Tr::Diff>,
-    <R as Mul<Tr::Diff>>::Output: Semigroup,
+    Tr: for<'a> TraceReader<Key<'a> : IntoOwned<'a, Owned = K>>+Clone+'static,
+    R: Mul<Tr::Diff, Output: Semigroup>,
     FF: Fn(&G::Timestamp, &mut Antichain<G::Timestamp>) + 'static,
     CF: Fn(Tr::TimeGat<'_>, &G::Timestamp) -> bool + 'static,
     DOut: Clone+'static,
@@ -135,8 +133,7 @@ where
     K: Hashable + ExchangeData,
     V: ExchangeData,
     R: ExchangeData + Monoid,
-    Tr: TraceReader+Clone+'static,
-    for<'a> Tr::Key<'a> : IntoOwned<'a, Owned = K>,
+    Tr: for<'a> TraceReader<Key<'a> : IntoOwned<'a, Owned = K>>+Clone+'static,
     FF: Fn(&G::Timestamp, &mut Antichain<G::Timestamp>) + 'static,
     CF: Fn(Tr::TimeGat<'_>, &Tr::Time) -> bool + 'static,
     DOut: Clone+'static,
diff --git a/dogsdogsdogs/src/operators/lookup_map.rs b/dogsdogsdogs/src/operators/lookup_map.rs
index 0440e2bf88..54fc11bb26 100644
--- a/dogsdogsdogs/src/operators/lookup_map.rs
+++ b/dogsdogsdogs/src/operators/lookup_map.rs
@@ -28,11 +28,11 @@ pub fn lookup_map<G, D, K, R, Tr, F, DOut, ROut, S>(
 ) -> Collection<G, DOut, ROut>
 where
     G: Scope<Timestamp=Tr::Time>,
-    Tr: TraceReader+Clone+'static,
-    for<'a> Tr::Key<'a>: IntoOwned<'a, Owned = K>,
-    for<'a> Tr::Diff : Semigroup<Tr::DiffGat<'a>>,
+    Tr: for<'a> TraceReader<
+        Key<'a>: IntoOwned<'a, Owned = K>,
+        Diff : Semigroup<Tr::DiffGat<'a>>+Monoid+ExchangeData,
+    >+Clone+'static,
     K: Hashable + Ord + 'static,
-    Tr::Diff: Monoid+ExchangeData,
     F: FnMut(&D, &mut K)+Clone+'static,
     D: ExchangeData,
     R: ExchangeData+Monoid,
diff --git a/dogsdogsdogs/src/operators/propose.rs b/dogsdogsdogs/src/operators/propose.rs
index 25df5d008e..571cf5071e 100644
--- a/dogsdogsdogs/src/operators/propose.rs
+++ b/dogsdogsdogs/src/operators/propose.rs
@@ -21,15 +21,15 @@ pub fn propose<G, Tr, K, F, P, V>(
 ) -> Collection<G, (P, V), Tr::Diff>
 where
     G: Scope<Timestamp=Tr::Time>,
-    Tr: TraceReader+Clone+'static,
-    for<'a> Tr::Key<'a> : IntoOwned<'a, Owned = K>,
+    Tr: for<'a> TraceReader<
+        Key<'a> : IntoOwned<'a, Owned = K>,
+        Val<'a> : IntoOwned<'a, Owned = V>,
+        Diff: Monoid+Multiply<Output = Tr::Diff>+ExchangeData+Semigroup<Tr::DiffGat<'a>>,
+    >+Clone+'static,
     K: Hashable + Default + Ord + 'static,
-    Tr::Diff: Monoid+Multiply<Output = Tr::Diff>+ExchangeData,
-    for<'a> Tr::Diff : Semigroup<Tr::DiffGat<'a>>,
     F: Fn(&P)->K+Clone+'static,
     P: ExchangeData,
     V: Clone + 'static,
-    for<'a> Tr::Val<'a> : IntoOwned<'a, Owned = V>,
 {
     crate::operators::lookup_map(
         prefixes,
@@ -54,15 +54,15 @@ pub fn propose_distinct<G, Tr, K, F, P, V>(
 ) -> Collection<G, (P, V), Tr::Diff>
 where
     G: Scope<Timestamp=Tr::Time>,
-    Tr: TraceReader+Clone+'static,
-    for<'a> Tr::Key<'a> : IntoOwned<'a, Owned = K>,
-    for<'a> Tr::Diff : Semigroup<Tr::DiffGat<'a>>,
+    Tr: for<'a> TraceReader<
+        Key<'a> : IntoOwned<'a, Owned = K>,
+        Val<'a> : IntoOwned<'a, Owned = V>,
+        Diff : Semigroup<Tr::DiffGat<'a>>+Monoid+Multiply<Output = Tr::Diff>+ExchangeData,
+    >+Clone+'static,
     K: Hashable + Default + Ord + 'static,
-    Tr::Diff: Monoid+Multiply<Output = Tr::Diff>+ExchangeData,
     F: Fn(&P)->K+Clone+'static,
     P: ExchangeData,
     V: Clone + 'static,
-    for<'a> Tr::Val<'a> : IntoOwned<'a, Owned = V>,
 {
     crate::operators::lookup_map(
         prefixes,
diff --git a/dogsdogsdogs/src/operators/validate.rs b/dogsdogsdogs/src/operators/validate.rs
index b6dfc404b0..51fe7df3a0 100644
--- a/dogsdogsdogs/src/operators/validate.rs
+++ b/dogsdogsdogs/src/operators/validate.rs
@@ -20,12 +20,12 @@ pub fn validate<G, K, V, Tr, F, P>(
 ) -> Collection<G, (P, V), Tr::Diff>
 where
     G: Scope<Timestamp=Tr::Time>,
-    Tr: TraceReader+Clone+'static,
-    for<'a> Tr::Key<'a> : IntoOwned<'a, Owned = (K, V)>,
-    for<'a> Tr::Diff : Semigroup<Tr::DiffGat<'a>>,
+    Tr: for<'a> TraceReader<
+        Key<'a> : IntoOwned<'a, Owned = (K, V)>,
+        Diff : Semigroup<Tr::DiffGat<'a>>+Monoid+Multiply<Output = Tr::Diff>+ExchangeData,
+    >+Clone+'static,
     K: Ord+Hash+Clone+Default + 'static,
     V: ExchangeData+Hash+Default,
-    Tr::Diff: Monoid+Multiply<Output = Tr::Diff>+ExchangeData,
     F: Fn(&P)->K+Clone+'static,
     P: ExchangeData,
 {