From 3eeba3be4fedd90937572b70a8dffa6c0640b6d0 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Wed, 8 Apr 2026 14:38:08 -0400
Subject: [PATCH 01/13] Track timely's Child changes

---
 Cargo.toml                                    |  4 +-
 differential-dataflow/examples/accumulate.rs  |  3 +-
 .../examples/columnar/main.rs                 |  6 +--
 differential-dataflow/examples/dynamic.rs     |  5 +-
 differential-dataflow/examples/graspan.rs     |  6 +--
 .../examples/iterate_container.rs             |  3 +-
 differential-dataflow/examples/monoid-bfs.rs  |  5 +-
 differential-dataflow/examples/pagerank.rs    |  5 +-
 .../src/algorithms/graphs/bijkstra.rs         |  7 ++-
 .../src/algorithms/graphs/propagate.rs        |  5 +-
 .../src/algorithms/graphs/scc.rs              | 10 ++--
 differential-dataflow/src/collection.rs       | 46 +++++++++++--------
 differential-dataflow/src/input.rs            | 22 ++++-----
 .../src/operators/arrange/arrangement.rs      | 23 ++++++----
 .../src/operators/iterate.rs                  | 21 +++++----
 dogsdogsdogs/examples/delta_query.rs          |  5 +-
 dogsdogsdogs/examples/delta_query_wcoj.rs     |  3 +-
 dogsdogsdogs/src/calculus.rs                  | 12 ++---
 dogsdogsdogs/src/operators/half_join.rs       |  6 +--
 experiments/src/bin/deals-interactive.rs      |  2 +-
 experiments/src/bin/deals.rs                  | 12 +++--
 experiments/src/bin/graphs-interactive-alt.rs |  7 +--
 .../src/bin/graphs-interactive-neu-zwei.rs    |  2 +-
 experiments/src/bin/graphs-interactive-neu.rs |  7 +--
 experiments/src/bin/graphs-interactive.rs     |  7 +--
 experiments/src/bin/graphs-static.rs          | 13 ++++--
 experiments/src/bin/graspan1.rs               |  5 +-
 experiments/src/bin/graspan2.rs               |  6 ++-
 interactive/src/plan/sfw.rs                   |  3 +-
 mdbook/src/chapter_2/chapter_2_7.md           | 11 +++--
 server/src/lib.rs                             |  3 +-
 31 files changed, 154 insertions(+), 121 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index d9d402c79..895c0407e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -23,9 +23,9 @@ rust-version = "1.86"
 
 [workspace.dependencies]
 differential-dataflow = { path = "differential-dataflow", default-features = false, version = "0.22.0" }
-timely = { version = "0.28", default-features = false }
+#timely = { version = "0.28", default-features = false }
 columnar = { version = "0.12", default-features = false }
-#timely = { git = "https://github.com/TimelyDataflow/timely-dataflow" }
+timely = { git = "https://github.com/TimelyDataflow/timely-dataflow" }
 #timely = { path = "../timely-dataflow/timely/", default-features = false }
 
 [workspace.lints.clippy]
diff --git a/differential-dataflow/examples/accumulate.rs b/differential-dataflow/examples/accumulate.rs
index 0fa792926..b04fe52b1 100644
--- a/differential-dataflow/examples/accumulate.rs
+++ b/differential-dataflow/examples/accumulate.rs
@@ -18,10 +18,11 @@ fn main() {
             let (input, data) = scope.new_collection::<_, isize>();
 
             use timely::dataflow::Scope;
+            let outer = scope.clone();
             scope.iterative::<u32,_,_>(|inner| {
                 data.enter_at(inner, |_| 0)
                     .consolidate()
-                    .leave()
+                    .leave(&outer)
             });
 
             input
diff --git a/differential-dataflow/examples/columnar/main.rs b/differential-dataflow/examples/columnar/main.rs
index 85b573157..66db2fc4e 100644
--- a/differential-dataflow/examples/columnar/main.rs
+++ b/differential-dataflow/examples/columnar/main.rs
@@ -115,9 +115,9 @@ mod reachability {
         roots: Collection<G, RecordedUpdates<(Node, (), Time, Diff)>>,
     ) -> Collection<G, RecordedUpdates<(Node, (), Time, Diff)>>
     {
-        let mut scope = edges.inner.scope();
+        let outer = edges.inner.scope();
 
-        scope.iterative::<u64, _, _>(|nested| {
+        outer.iterative::<u64, _, _>(|nested| {
             let summary = Product::new(Time::default(), 1);
 
             let roots_inner = roots.enter(nested);
@@ -186,7 +186,7 @@ mod reachability {
             variable.set(result_col.clone());
 
             // Leave the iterative scope.
-            result_col.leave()
+            result_col.leave(&outer)
         })
     }
 }
diff --git a/differential-dataflow/examples/dynamic.rs b/differential-dataflow/examples/dynamic.rs
index a844c28bb..35dbac8ba 100644
--- a/differential-dataflow/examples/dynamic.rs
+++ b/differential-dataflow/examples/dynamic.rs
@@ -103,7 +103,8 @@ where
     let nodes = roots.map(|x| (x, 0));
 
     // repeatedly update minimal distances each node can be reached from each root
-    nodes.scope().iterative::<PointStamp<usize>, _, _>(|inner| {
+    let outer = nodes.scope();
+    outer.iterative::<PointStamp<usize>, _, _>(|inner| {
 
         // These enter the statically bound scope, rather than any iterative scopes.
         // We do not *need* to enter them into the dynamic scope, as they are static
@@ -126,7 +127,7 @@ where
         // Leave the dynamic iteration, stripping off the last timestamp coordinate.
         next.leave_dynamic(1)
             .inspect(|x| println!("{:?}", x))
-            .leave()
+            .leave(&outer)
     })
 
 }
diff --git a/differential-dataflow/examples/graspan.rs b/differential-dataflow/examples/graspan.rs
index 79c7fd184..41d82e195 100644
--- a/differential-dataflow/examples/graspan.rs
+++ b/differential-dataflow/examples/graspan.rs
@@ -5,7 +5,6 @@ use std::fs::File;
 use timely::progress::Timestamp;
 use timely::order::Product;
 use timely::dataflow::Scope;
-use timely::dataflow::scopes::ScopeParent;
 
 use differential_dataflow::VecCollection;
 use differential_dataflow::lattice::Lattice;
@@ -69,7 +68,7 @@ use differential_dataflow::operators::arrange::{Arranged, TraceAgent};
 
 type TraceKeyHandle<K,T,R> = TraceAgent<KeySpine<K, T, R>>;
 type TraceValHandle<K,V,T,R> = TraceAgent<ValSpine<K, V, T, R>>;
-type Arrange<G,K,V,R> = Arranged<G, TraceValHandle<K, V, <G as ScopeParent>::Timestamp, R>>;
+type Arrange<G,K,V,R> = Arranged<G, TraceValHandle<K, V, <G as Scope>::Timestamp, R>>;
 
 /// An evolving set of edges.
 ///
@@ -162,6 +161,7 @@ impl Query {
         }
 
         // We need a subscope to allow iterative development of variables.
+        let outer = scope.clone();
         scope.iterative::<Iter,_,_>(|subscope| {
 
             // create map from relation name to input handle and collection.
@@ -171,7 +171,7 @@ impl Query {
             // create variables and result handles for each named relation.
             for (name, (input, collection)) in input_map {
                 let edge_variable = EdgeVariable::from(collection.enter(subscope), Product::new(Default::default(), 1));
-                let trace = edge_variable.collection.clone().leave().arrange_by_self().trace;
+                let trace = edge_variable.collection.clone().leave(&outer).arrange_by_self().trace;
                 result_map.insert(name.clone(), RelationHandles { input, trace });
                 variable_map.insert(name.clone(), edge_variable);
             }
diff --git a/differential-dataflow/examples/iterate_container.rs b/differential-dataflow/examples/iterate_container.rs
index f7ef3764e..0a45fd7ab 100644
--- a/differential-dataflow/examples/iterate_container.rs
+++ b/differential-dataflow/examples/iterate_container.rs
@@ -53,6 +53,7 @@ fn main() {
         let numbers = scope.new_collection_from(1 .. 10u32).1;
         let numbers: Collection<_, _>  = wrap(numbers.inner).as_collection();
 
+        let outer = scope.clone();
         scope.iterative::<u64,_,_>(|nested| {
             let summary = Product::new(Default::default(), 1);
             let (variable, collection) = Variable::new_from(numbers.enter(nested), summary);
@@ -77,7 +78,7 @@ fn main() {
             }).as_collection().consolidate();
             let result = wrap(result.inner).as_collection();
             variable.set(result);
-            collection.leave()
+            collection.leave(&outer)
         });
     })
 }
diff --git a/differential-dataflow/examples/monoid-bfs.rs b/differential-dataflow/examples/monoid-bfs.rs
index cce06674e..00ce5f998 100644
--- a/differential-dataflow/examples/monoid-bfs.rs
+++ b/differential-dataflow/examples/monoid-bfs.rs
@@ -127,7 +127,8 @@ where
     G: Scope<Timestamp: Lattice+Ord>,
 {
     // repeatedly update minimal distances each node can be reached from each root
-    roots.scope().iterative::<u32,_,_>(|scope| {
+    let outer = roots.scope();
+    outer.iterative::<u32,_,_>(|scope| {
 
         use differential_dataflow::operators::iterate::Variable;
         use differential_dataflow::trace::implementations::{KeySpine, KeyBuilder};
@@ -152,6 +153,6 @@ where
             .as_collection(|k,()| *k);
 
         variable.set(result.clone());
-        result.leave()
+        result.leave(&outer)
      })
 }
diff --git a/differential-dataflow/examples/pagerank.rs b/differential-dataflow/examples/pagerank.rs
index d779ed36e..caf0e5822 100644
--- a/differential-dataflow/examples/pagerank.rs
+++ b/differential-dataflow/examples/pagerank.rs
@@ -92,7 +92,8 @@ where
                      .map(|(src,_dst)| src)
                      .count();
 
-    edges.scope().iterative::<Iter,_,_>(|inner| {
+    let outer = edges.scope();
+    outer.iterative::<Iter,_,_>(|inner| {
 
         // Bring various collections into the scope.
         let edges = edges.enter(inner);
@@ -130,6 +131,6 @@ where
 
         // Bind the recursive variable, return its limit.
         ranks_bind.set(pushed.clone());
-        pushed.leave()
+        pushed.leave(&outer)
     })
 }
diff --git a/differential-dataflow/src/algorithms/graphs/bijkstra.rs b/differential-dataflow/src/algorithms/graphs/bijkstra.rs
index 9c61716ef..bfc5d7606 100644
--- a/differential-dataflow/src/algorithms/graphs/bijkstra.rs
+++ b/differential-dataflow/src/algorithms/graphs/bijkstra.rs
@@ -43,9 +43,8 @@ where
     N: ExchangeData+Hash,
     Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Diff=isize>+Clone+'static,
 {
-    forward
-        .stream
-        .scope().iterative::<u64,_,_>(|inner| {
+    let outer = forward.stream.scope();
+    outer.iterative::<u64,_,_>(|inner| {
 
             let forward_edges = forward.enter(inner);
             let reverse_edges = reverse.enter(inner);
@@ -120,6 +119,6 @@ where
 
         reverse_bind.set(reverse_next);
 
-        reached.leave()
+        reached.leave(&outer)
     })
 }
diff --git a/differential-dataflow/src/algorithms/graphs/propagate.rs b/differential-dataflow/src/algorithms/graphs/propagate.rs
index 2728de6e2..07692e3bb 100644
--- a/differential-dataflow/src/algorithms/graphs/propagate.rs
+++ b/differential-dataflow/src/algorithms/graphs/propagate.rs
@@ -78,7 +78,8 @@ where
     //      })
 
     use timely::order::Product;
-    nodes.scope().scoped::<Product<_, usize>,_,_>("Propagate", |scope| {
+    let outer = nodes.scope();
+    outer.scoped::<Product<_, usize>,_,_>("Propagate", |scope| {
 
         use crate::operators::iterate::Variable;
         use crate::trace::implementations::{ValBuilder, ValSpine};
@@ -104,6 +105,6 @@ where
 
         labels
             .as_collection(|k,v| (k.clone(), v.clone()))
-            .leave()
+            .leave(&outer)
     })
 }
diff --git a/differential-dataflow/src/algorithms/graphs/scc.rs b/differential-dataflow/src/algorithms/graphs/scc.rs
index b730302e7..bd1eff850 100644
--- a/differential-dataflow/src/algorithms/graphs/scc.rs
+++ b/differential-dataflow/src/algorithms/graphs/scc.rs
@@ -21,7 +21,8 @@ where
     R: From<i8>
 {
     use timely::order::Product;
-    graph.scope().scoped::<Product<_, usize>,_,_>("StronglyConnected", |scope| {
+    let outer = graph.scope();
+    outer.scoped::<Product<_, usize>,_,_>("StronglyConnected", |scope| {
         // Bring in edges and transposed edges.
         let edges = graph.enter(&scope);
         let trans = edges.clone().map_in_place(|x| mem::swap(&mut x.0, &mut x.1));
@@ -31,7 +32,7 @@ where
 
         let result = trim_edges(trim_edges(inner, edges), trans);
         variable.set(result.clone());
-        result.leave()
+        result.leave(&outer)
     })
 }
 
@@ -44,7 +45,8 @@ where
     R: Multiply<R, Output=R>,
     R: From<i8>
 {
-    edges.inner.scope().region_named("TrimEdges", |region| {
+    let outer = edges.inner.scope();
+    outer.region_named("TrimEdges", |region| {
         let cycle = cycle.enter_region(region);
         let edges = edges.enter_region(region);
 
@@ -62,6 +64,6 @@ where
              .join_core(labels, |e2,(e1,l1),l2| [((e1.clone(),e2.clone()),(l1.clone(),l2.clone()))])
              .filter(|(_,(l1,l2))| l1 == l2)
              .map(|((x1,x2),_)| (x2,x1))
-             .leave_region()
+             .leave_region(&outer)
     })
 }
diff --git a/differential-dataflow/src/collection.rs b/differential-dataflow/src/collection.rs
index 6981cc3da..1201474de 100644
--- a/differential-dataflow/src/collection.rs
+++ b/differential-dataflow/src/collection.rs
@@ -109,7 +109,7 @@ impl<G: Scope, C: Container> Collection<G, C> {
     ///
     /// This method is a specialization of `enter` to the case where the nested scope is a region.
     /// It removes the need for an operator that adjusts the timestamp.
-    pub fn enter_region<'a>(self, child: &Child<'a, G, <G as ScopeParent>::Timestamp>) -> Collection<Child<'a, G, <G as ScopeParent>::Timestamp>, C> {
+    pub fn enter_region<'a>(self, child: &Child<'a, G::Allocator, <G as Scope>::Timestamp>) -> Collection<Child<'a, G::Allocator, <G as Scope>::Timestamp>, C> {
         self.inner
             .enter(child)
             .as_collection()
@@ -206,19 +206,20 @@ impl<G: Scope, C: Container> Collection<G, C> {
     ///
     ///     let data = scope.new_collection_from(1 .. 10).1;
     ///
+    ///     let outer = scope.clone();
     ///     let result = scope.region(|child| {
     ///         data.clone()
     ///             .enter(child)
-    ///             .leave()
+    ///             .leave(&outer)
     ///     });
     ///
     ///     data.assert_eq(result);
     /// });
     /// ```
-    pub fn enter<'a, T>(self, child: &Child<'a, G, T>) -> Collection<Child<'a, G, T>, <C as containers::Enter<<G as ScopeParent>::Timestamp, T>>::InnerContainer>
+    pub fn enter<'a, T>(self, child: &Child<'a, G::Allocator, T>) -> Collection<Child<'a, G::Allocator, T>, <C as containers::Enter<<G as Scope>::Timestamp, T>>::InnerContainer>
     where
-        C: containers::Enter<<G as ScopeParent>::Timestamp, T, InnerContainer: Container>,
-        T: Refines<<G as ScopeParent>::Timestamp>,
+        C: containers::Enter<<G as Scope>::Timestamp, T, InnerContainer: Container>,
+        T: Refines<<G as Scope>::Timestamp>,
     {
         use timely::dataflow::channels::pact::Pipeline;
         self.inner
@@ -262,14 +263,10 @@ impl<G: Scope, C: Container> Collection<G, C> {
     }
 }
 
-use timely::dataflow::scopes::ScopeParent;
 use timely::progress::timestamp::Refines;
 
 /// Methods requiring a nested scope.
-impl<'a, G: Scope, T: Timestamp, C: Container> Collection<Child<'a, G, T>, C>
-where
-    C: containers::Leave<T, G::Timestamp, OuterContainer: Container>,
-    T: Refines<<G as ScopeParent>::Timestamp>,
+impl<'a, A: timely::communication::Allocate, T: Timestamp, C: Container> Collection<Child<'a, A, T>, C>
 {
     /// Returns the final value of a Collection from a nested scope to its containing scope.
     ///
@@ -286,16 +283,21 @@ where
     ///    let result = scope.region(|child| {
     ///         data.clone()
     ///             .enter(child)
-    ///             .leave()
+    ///             .leave(scope)
     ///     });
     ///
     ///     data.assert_eq(result);
     /// });
     /// ```
-    pub fn leave(self) -> Collection<G, <C as containers::Leave<T, G::Timestamp>>::OuterContainer> {
+    pub fn leave<G>(self, outer: &G) -> Collection<G, <C as containers::Leave<T, G::Timestamp>>::OuterContainer>
+    where
+        G: Scope<Allocator = A>,
+        T: Refines<G::Timestamp>,
+        C: containers::Leave<T, G::Timestamp, OuterContainer: Container>,
+    {
         use timely::dataflow::channels::pact::Pipeline;
         self.inner
-            .leave()
+            .leave(outer)
             .unary(Pipeline, "Leave", move |_,_| move |input, output| {
                 input.for_each(|time, data| output.session(&time).give_container(&mut std::mem::take(data).leave()));
             })
@@ -304,15 +306,18 @@ where
 }
 
 /// Methods requiring a region as the scope.
-impl<G: Scope, C: Container+Clone+'static> Collection<Child<'_, G, G::Timestamp>, C>
+impl<'a, A: timely::communication::Allocate, T: Timestamp, C: Container+Clone+'static> Collection<Child<'a, A, T>, C>
 {
     /// Returns the value of a Collection from a nested region to its containing scope.
     ///
     /// This method is a specialization of `leave` to the case that of a nested region.
     /// It removes the need for an operator that adjusts the timestamp.
-    pub fn leave_region(self) -> Collection<G, C> {
+    pub fn leave_region<G>(self, outer: &G) -> Collection<G, C>
+    where
+        G: Scope<Allocator = A, Timestamp = T>,
+    {
         self.inner
-            .leave()
+            .leave(outer)
             .as_collection()
     }
 }
@@ -326,7 +331,7 @@ pub mod vec {
     use timely::progress::Timestamp;
     use timely::order::Product;
     use timely::dataflow::scopes::child::Iterative;
-    use timely::dataflow::{Scope, ScopeParent};
+    use timely::dataflow::Scope;
     use timely::dataflow::operators::*;
     use timely::dataflow::operators::vec::*;
 
@@ -352,7 +357,7 @@ pub mod vec {
     /// defaults to) `isize`, representing changes to the occurrence count of each record.
     ///
     /// This type definition instantiates the [`Collection`] type with a `Vec<(D, G::Timestamp, R)>`.
-    pub type Collection<G, D, R = isize> = super::Collection<G, Vec<(D, <G as ScopeParent>::Timestamp, R)>>;
+    pub type Collection<G, D, R = isize> = super::Collection<G, Vec<(D, <G as Scope>::Timestamp, R)>>;
 
 
     impl<G: Scope, D: Clone+'static, R: Clone+'static> Collection<G, D, R> {
@@ -534,16 +539,17 @@ pub mod vec {
         ///
         ///     let data = scope.new_collection_from(1 .. 10).1;
         ///
+        ///     let outer = scope.clone();
         ///     let result = scope.iterative::<u64,_,_>(|child| {
         ///         data.clone()
         ///             .enter_at(child, |x| *x)
-        ///             .leave()
+        ///             .leave(&outer)
         ///     });
         ///
         ///     data.assert_eq(result);
         /// });
         /// ```
-        pub fn enter_at<'a, T, F>(self, child: &Iterative<'a, G, T>, mut initial: F) -> Collection<Iterative<'a, G, T>, D, R>
+        pub fn enter_at<'a, T, F>(self, child: &Iterative<'a, G::Allocator, G::Timestamp, T>, mut initial: F) -> Collection<Iterative<'a, G::Allocator, G::Timestamp, T>, D, R>
         where
             T: Timestamp+Hash,
             F: FnMut(&D) -> T + Clone + 'static,
diff --git a/differential-dataflow/src/input.rs b/differential-dataflow/src/input.rs
index 43a4987e8..2d669fb4f 100644
--- a/differential-dataflow/src/input.rs
+++ b/differential-dataflow/src/input.rs
@@ -9,7 +9,7 @@
 use timely::progress::Timestamp;
 use timely::dataflow::operators::vec::Input as TimelyInput;
 use timely::dataflow::operators::vec::input::Handle;
-use timely::dataflow::scopes::ScopeParent;
+use timely::dataflow::Scope;
 
 use crate::Data;
 use crate::difference::Semigroup;
@@ -41,7 +41,7 @@ pub trait Input : TimelyInput {
     ///
     /// }).unwrap();
     /// ```
-    fn new_collection<D, R>(&mut self) -> (InputSession<<Self as ScopeParent>::Timestamp, D, R>, VecCollection<Self, D, R>)
+    fn new_collection<D, R>(&mut self) -> (InputSession<<Self as Scope>::Timestamp, D, R>, VecCollection<Self, D, R>)
     where D: Data, R: Semigroup+'static;
     /// Create a new collection and input handle from initial data.
     ///
@@ -67,7 +67,7 @@ pub trait Input : TimelyInput {
     ///
     /// }).unwrap();
     /// ```
-    fn new_collection_from<I>(&mut self, data: I) -> (InputSession<<Self as ScopeParent>::Timestamp, I::Item, isize>, VecCollection<Self, I::Item, isize>)
+    fn new_collection_from<I>(&mut self, data: I) -> (InputSession<<Self as Scope>::Timestamp, I::Item, isize>, VecCollection<Self, I::Item, isize>)
     where I: IntoIterator<Item: Data> + 'static;
     /// Create a new collection and input handle from initial data.
     ///
@@ -93,28 +93,28 @@ pub trait Input : TimelyInput {
     ///
     /// }).unwrap();
     /// ```
-    fn new_collection_from_raw<D, R, I>(&mut self, data: I) -> (InputSession<<Self as ScopeParent>::Timestamp, D, R>, VecCollection<Self, D, R>)
-    where I: IntoIterator<Item=(D,<Self as ScopeParent>::Timestamp,R)>+'static, D: Data, R: Semigroup+'static;
+    fn new_collection_from_raw<D, R, I>(&mut self, data: I) -> (InputSession<<Self as Scope>::Timestamp, D, R>, VecCollection<Self, D, R>)
+    where I: IntoIterator<Item=(D,<Self as Scope>::Timestamp,R)>+'static, D: Data, R: Semigroup+'static;
 }
 
 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>, VecCollection<G, D, R>)
+impl<G: TimelyInput> Input for G where <G as Scope>::Timestamp: Lattice {
+    fn new_collection<D, R>(&mut self) -> (InputSession<<G as Scope>::Timestamp, D, R>, VecCollection<G, D, R>)
     where
         D: Data, R: Semigroup+'static,
     {
         let (handle, stream) = self.new_input();
         (InputSession::from(handle), stream.as_collection())
     }
-    fn new_collection_from<I>(&mut self, data: I) -> (InputSession<<G as ScopeParent>::Timestamp, I::Item, isize>, VecCollection<G, I::Item, isize>)
+    fn new_collection_from<I>(&mut self, data: I) -> (InputSession<<G as Scope>::Timestamp, I::Item, isize>, VecCollection<G, I::Item, isize>)
     where I: IntoIterator+'static, I::Item: Data {
         self.new_collection_from_raw(data.into_iter().map(|d| (d, <G::Timestamp as timely::progress::Timestamp>::minimum(), 1)))
     }
-    fn new_collection_from_raw<D,R,I>(&mut self, data: I) -> (InputSession<<G as ScopeParent>::Timestamp, D, R>, VecCollection<G, D, R>)
+    fn new_collection_from_raw<D,R,I>(&mut self, data: I) -> (InputSession<<G as Scope>::Timestamp, D, R>, VecCollection<G, D, R>)
     where
         D: Data,
         R: Semigroup+'static,
-        I: IntoIterator<Item=(D,<Self as ScopeParent>::Timestamp,R)>+'static,
+        I: IntoIterator<Item=(D,<Self as Scope>::Timestamp,R)>+'static,
     {
         use timely::dataflow::operators::ToStream;
 
@@ -200,7 +200,7 @@ impl<T: Timestamp+Clone, D: Data, R: Semigroup+'static> InputSession<T, D, R> {
     /// Introduces a handle as collection.
     pub fn to_collection<G: TimelyInput>(&mut self, scope: &mut G) -> VecCollection<G, D, R>
     where
-        G: ScopeParent<Timestamp=T>,
+        G: Scope<Timestamp=T>,
     {
         scope
             .input_from(&mut self.handle)
diff --git a/differential-dataflow/src/operators/arrange/arrangement.rs b/differential-dataflow/src/operators/arrange/arrangement.rs
index cd1bd0894..cd0d00dfc 100644
--- a/differential-dataflow/src/operators/arrange/arrangement.rs
+++ b/differential-dataflow/src/operators/arrange/arrangement.rs
@@ -85,8 +85,8 @@ where
     /// This method produces a proxy trace handle that uses the same backing data, but acts as if the timestamps
     /// have all been extended with an additional coordinate with the default value. The resulting collection does
     /// not vary with the new timestamp coordinate.
-    pub fn enter<'a, TInner>(self, child: &Child<'a, G, TInner>)
-        -> Arranged<Child<'a, G, TInner>, TraceEnter<Tr, TInner>>
+    pub fn enter<'a, TInner>(self, child: &Child<'a, G::Allocator, TInner>)
+        -> Arranged<Child<'a, G::Allocator, TInner>, TraceEnter<Tr, TInner>>
         where
             TInner: Refines<G::Timestamp>+Lattice+Timestamp+Clone,
     {
@@ -100,8 +100,8 @@ where
     ///
     /// This method only applies to *regions*, which are subscopes with the same timestamp
     /// as their containing scope. In this case, the trace type does not need to change.
-    pub fn enter_region<'a>(self, child: &Child<'a, G, G::Timestamp>)
-        -> Arranged<Child<'a, G, G::Timestamp>, Tr> {
+    pub fn enter_region<'a>(self, child: &Child<'a, G::Allocator, G::Timestamp>)
+        -> Arranged<Child<'a, G::Allocator, G::Timestamp>, Tr> {
         Arranged {
             stream: self.stream.enter(child),
             trace: self.trace,
@@ -113,8 +113,8 @@ where
     /// This method produces a proxy trace handle that uses the same backing data, but acts as if the timestamps
     /// have all been extended with an additional coordinate with the default value. The resulting collection does
     /// not vary with the new timestamp coordinate.
-    pub fn enter_at<'a, TInner, F, P>(self, child: &Child<'a, G, TInner>, logic: F, prior: P)
-        -> Arranged<Child<'a, G, TInner>, TraceEnterAt<Tr, TInner, F, P>>
+    pub fn enter_at<'a, TInner, F, P>(self, child: &Child<'a, G::Allocator, TInner>, logic: F, prior: P)
+        -> Arranged<Child<'a, G::Allocator, TInner>, TraceEnterAt<Tr, TInner, F, P>>
         where
             TInner: Refines<G::Timestamp>+Lattice+Timestamp+Clone+'static,
             F: FnMut(Tr::Key<'_>, Tr::Val<'_>, Tr::TimeGat<'_>)->TInner+Clone+'static,
@@ -315,19 +315,22 @@ where
 }
 
 
-impl<'a, G, Tr> Arranged<Child<'a, G, G::Timestamp>, Tr>
+impl<'a, A, Tr> Arranged<Child<'a, A, Tr::Time>, Tr>
 where
-    G: Scope<Timestamp=Tr::Time>,
+    A: timely::communication::Allocate,
     Tr: TraceReader + Clone,
 {
     /// Brings an arranged collection out of a nested region.
     ///
     /// This method only applies to *regions*, which are subscopes with the same timestamp
     /// as their containing scope. In this case, the trace type does not need to change.
-    pub fn leave_region(self) -> Arranged<G, Tr> {
+    pub fn leave_region<G>(self, outer: &G) -> Arranged<G, Tr>
+    where
+        G: Scope<Allocator = A, Timestamp = Tr::Time>,
+    {
         use timely::dataflow::operators::Leave;
         Arranged {
-            stream: self.stream.leave(),
+            stream: self.stream.leave(outer),
             trace: self.trace,
         }
     }
diff --git a/differential-dataflow/src/operators/iterate.rs b/differential-dataflow/src/operators/iterate.rs
index e5486bb6e..3dd3412b2 100644
--- a/differential-dataflow/src/operators/iterate.rs
+++ b/differential-dataflow/src/operators/iterate.rs
@@ -75,15 +75,16 @@ pub trait Iterate<G: Scope<Timestamp: Lattice>, D: Data, R: Semigroup> {
     /// ```
     fn iterate<F>(self, logic: F) -> VecCollection<G, D, R>
     where
-        for<'a> F: FnOnce(Iterative<'a, G, u64>, VecCollection<Iterative<'a, G, u64>, D, R>)->VecCollection<Iterative<'a, G, u64>, D, R>;
+        for<'a> F: FnOnce(Iterative<'a, G::Allocator, G::Timestamp, u64>, VecCollection<Iterative<'a, G::Allocator, G::Timestamp, u64>, D, R>)->VecCollection<Iterative<'a, G::Allocator, G::Timestamp, u64>, D, R>;
 }
 
 impl<G: Scope<Timestamp: Lattice>, D: Ord+Data+Debug, R: Abelian+'static> Iterate<G, D, R> for VecCollection<G, D, R> {
     fn iterate<F>(self, logic: F) -> VecCollection<G, D, R>
     where
-        for<'a> F: FnOnce(Iterative<'a, G, u64>, VecCollection<Iterative<'a, G, u64>, D, R>)->VecCollection<Iterative<'a, G, u64>, D, R>,
+        for<'a> F: FnOnce(Iterative<'a, G::Allocator, G::Timestamp, u64>, VecCollection<Iterative<'a, G::Allocator, G::Timestamp, u64>, D, R>)->VecCollection<Iterative<'a, G::Allocator, G::Timestamp, u64>, D, R>,
     {
-        self.inner.scope().scoped("Iterate", |subgraph| {
+        let outer = self.inner.scope();
+        outer.scoped("Iterate", |subgraph| {
             // create a new variable, apply logic, bind variable, return.
             //
             // this could be much more succinct if we returned the collection
@@ -93,16 +94,17 @@ impl<G: Scope<Timestamp: Lattice>, D: Ord+Data+Debug, R: Abelian+'static> Iterat
             let (variable, collection) = Variable::new_from(self.enter(subgraph), Product::new(Default::default(), 1));
             let result = logic(subgraph.clone(), collection);
             variable.set(result.clone());
-            result.leave()
+            result.leave(&outer)
         })
     }
 }
 
 impl<G: Scope<Timestamp: Lattice>, D: Ord+Data+Debug, R: Semigroup+'static> Iterate<G, D, R> for G {
-    fn iterate<F>(mut self, logic: F) -> VecCollection<G, D, R>
+    fn iterate<F>(self, logic: F) -> VecCollection<G, D, R>
     where
-        for<'a> F: FnOnce(Iterative<'a, G, u64>, VecCollection<Iterative<'a, G, u64>, D, R>)->VecCollection<Iterative<'a, G, u64>, D, R>,
+        for<'a> F: FnOnce(Iterative<'a, G::Allocator, G::Timestamp, u64>, VecCollection<Iterative<'a, G::Allocator, G::Timestamp, u64>, D, R>)->VecCollection<Iterative<'a, G::Allocator, G::Timestamp, u64>, D, R>,
     {
+        let outer = self.clone();
         self.scoped("Iterate", |subgraph| {
                 // create a new variable, apply logic, bind variable, return.
                 //
@@ -113,7 +115,7 @@ impl<G: Scope<Timestamp: Lattice>, D: Ord+Data+Debug, R: Semigroup+'static> Iter
                 let (variable, collection) = Variable::new(subgraph, Product::new(Default::default(), 1));
                 let result = logic(subgraph.clone(), collection);
                 variable.set(result.clone());
-                result.leave()
+                result.leave(&outer)
             }
         )
     }
@@ -140,13 +142,14 @@ impl<G: Scope<Timestamp: Lattice>, D: Ord+Data+Debug, R: Semigroup+'static> Iter
 ///
 ///     let numbers = scope.new_collection_from(1 .. 10u32).1;
 ///
+///     let outer = scope.clone();
 ///     scope.iterative::<u64,_,_>(|nested| {
 ///         let summary = Product::new(Default::default(), 1);
 ///         let (variable, collection) = Variable::new_from(numbers.enter(nested), summary);
 ///         let result = collection.map(|x| if x % 2 == 0 { x/2 } else { x })
 ///                                .consolidate();
 ///         variable.set(result.clone());
-///         result.leave()
+///         result.leave(&outer)
 ///     });
 /// })
 /// ```
@@ -198,7 +201,7 @@ where
 }
 
 /// A `Variable` specialized to a vector container of update triples (data, time, diff).
-pub type VecVariable<G, D, R> = Variable<G, Vec<(D, <G as ScopeParent>::Timestamp, R)>>;
+pub type VecVariable<G, D, R> = Variable<G, Vec<(D, <G as Scope>::Timestamp, R)>>;
 
 impl<G, C: Container> Variable<G, C>
 where
diff --git a/dogsdogsdogs/examples/delta_query.rs b/dogsdogsdogs/examples/delta_query.rs
index af9eb5bfd..8c46a090b 100644
--- a/dogsdogsdogs/examples/delta_query.rs
+++ b/dogsdogsdogs/examples/delta_query.rs
@@ -43,6 +43,7 @@ fn main() {
             // let reverse_count = edges.map(|(x,y)| y).arrange_by_self();
 
             // Q(a,b,c) :=  E1(a,b),  E2(b,c),  E3(a,c)
+            let outer = scope.clone();
             let (triangles_prev, triangles_next) = scope.scoped::<AltNeu<usize>,_,_>("DeltaQuery (Triangles)", |inner| {
 
                 // Grab the stream of changes.
@@ -90,7 +91,7 @@ fn main() {
                 let changes3 = validate(changes3, reverse_self_alt.clone(), key2.clone());
                 let changes3 = changes3.map(|((a,c),b)| (a,b,c));
 
-                let prev_changes = changes1.concat(changes2).concat(changes3).leave();
+                let prev_changes = changes1.concat(changes2).concat(changes3).leave(&outer);
 
                 // New ideas
                 let d_edges = edges.differentiate(inner);
@@ -116,7 +117,7 @@ fn main() {
                     .join_core(forward_key_alt, |a,c,b| Some(((*c, *b), *a)))
                     .join_core(reverse_self_alt, |(c,b), a, &()| Some((*a,*b,*c)));
 
-                let next_changes = changes1.concat(changes2).concat(changes3).integrate();
+                let next_changes = changes1.concat(changes2).concat(changes3).integrate(&outer);
 
                 (prev_changes, next_changes)
             });
diff --git a/dogsdogsdogs/examples/delta_query_wcoj.rs b/dogsdogsdogs/examples/delta_query_wcoj.rs
index afceef1ee..ac8ae3e6c 100644
--- a/dogsdogsdogs/examples/delta_query_wcoj.rs
+++ b/dogsdogsdogs/examples/delta_query_wcoj.rs
@@ -31,6 +31,7 @@ fn main() {
             let reverse = edges.map(|(x,y)| (y,x));
 
             // Q(a,b,c) :=  E1(a,b),  E2(b,c),  E3(a,c)
+            let outer = scope.clone();
             let triangles = scope.scoped::<AltNeu<usize>,_,_>("DeltaQuery (Triangles)", |inner| {
 
                 // Each relation we'll need.
@@ -80,7 +81,7 @@ fn main() {
                     ])
                     .map(|((a,c),b)| (a,b,c));
 
-                changes1.concat(changes2).concat(changes3).leave()
+                changes1.concat(changes2).concat(changes3).leave(&outer)
             });
 
             triangles
diff --git a/dogsdogsdogs/src/calculus.rs b/dogsdogsdogs/src/calculus.rs
index 94b443231..c6f057dcb 100644
--- a/dogsdogsdogs/src/calculus.rs
+++ b/dogsdogsdogs/src/calculus.rs
@@ -22,12 +22,12 @@ use crate::altneu::AltNeu;
 
 /// Produce a collection containing the changes at the moments they happen.
 pub trait Differentiate<G: Scope, D: Data, R: Abelian> {
-    fn differentiate<'a>(self, child: &Child<'a, G, AltNeu<G::Timestamp>>) -> VecCollection<Child<'a, G, AltNeu<G::Timestamp>>, D, R>;
+    fn differentiate<'a>(self, child: &Child<'a, G::Allocator, AltNeu<G::Timestamp>>) -> VecCollection<Child<'a, G::Allocator, AltNeu<G::Timestamp>>, D, R>;
 }
 
 /// Collect instantaneous changes back in to a collection.
 pub trait Integrate<G: Scope, D: Data, R: Abelian> {
-    fn integrate(self) -> VecCollection<G, D, R>;
+    fn integrate(self, outer: &G) -> VecCollection<G, D, R>;
 }
 
 impl<G, D, R> Differentiate<G, D, R> for VecCollection<G, D, R>
@@ -37,7 +37,7 @@ where
     R: Abelian + 'static,
 {
     // For each (data, Alt(time), diff) we add a (data, Neu(time), -diff).
-    fn differentiate<'a>(self, child: &Child<'a, G, AltNeu<G::Timestamp>>) -> VecCollection<Child<'a, G, AltNeu<G::Timestamp>>, D, R> {
+    fn differentiate<'a>(self, child: &Child<'a, G::Allocator, AltNeu<G::Timestamp>>) -> VecCollection<Child<'a, G::Allocator, AltNeu<G::Timestamp>>, D, R> {
         self.enter(child)
             .inner
             .flat_map(|(data, time, diff)| {
@@ -51,17 +51,17 @@ where
     }
 }
 
-impl<'a, G, D, R> Integrate<G, D, R> for VecCollection<Child<'a, G, AltNeu<G::Timestamp>>, D, R>
+impl<'a, G, D, R> Integrate<G, D, R> for VecCollection<Child<'a, G::Allocator, AltNeu<G::Timestamp>>, D, R>
 where
     G: Scope,
     D: Data,
     R: Abelian + 'static,
 {
     // We discard each `neu` variant and strip off the `alt` wrapper.
-    fn integrate(self) -> VecCollection<G, D, R> {
+    fn integrate(self, outer: &G) -> VecCollection<G, D, R> {
         self.inner
             .filter(|(_d,t,_r)| !t.neu)
             .as_collection()
-            .leave()
+            .leave(outer)
     }
 }
diff --git a/dogsdogsdogs/src/operators/half_join.rs b/dogsdogsdogs/src/operators/half_join.rs
index 2a18a9aa1..16aa59876 100644
--- a/dogsdogsdogs/src/operators/half_join.rs
+++ b/dogsdogsdogs/src/operators/half_join.rs
@@ -37,7 +37,7 @@ use std::time::Instant;
 
 use timely::ContainerBuilder;
 use timely::container::CapacityContainerBuilder;
-use timely::dataflow::{Scope, ScopeParent, Stream};
+use timely::dataflow::{Scope, Stream};
 use timely::dataflow::channels::pact::{Pipeline, Exchange};
 use timely::dataflow::operators::{Capability, Operator, generic::Session};
 use timely::progress::Antichain;
@@ -109,9 +109,9 @@ where
 /// This is a shorthand primarily for the reson of readability.
 type SessionFor<'a, 'b, G, CB> =
     Session<'a, 'b,
-        <G as ScopeParent>::Timestamp,
+        <G as Scope>::Timestamp,
         CB,
-        Capability<<G as ScopeParent>::Timestamp>,
+        Capability<<G as Scope>::Timestamp>,
     >;
 
 /// An unsafe variant of `half_join` where the `output_func` closure takes
diff --git a/experiments/src/bin/deals-interactive.rs b/experiments/src/bin/deals-interactive.rs
index 3ea53cd14..83c7ae960 100644
--- a/experiments/src/bin/deals-interactive.rs
+++ b/experiments/src/bin/deals-interactive.rs
@@ -13,7 +13,7 @@ use differential_dataflow::trace::implementations::ValSpine;
 use differential_dataflow::operators::arrange::TraceAgent;
 use differential_dataflow::operators::arrange::Arranged;
 
-type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, <G as ScopeParent>::Timestamp, R>>>;
+type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, <G as Scope>::Timestamp, R>>>;
 
 type Node = u32;
 
diff --git a/experiments/src/bin/deals.rs b/experiments/src/bin/deals.rs
index 782941e15..f67e34146 100644
--- a/experiments/src/bin/deals.rs
+++ b/experiments/src/bin/deals.rs
@@ -13,7 +13,7 @@ use differential_dataflow::operators::arrange::Arrange;
 use differential_dataflow::operators::iterate::Variable;
 use differential_dataflow::difference::Present;
 
-type EdgeArranged<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, <G as ScopeParent>::Timestamp, R>>>;
+type EdgeArranged<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, <G as Scope>::Timestamp, R>>>;
 
 type Node = u32;
 type Edge = (Node, Node);
@@ -86,7 +86,8 @@ use timely::order::Product;
 fn tc<G: Scope<Timestamp=()>>(edges: EdgeArranged<G, Node, Node, Present>) -> VecCollection<G, Edge, Present> {
 
     // repeatedly update minimal distances each node can be reached from each root
-    edges.stream.scope().iterative::<Iter,_,_>(|scope| {
+    let outer = edges.stream.scope();
+    outer.iterative::<Iter,_,_>(|scope| {
 
             let (inner, inner_collection) = Variable::new(scope, Product::new(Default::default(), 1));
             let edges = edges.enter(scope);
@@ -102,7 +103,7 @@ fn tc<G: Scope<Timestamp=()>>(edges: EdgeArranged<G, Node, Node, Present>) -> Ve
                 ;
 
             inner.set(result.clone());
-            result.leave()
+            result.leave(&outer)
         }
     )
 }
@@ -113,7 +114,8 @@ fn sg<G: Scope<Timestamp=()>>(edges: EdgeArranged<G, Node, Node, Present>) -> Ve
     let peers = edges.clone().join_core(edges.clone(), |_,&x,&y| Some((x,y))).filter(|&(x,y)| x != y);
 
     // repeatedly update minimal distances each node can be reached from each root
-    peers.scope().iterative::<Iter,_,_>(|scope| {
+    let outer = peers.scope();
+    outer.iterative::<Iter,_,_>(|scope| {
 
             let (inner, inner_collection) = Variable::new(scope, Product::new(Default::default(), 1));
             let edges = edges.enter(scope);
@@ -131,7 +133,7 @@ fn sg<G: Scope<Timestamp=()>>(edges: EdgeArranged<G, Node, Node, Present>) -> Ve
                 ;
 
             inner.set(result.clone());
-            result.leave()
+            result.leave(&outer)
         }
     )
 }
diff --git a/experiments/src/bin/graphs-interactive-alt.rs b/experiments/src/bin/graphs-interactive-alt.rs
index 6e5b0ffaa..d7533d4a0 100644
--- a/experiments/src/bin/graphs-interactive-alt.rs
+++ b/experiments/src/bin/graphs-interactive-alt.rs
@@ -258,7 +258,7 @@ use differential_dataflow::trace::implementations::ValSpine;
 use differential_dataflow::operators::arrange::TraceAgent;
 use differential_dataflow::operators::arrange::Arranged;
 
-type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, <G as ScopeParent>::Timestamp, R>>>;
+type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, <G as Scope>::Timestamp, R>>>;
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
 fn three_hop<G: Scope>(
@@ -294,7 +294,8 @@ fn _bidijkstra<G: Scope>(
     goals: VecCollection<G, (Node, Node)>) -> VecCollection<G, ((Node, Node), u32)>
 where G::Timestamp: Lattice+Ord {
 
-    goals.scope().iterative::<Iter,_,_>(|inner| {
+    let outer = goals.scope();
+    outer.iterative::<Iter,_,_>(|inner| {
 
         // Our plan is to start evolving distances from both sources and destinations.
         // The evolution from a source or destination should continue as long as there
@@ -356,7 +357,7 @@ where G::Timestamp: Lattice+Ord {
 
         reverse.set(reverse_next);
 
-        reached.leave()
+        reached.leave(&outer)
     })
 }
 
diff --git a/experiments/src/bin/graphs-interactive-neu-zwei.rs b/experiments/src/bin/graphs-interactive-neu-zwei.rs
index 35a118cd9..62675f93f 100644
--- a/experiments/src/bin/graphs-interactive-neu-zwei.rs
+++ b/experiments/src/bin/graphs-interactive-neu-zwei.rs
@@ -226,7 +226,7 @@ use differential_dataflow::trace::implementations::ValSpine;
 use differential_dataflow::operators::arrange::TraceAgent;
 use differential_dataflow::operators::arrange::Arranged;
 
-type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, <G as ScopeParent>::Timestamp, R>>>;
+type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, <G as Scope>::Timestamp, R>>>;
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
 fn three_hop<G: Scope>(
diff --git a/experiments/src/bin/graphs-interactive-neu.rs b/experiments/src/bin/graphs-interactive-neu.rs
index 7e27e7ed8..dcc00b0b9 100644
--- a/experiments/src/bin/graphs-interactive-neu.rs
+++ b/experiments/src/bin/graphs-interactive-neu.rs
@@ -291,7 +291,7 @@ use differential_dataflow::trace::implementations::ValSpine;
 use differential_dataflow::operators::arrange::TraceAgent;
 use differential_dataflow::operators::arrange::Arranged;
 
-type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, <G as ScopeParent>::Timestamp, R>>>;
+type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, <G as Scope>::Timestamp, R>>>;
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
 fn three_hop<G: Scope>(
@@ -327,7 +327,8 @@ fn _bidijkstra<G: Scope>(
     goals: VecCollection<G, (Node, Node)>) -> VecCollection<G, ((Node, Node), u32)>
 where G::Timestamp: Lattice+Ord {
 
-    goals.scope().iterative::<Iter,_,_>(|inner| {
+    let outer = goals.scope();
+    outer.iterative::<Iter,_,_>(|inner| {
 
         // Our plan is to start evolving distances from both sources and destinations.
         // The evolution from a source or destination should continue as long as there
@@ -389,6 +390,6 @@ where G::Timestamp: Lattice+Ord {
 
         reverse.set(reverse_next);
 
-        reached.leave()
+        reached.leave(&outer)
     })
 }
diff --git a/experiments/src/bin/graphs-interactive.rs b/experiments/src/bin/graphs-interactive.rs
index 2ec74e93f..54fc27309 100644
--- a/experiments/src/bin/graphs-interactive.rs
+++ b/experiments/src/bin/graphs-interactive.rs
@@ -194,7 +194,7 @@ use differential_dataflow::trace::implementations::ValSpine;
 use differential_dataflow::operators::arrange::TraceAgent;
 use differential_dataflow::operators::arrange::Arranged;
 
-type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, <G as ScopeParent>::Timestamp, R>>>;
+type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, <G as Scope>::Timestamp, R>>>;
 
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
@@ -231,7 +231,8 @@ fn _bidijkstra<G: Scope>(
     goals: VecCollection<G, (Node, Node)>) -> VecCollection<G, ((Node, Node), u32)>
 where G::Timestamp: Lattice+Ord {
 
-    goals.scope().iterative::<usize,_,_>(|inner| {
+    let outer = goals.scope();
+    outer.iterative::<usize,_,_>(|inner| {
 
         // Our plan is to start evolving distances from both sources and destinations.
         // The evolution from a source or destination should continue as long as there
@@ -293,6 +294,6 @@ where G::Timestamp: Lattice+Ord {
 
         reverse.set(reverse_next);
 
-        reached.leave()
+        reached.leave(&outer)
     })
 }
diff --git a/experiments/src/bin/graphs-static.rs b/experiments/src/bin/graphs-static.rs
index 16cbbd6dd..7c382d645 100644
--- a/experiments/src/bin/graphs-static.rs
+++ b/experiments/src/bin/graphs-static.rs
@@ -113,7 +113,8 @@ fn reach<G: Scope<Timestamp = ()>> (
 
     let graph = graph.import(&roots.scope());
 
-    roots.scope().iterative::<Iter,_,_>(|scope| {
+    let outer = roots.scope();
+    outer.iterative::<Iter,_,_>(|scope| {
 
         let graph = graph.enter(scope);
         let roots = roots.enter(scope);
@@ -126,7 +127,7 @@ fn reach<G: Scope<Timestamp = ()>> (
              .threshold_total(|_,_| 1);
 
         inner.set(result.clone());
-        result.leave()
+        result.leave(&outer)
     })
 }
 
@@ -139,7 +140,8 @@ fn bfs<G: Scope<Timestamp = ()>> (
     let graph = graph.import(&roots.scope());
     let roots = roots.map(|r| (r,0));
 
-    roots.scope().iterative::<Iter,_,_>(|scope| {
+    let outer = roots.scope();
+    outer.iterative::<Iter,_,_>(|scope| {
 
         let graph = graph.enter(scope);
         let roots = roots.enter(scope);
@@ -151,7 +153,7 @@ fn bfs<G: Scope<Timestamp = ()>> (
              .reduce(|_key, input, output| output.push((*input[0].0,1)));
 
         inner.set(result.clone());
-        result.leave()
+        result.leave(&outer)
     })
 }
 
@@ -169,6 +171,7 @@ fn connected_components<G: Scope<Timestamp = ()>>(
     let nodes_r = reverse.clone().flat_map_ref(|k,v| if k < v { Some(*k) } else { None });
     let nodes = nodes_f.concat(nodes_r).consolidate().map(|x| (x,x));
 
+    let outer = scope.clone();
     scope.iterative(|scope| {
 
         // import arrangements, nodes.
@@ -197,6 +200,6 @@ fn connected_components<G: Scope<Timestamp = ()>>(
             .reduce(|_, s, t| { t.push((*s[0].0, 1)); });
 
         inner.set(result.clone());
-        result.leave()
+        result.leave(&outer)
     })
 }
diff --git a/experiments/src/bin/graspan1.rs b/experiments/src/bin/graspan1.rs
index 507f5c46b..82fbe3ba2 100644
--- a/experiments/src/bin/graspan1.rs
+++ b/experiments/src/bin/graspan1.rs
@@ -35,8 +35,9 @@ fn main() {
 
             // a N c  <-  a N b && b E c
             // N(a,c) <-  N(a,b), E(b, c)
+            let outer = nodes.scope();
             let reached =
-            nodes.scope().iterative::<Iter,_,_>(|inner| {
+            outer.iterative::<Iter,_,_>(|inner| {
 
                 let nodes = nodes.enter(inner).map(|(a,b)| (b,a));
                 let edges = edges.enter(inner);
@@ -51,7 +52,7 @@ fn main() {
                       .threshold_semigroup(|_,_,x: Option<&Present>| if x.is_none() { Some(Present) } else { None });
 
                 labels.set(next.clone());
-                next.leave()
+                next.leave(&outer)
             });
 
             reached
diff --git a/experiments/src/bin/graspan2.rs b/experiments/src/bin/graspan2.rs
index 4ce8574a9..64d44dbe0 100644
--- a/experiments/src/bin/graspan2.rs
+++ b/experiments/src/bin/graspan2.rs
@@ -49,6 +49,7 @@ fn unoptimized() {
 
             let dereference = dereference.arrange::<ValBatcher<_,_,_,_>, ValBuilder<_,_,_,_>, ValSpine<_,_,_,_>>();
 
+            let outer = scope.clone();
             let (value_flow, memory_alias, value_alias) =
             scope
                 .iterative::<Iter,_,_>(|scope| {
@@ -108,7 +109,7 @@ fn unoptimized() {
                     value_flow.set(value_flow_next.clone());
                     memory_alias.set(memory_alias_next.clone());
 
-                    (value_flow_next.leave(), memory_alias_next.leave(), value_alias_next.leave())
+                    (value_flow_next.leave(&outer), memory_alias_next.leave(&outer), value_alias_next.leave(&outer))
                 });
 
                 value_flow.map(|_| ()).consolidate().inspect(|x| println!("VF: {:?}", x));
@@ -174,6 +175,7 @@ fn optimized() {
 
             let dereference = dereference.arrange::<ValBatcher<_,_,_,_>, ValBuilder<_,_,_,_>, ValSpine<_,_,_,_>>();
 
+            let outer = scope.clone();
             let (value_flow, memory_alias) =
             scope
                 .iterative::<Iter,_,_>(|scope| {
@@ -233,7 +235,7 @@ fn optimized() {
                     value_flow.set(value_flow_next.clone());
                     memory_alias.set(memory_alias_next.clone());
 
-                    (value_flow_next.leave(), memory_alias_next.leave())
+                    (value_flow_next.leave(&outer), memory_alias_next.leave(&outer))
                 });
 
                 value_flow.map(|_| ()).consolidate().inspect(|x| println!("VF: {:?}", x));
diff --git a/interactive/src/plan/sfw.rs b/interactive/src/plan/sfw.rs
index 6a5c82fc8..c4a8a44a0 100644
--- a/interactive/src/plan/sfw.rs
+++ b/interactive/src/plan/sfw.rs
@@ -231,6 +231,7 @@ impl<V: ExchangeData+Hash+Datum> Render for MultiwayJoin<V> {
             use differential_dogs3::altneu::AltNeu;
 
             let scope_name = format!("DeltaRule: {}/{}", index, self.sources.len());
+            let outer = scope.clone();
             let changes = scope.clone().scoped::<AltNeu<_>,_,_>(&scope_name, |inner| {
 
                 // This should default to an `AltNeu::Alt` timestamp.
@@ -288,7 +289,7 @@ impl<V: ExchangeData+Hash+Datum> Render for MultiwayJoin<V> {
 
                 changes
                     .map(move |tuple| extract_map.iter().map(|&i| tuple[i].clone()).collect::<Vec<_>>())
-                    .leave()
+                    .leave(&outer)
             });
 
             accumulated_changes.push(changes);
diff --git a/mdbook/src/chapter_2/chapter_2_7.md b/mdbook/src/chapter_2/chapter_2_7.md
index def1c4dcd..4692fc007 100644
--- a/mdbook/src/chapter_2/chapter_2_7.md
+++ b/mdbook/src/chapter_2/chapter_2_7.md
@@ -90,19 +90,20 @@ As an example, the implementation of the `iterate` operator looks something like
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::operators::{Iterate, iterate::VecVariable};
 # use differential_dataflow::lattice::Lattice;
-# fn logic<'a, G: Scope>(collection: VecCollection<Child<'a, G, G::Timestamp>, (u64, u64), isize>) -> VecCollection<Child<'a, G, G::Timestamp>, (u64, u64)>
+# fn logic<'a, G: Scope>(collection: VecCollection<Child<'a, G::Allocator, G::Timestamp>, (u64, u64), isize>) -> VecCollection<Child<'a, G::Allocator, G::Timestamp>, (u64, u64)>
 # where G::Timestamp: Lattice
 # {
 #     collection
 # }
-# fn example<'a, G: Scope<Timestamp=u64>>(collection: VecCollection<G, (u64, u64)>) //, logic: impl Fn(&VecVariable<Child<'a, G, G::Timestamp>, (u64, u64), isize>) -> VecCollection<Child<'a, G, G::Timestamp>, (u64, u64)>)
+# fn example<'a, G: Scope<Timestamp=u64>>(collection: VecCollection<G, (u64, u64)>) //, logic: impl Fn(&VecVariable<Child<'a, G::Allocator, G::Timestamp>, (u64, u64), isize>) -> VecCollection<Child<'a, G::Allocator, G::Timestamp>, (u64, u64)>)
 #    where G::Timestamp: Lattice
 # {
-    collection.scope().scoped("inner", |subgraph| {
+    let outer = collection.scope();
+    outer.scoped::<u64,_,_>("inner", |subgraph| {
         let (variable, collection) = VecVariable::new_from(collection.enter(subgraph), 1);
-        let result = logic(collection);
+        let result = logic::<G>(collection);
         variable.set(result.clone());
-        result.leave()
+        result.leave(&outer)
     });
 # }
 ```
diff --git a/server/src/lib.rs b/server/src/lib.rs
index 745de0bb9..d13579876 100644
--- a/server/src/lib.rs
+++ b/server/src/lib.rs
@@ -6,7 +6,6 @@ use std::time::Instant;
 use libloading::Library;
 
 use timely::communication::Allocator;
-use timely::worker::Worker;
 use timely::dataflow::scopes::Child;
 use timely::dataflow::operators::probe::Handle as ProbeHandle;
 
@@ -21,7 +20,7 @@ pub type TraceHandle = TraceAgent<TraceSpine>;
 
 /// Arguments provided to each shared library to help build their dataflows and register their results.
 pub type Environment<'a, 'b> = (
-    &'a mut Child<'b, Worker<Allocator>,usize>,
+    &'a mut Child<'b, Allocator, usize>,
     &'a mut TraceHandler,
     &'a mut ProbeHandle<RootTime>,
     &'a Instant,

From da1698bc7ef100e583787d8e6e5f982007b94e31 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Wed, 8 Apr 2026 23:27:02 -0400
Subject: [PATCH 02/13] Tidy bounds

---
 differential-dataflow/src/collection.rs |  8 ++++----
 differential-dataflow/src/input.rs      | 18 +++++++++---------
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/differential-dataflow/src/collection.rs b/differential-dataflow/src/collection.rs
index 1201474de..e5016ccd4 100644
--- a/differential-dataflow/src/collection.rs
+++ b/differential-dataflow/src/collection.rs
@@ -109,7 +109,7 @@ impl<G: Scope, C: Container> Collection<G, C> {
     ///
     /// This method is a specialization of `enter` to the case where the nested scope is a region.
     /// It removes the need for an operator that adjusts the timestamp.
-    pub fn enter_region<'a>(self, child: &Child<'a, G::Allocator, <G as Scope>::Timestamp>) -> Collection<Child<'a, G::Allocator, <G as Scope>::Timestamp>, C> {
+    pub fn enter_region<'a>(self, child: &Child<'a, G::Allocator, G::Timestamp>) -> Collection<Child<'a, G::Allocator, G::Timestamp>, C> {
         self.inner
             .enter(child)
             .as_collection()
@@ -216,10 +216,10 @@ impl<G: Scope, C: Container> Collection<G, C> {
     ///     data.assert_eq(result);
     /// });
     /// ```
-    pub fn enter<'a, T>(self, child: &Child<'a, G::Allocator, T>) -> Collection<Child<'a, G::Allocator, T>, <C as containers::Enter<<G as Scope>::Timestamp, T>>::InnerContainer>
+    pub fn enter<'a, T>(self, child: &Child<'a, G::Allocator, T>) -> Collection<Child<'a, G::Allocator, T>, <C as containers::Enter<G::Timestamp, T>>::InnerContainer>
     where
-        C: containers::Enter<<G as Scope>::Timestamp, T, InnerContainer: Container>,
-        T: Refines<<G as Scope>::Timestamp>,
+        C: containers::Enter<G::Timestamp, T, InnerContainer: Container>,
+        T: Refines<G::Timestamp>,
     {
         use timely::dataflow::channels::pact::Pipeline;
         self.inner
diff --git a/differential-dataflow/src/input.rs b/differential-dataflow/src/input.rs
index 2d669fb4f..024aeb10d 100644
--- a/differential-dataflow/src/input.rs
+++ b/differential-dataflow/src/input.rs
@@ -41,7 +41,7 @@ pub trait Input : TimelyInput {
     ///
     /// }).unwrap();
     /// ```
-    fn new_collection<D, R>(&mut self) -> (InputSession<<Self as Scope>::Timestamp, D, R>, VecCollection<Self, D, R>)
+    fn new_collection<D, R>(&mut self) -> (InputSession<Self::Timestamp, D, R>, VecCollection<Self, D, R>)
     where D: Data, R: Semigroup+'static;
     /// Create a new collection and input handle from initial data.
     ///
@@ -67,7 +67,7 @@ pub trait Input : TimelyInput {
     ///
     /// }).unwrap();
     /// ```
-    fn new_collection_from<I>(&mut self, data: I) -> (InputSession<<Self as Scope>::Timestamp, I::Item, isize>, VecCollection<Self, I::Item, isize>)
+    fn new_collection_from<I>(&mut self, data: I) -> (InputSession<Self::Timestamp, I::Item, isize>, VecCollection<Self, I::Item, isize>)
     where I: IntoIterator<Item: Data> + 'static;
     /// Create a new collection and input handle from initial data.
     ///
@@ -93,28 +93,28 @@ pub trait Input : TimelyInput {
     ///
     /// }).unwrap();
     /// ```
-    fn new_collection_from_raw<D, R, I>(&mut self, data: I) -> (InputSession<<Self as Scope>::Timestamp, D, R>, VecCollection<Self, D, R>)
-    where I: IntoIterator<Item=(D,<Self as Scope>::Timestamp,R)>+'static, D: Data, R: Semigroup+'static;
+    fn new_collection_from_raw<D, R, I>(&mut self, data: I) -> (InputSession<Self::Timestamp, D, R>, VecCollection<Self, D, R>)
+    where I: IntoIterator<Item=(D,Self::Timestamp,R)>+'static, D: Data, R: Semigroup+'static;
 }
 
 use crate::lattice::Lattice;
-impl<G: TimelyInput> Input for G where <G as Scope>::Timestamp: Lattice {
-    fn new_collection<D, R>(&mut self) -> (InputSession<<G as Scope>::Timestamp, D, R>, VecCollection<G, D, R>)
+impl<G: TimelyInput> Input for G where G::Timestamp: Lattice {
+    fn new_collection<D, R>(&mut self) -> (InputSession<G::Timestamp, D, R>, VecCollection<G, D, R>)
     where
         D: Data, R: Semigroup+'static,
     {
         let (handle, stream) = self.new_input();
         (InputSession::from(handle), stream.as_collection())
     }
-    fn new_collection_from<I>(&mut self, data: I) -> (InputSession<<G as Scope>::Timestamp, I::Item, isize>, VecCollection<G, I::Item, isize>)
+    fn new_collection_from<I>(&mut self, data: I) -> (InputSession<G::Timestamp, I::Item, isize>, VecCollection<G, I::Item, isize>)
     where I: IntoIterator+'static, I::Item: Data {
         self.new_collection_from_raw(data.into_iter().map(|d| (d, <G::Timestamp as timely::progress::Timestamp>::minimum(), 1)))
     }
-    fn new_collection_from_raw<D,R,I>(&mut self, data: I) -> (InputSession<<G as Scope>::Timestamp, D, R>, VecCollection<G, D, R>)
+    fn new_collection_from_raw<D,R,I>(&mut self, data: I) -> (InputSession<G::Timestamp, D, R>, VecCollection<G, D, R>)
     where
         D: Data,
         R: Semigroup+'static,
-        I: IntoIterator<Item=(D,<Self as Scope>::Timestamp,R)>+'static,
+        I: IntoIterator<Item=(D,Self::Timestamp,R)>+'static,
     {
         use timely::dataflow::operators::ToStream;
 

From 8e9ae63351f4752127937a7c4ed09807d7f5b487 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Thu, 9 Apr 2026 09:21:52 -0400
Subject: [PATCH 03/13] Absorb next wave of changes

---
 Cargo.toml                                    |   4 +-
 diagnostics/src/logging.rs                    |  56 ++++---
 differential-dataflow/examples/bfs.rs         |   2 +-
 .../examples/columnar/columnar_support.rs     |  23 ++-
 .../examples/columnar/main.rs                 |  10 +-
 differential-dataflow/examples/dynamic.rs     |   2 +-
 differential-dataflow/examples/graspan.rs     |  12 +-
 differential-dataflow/examples/interpreted.rs |   2 +-
 .../examples/iterate_container.rs             |   2 +-
 differential-dataflow/examples/monoid-bfs.rs  |   2 +-
 differential-dataflow/examples/pagerank.rs    |   2 +-
 differential-dataflow/examples/progress.rs    |   8 +-
 .../examples/stackoverflow.rs                 |   2 +-
 .../src/algorithms/graphs/bfs.rs              |   8 +-
 .../src/algorithms/graphs/bijkstra.rs         |   8 +-
 .../src/algorithms/graphs/propagate.rs        |  10 +-
 .../src/algorithms/graphs/scc.rs              |   6 +-
 .../src/algorithms/graphs/sequential.rs       |   6 +-
 .../src/algorithms/identifiers.rs             |   6 +-
 .../src/algorithms/prefix_sum.rs              |  10 +-
 differential-dataflow/src/capture.rs          |  16 +-
 differential-dataflow/src/collection.rs       | 145 +++++++++---------
 differential-dataflow/src/dynamic/mod.rs      |   4 +-
 differential-dataflow/src/input.rs            |  25 +--
 differential-dataflow/src/logging.rs          |   3 +-
 .../src/operators/arrange/agent.rs            |  19 +--
 .../src/operators/arrange/arrangement.rs      |  77 +++++-----
 .../src/operators/arrange/upsert.rs           |  21 +--
 differential-dataflow/src/operators/count.rs  |  14 +-
 .../src/operators/iterate.rs                  |  28 ++--
 differential-dataflow/src/operators/join.rs   |  16 +-
 differential-dataflow/src/operators/reduce.rs |  29 ++--
 .../src/operators/threshold.rs                |  16 +-
 differential-dataflow/tests/bfs.rs            |   2 +-
 differential-dataflow/tests/scc.rs            |   6 +-
 dogsdogsdogs/examples/ngo.rs                  |   4 +-
 dogsdogsdogs/src/calculus.rs                  |  20 +--
 dogsdogsdogs/src/lib.rs                       |  16 +-
 dogsdogsdogs/src/operators/count.rs           |   6 +-
 dogsdogsdogs/src/operators/half_join.rs       |  41 ++---
 dogsdogsdogs/src/operators/half_join2.rs      |  37 +++--
 dogsdogsdogs/src/operators/lookup_map.rs      |   9 +-
 dogsdogsdogs/src/operators/propose.rs         |  10 +-
 dogsdogsdogs/src/operators/validate.rs        |   6 +-
 experiments/Cargo.toml                        |   2 +-
 experiments/src/bin/deals-interactive.rs      |   7 +-
 experiments/src/bin/deals.rs                  |   7 +-
 experiments/src/bin/graphs-interactive-alt.rs |  16 +-
 .../src/bin/graphs-interactive-neu-zwei.rs    |  11 +-
 experiments/src/bin/graphs-interactive-neu.rs |  11 +-
 experiments/src/bin/graphs-interactive.rs     |  11 +-
 experiments/src/bin/graphs-static.rs          |  18 +--
 experiments/src/bin/graphs.rs                 |  16 +-
 interactive/src/command.rs                    |   3 +-
 interactive/src/logging.rs                    |  11 +-
 interactive/src/manager.rs                    |   3 +-
 interactive/src/plan/concat.rs                |   6 +-
 interactive/src/plan/filter.rs                |   8 +-
 interactive/src/plan/join.rs                  |   8 +-
 interactive/src/plan/map.rs                   |   8 +-
 interactive/src/plan/mod.rs                   |  17 +-
 interactive/src/plan/sfw.rs                   |   8 +-
 mdbook/src/chapter_2/chapter_2_1.md           |  10 +-
 mdbook/src/chapter_2/chapter_2_2.md           |   5 +-
 mdbook/src/chapter_2/chapter_2_3.md           |   5 +-
 mdbook/src/chapter_2/chapter_2_4.md           |  10 +-
 mdbook/src/chapter_2/chapter_2_5.md           |   5 +-
 mdbook/src/chapter_2/chapter_2_6.md           |   5 +-
 mdbook/src/chapter_2/chapter_2_7.md           |  20 +--
 server/Cargo.toml                             |   2 +-
 server/src/lib.rs                             |   7 +-
 71 files changed, 483 insertions(+), 508 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 895c0407e..f1a2b61a1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,8 +25,8 @@ rust-version = "1.86"
 differential-dataflow = { path = "differential-dataflow", default-features = false, version = "0.22.0" }
 #timely = { version = "0.28", default-features = false }
 columnar = { version = "0.12", default-features = false }
-timely = { git = "https://github.com/TimelyDataflow/timely-dataflow" }
-#timely = { path = "../timely-dataflow/timely/", default-features = false }
+#timely = { git = "https://github.com/TimelyDataflow/timely-dataflow" }
+timely = { path = "../timely-dataflow/timely/", default-features = false }
 
 [workspace.lints.clippy]
 type_complexity = "allow"
diff --git a/diagnostics/src/logging.rs b/diagnostics/src/logging.rs
index b47721e62..f0fac8d2b 100644
--- a/diagnostics/src/logging.rs
+++ b/diagnostics/src/logging.rs
@@ -34,7 +34,6 @@ use differential_dataflow::operators::arrange::TraceAgent;
 use differential_dataflow::trace::implementations::{KeySpine, ValSpine};
 use differential_dataflow::{AsCollection, VecCollection};
 
-use timely::communication::Allocate;
 use timely::container::CapacityContainerBuilder;
 use timely::dataflow::channels::pact::Pipeline;
 use timely::dataflow::operators::capture::{Event, EventLink, Replay, Capture};
@@ -244,12 +243,11 @@ fn quantize(time: Duration, interval: Duration) -> Duration {
 }
 
 /// Quantize timestamps in a collection's inner stream.
-fn quantize_collection<S, D>(
-    collection: VecCollection<S, D, i64>,
+fn quantize_collection<D>(
+    collection: VecCollection<Duration, D, i64>,
     interval: Duration,
-) -> VecCollection<S, D, i64>
+) -> VecCollection<Duration, D, i64>
 where
-    S: Scope<Timestamp = Duration>,
     D: differential_dataflow::Data,
 {
     collection
@@ -276,7 +274,7 @@ where
 ///
 /// Returns a [`LoggingState`] with trace handles and a [`SinkHandle`] for
 /// the WebSocket thread.
-pub fn register<A: Allocate>(worker: &mut Worker<A>, log_logging: bool) -> LoggingState {
+pub fn register(worker: &mut Worker, log_logging: bool) -> LoggingState {
     let start = Instant::now();
 
     // Event links for logging capture (worker-internal, Rc-based).
@@ -377,8 +375,8 @@ pub fn register<A: Allocate>(worker: &mut Worker<A>, log_logging: bool) -> Loggi
     }
 }
 
-fn install_loggers<A: Allocate>(
-    worker: &mut Worker<A>,
+fn install_loggers(
+    worker: &mut Worker,
     t_link: Rc<EventLink<Duration, Vec<(Duration, TimelyEvent)>>>,
     d_link: Rc<EventLink<Duration, Vec<(Duration, DifferentialEvent)>>>,
 ) {
@@ -402,11 +400,11 @@ fn install_loggers<A: Allocate>(
 // ============================================================================
 
 /// Internal: collections before arrangement, used for the cross-join.
-struct TimelyCollections<S: Scope> {
-    operators: VecCollection<S, (usize, String, Vec<usize>), i64>,
-    channels: VecCollection<S, (usize, Vec<usize>, (usize, usize), (usize, usize)), i64>,
-    elapsed: VecCollection<S, usize, i64>,
-    messages: VecCollection<S, usize, i64>,
+struct TimelyCollections {
+    operators: VecCollection<Duration, (usize, String, Vec<usize>), i64>,
+    channels: VecCollection<Duration, (usize, Vec<usize>, (usize, usize), (usize, usize)), i64>,
+    elapsed: VecCollection<Duration, usize, i64>,
+    messages: VecCollection<Duration, usize, i64>,
 }
 
 #[derive(Default)]
@@ -416,10 +414,10 @@ struct TimelyDemuxState {
 }
 
 /// Build timely logging collections and arrangements.
-fn construct_timely<S: Scope<Timestamp = Duration>>(
-    scope: &mut S,
-    stream: Stream<S, Vec<(Duration, TimelyEvent)>>,
-) -> (TimelyTraces, TimelyCollections<S>) {
+fn construct_timely(
+    scope: &mut Scope<Duration>,
+    stream: Stream<Duration, Vec<(Duration, TimelyEvent)>>,
+) -> (TimelyTraces, TimelyCollections) {
     type OpUpdate = ((usize, String, Vec<usize>), Duration, i64);
     type ChUpdate = ((usize, Vec<usize>, (usize, usize), (usize, usize)), Duration, i64);
     type ElUpdate = (usize, Duration, i64);
@@ -536,21 +534,21 @@ fn construct_timely<S: Scope<Timestamp = Duration>>(
 // ============================================================================
 
 /// Internal: collections before arrangement, used for the cross-join.
-struct DifferentialCollections<S: Scope> {
-    arrangement_batches: VecCollection<S, usize, i64>,
-    arrangement_records: VecCollection<S, usize, i64>,
-    sharing: VecCollection<S, usize, i64>,
-    batcher_records: VecCollection<S, usize, i64>,
-    batcher_size: VecCollection<S, usize, i64>,
-    batcher_capacity: VecCollection<S, usize, i64>,
-    batcher_allocations: VecCollection<S, usize, i64>,
+struct DifferentialCollections {
+    arrangement_batches: VecCollection<Duration, usize, i64>,
+    arrangement_records: VecCollection<Duration, usize, i64>,
+    sharing: VecCollection<Duration, usize, i64>,
+    batcher_records: VecCollection<Duration, usize, i64>,
+    batcher_size: VecCollection<Duration, usize, i64>,
+    batcher_capacity: VecCollection<Duration, usize, i64>,
+    batcher_allocations: VecCollection<Duration, usize, i64>,
 }
 
 /// Build differential logging collections and arrangements.
-fn construct_differential<S: Scope<Timestamp = Duration>>(
-    scope: &mut S,
-    stream: Stream<S, Vec<(Duration, DifferentialEvent)>>,
-) -> (DifferentialTraces, DifferentialCollections<S>) {
+fn construct_differential(
+    scope: &mut Scope<Duration>,
+    stream: Stream<Duration, Vec<(Duration, DifferentialEvent)>>,
+) -> (DifferentialTraces, DifferentialCollections) {
     type Update = (usize, Duration, i64);
 
     let mut demux = OperatorBuilder::new("Differential Demux".to_string(), scope.clone());
diff --git a/differential-dataflow/examples/bfs.rs b/differential-dataflow/examples/bfs.rs
index af875d5d5..5c78c938b 100644
--- a/differential-dataflow/examples/bfs.rs
+++ b/differential-dataflow/examples/bfs.rs
@@ -93,7 +93,7 @@ fn main() {
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
 fn bfs<G>(edges: VecCollection<G, Edge>, roots: VecCollection<G, Node>) -> VecCollection<G, (Node, u32)>
 where
-    G: Scope<Timestamp: Lattice+Ord>,
+    G: timely::progress::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/columnar_support.rs b/differential-dataflow/examples/columnar/columnar_support.rs
index 8b6e10543..825bd2a97 100644
--- a/differential-dataflow/examples/columnar/columnar_support.rs
+++ b/differential-dataflow/examples/columnar/columnar_support.rs
@@ -1839,13 +1839,12 @@ pub mod updates {
 /// joins output times with input times, multiplies output diffs with input diffs.
 ///
 /// This subsumes map, filter, negate, and enter_at for columnar collections.
-pub fn join_function<G, U, I, L>(
-    input: differential_dataflow::Collection<G, RecordedUpdates<U>>,
+pub fn join_function<U, I, L>(
+    input: differential_dataflow::Collection<U::Time, RecordedUpdates<U>>,
     mut logic: L,
-) -> differential_dataflow::Collection<G, RecordedUpdates<U>>
+) -> differential_dataflow::Collection<U::Time, RecordedUpdates<U>>
 where
-    G: timely::dataflow::Scope,
-    G::Timestamp: differential_dataflow::lattice::Lattice,
+    U::Time: differential_dataflow::lattice::Lattice,
     U: layout::ColumnarUpdate<Diff: differential_dataflow::difference::Multiply<U::Diff, Output = U::Diff>>,
     I: IntoIterator<Item = (U::Key, U::Val, U::Time, U::Diff)>,
     L: FnMut(
@@ -1893,12 +1892,11 @@ type DynTime = timely::order::Product<u64, differential_dataflow::dynamic::point
 /// that tells timely how the PointStamp is affected (retain `level - 1` coordinates).
 ///
 /// Consolidates after truncation since distinct PointStamp coordinates can collapse.
-pub fn leave_dynamic<G, K, V, R>(
-    input: differential_dataflow::Collection<G, RecordedUpdates<(K, V, DynTime, R)>>,
+pub fn leave_dynamic<K, V, R>(
+    input: differential_dataflow::Collection<DynTime, RecordedUpdates<(K, V, DynTime, R)>>,
     level: usize,
-) -> differential_dataflow::Collection<G, RecordedUpdates<(K, V, DynTime, R)>>
+) -> differential_dataflow::Collection<DynTime, RecordedUpdates<(K, V, DynTime, R)>>
 where
-    G: timely::dataflow::Scope<Timestamp = DynTime>,
     K: columnar::Columnar,
     V: columnar::Columnar,
     R: columnar::Columnar,
@@ -1972,14 +1970,13 @@ where
 ///
 /// Cursors through each batch and pushes `(key, val, time, diff)` refs into
 /// a `ValColBuilder`, which sorts and consolidates on flush.
-pub fn as_recorded_updates<G, U>(
+pub fn as_recorded_updates<U>(
     arranged: differential_dataflow::operators::arrange::Arranged<
-        G,
+        U::Time,
         differential_dataflow::operators::arrange::TraceAgent<ValSpine<U::Key, U::Val, U::Time, U::Diff>>,
     >,
-) -> differential_dataflow::Collection<G, RecordedUpdates<U>>
+) -> differential_dataflow::Collection<U::Time, RecordedUpdates<U>>
 where
-    G: timely::dataflow::Scope<Timestamp = U::Time>,
     U: layout::ColumnarUpdate,
 {
     use timely::dataflow::operators::generic::Operator;
diff --git a/differential-dataflow/examples/columnar/main.rs b/differential-dataflow/examples/columnar/main.rs
index 66db2fc4e..9d58f154d 100644
--- a/differential-dataflow/examples/columnar/main.rs
+++ b/differential-dataflow/examples/columnar/main.rs
@@ -110,10 +110,10 @@ mod reachability {
     /// Compute the set of nodes reachable from `roots` along directed `edges`.
     ///
     /// Returns `(node, ())` for each reachable node.
-    pub fn reach<G: Scope<Timestamp = Time>>(
-        edges: Collection<G, RecordedUpdates<(Node, Node, Time, Diff)>>,
-        roots: Collection<G, RecordedUpdates<(Node, (), Time, Diff)>>,
-    ) -> Collection<G, RecordedUpdates<(Node, (), Time, Diff)>>
+    pub fn reach(
+        edges: Collection<Time, RecordedUpdates<(Node, Node, Time, Diff)>>,
+        roots: Collection<Time, RecordedUpdates<(Node, (), Time, Diff)>>,
+    ) -> Collection<Time, RecordedUpdates<(Node, (), Time, Diff)>>
     {
         let outer = edges.inner.scope();
 
@@ -181,7 +181,7 @@ mod reachability {
             });
 
             // Extract RecordedUpdates from the Arranged's batch stream.
-            let result_col = as_recorded_updates::<_, (Node, (), IterTime, Diff)>(result);
+            let result_col = as_recorded_updates::<(Node, (), IterTime, Diff)>(result);
 
             variable.set(result_col.clone());
 
diff --git a/differential-dataflow/examples/dynamic.rs b/differential-dataflow/examples/dynamic.rs
index 35dbac8ba..345f40ab4 100644
--- a/differential-dataflow/examples/dynamic.rs
+++ b/differential-dataflow/examples/dynamic.rs
@@ -93,7 +93,7 @@ fn main() {
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
 fn bfs<G>(edges: VecCollection<G, Edge>, roots: VecCollection<G, Node>) -> VecCollection<G, (Node, u32)>
 where
-    G: Scope<Timestamp: Lattice+Ord>,
+    G: timely::progress::Timestamp + Lattice + Ord,
 {
     use timely::order::Product;
     use iterate::Variable;
diff --git a/differential-dataflow/examples/graspan.rs b/differential-dataflow/examples/graspan.rs
index 41d82e195..9de864eba 100644
--- a/differential-dataflow/examples/graspan.rs
+++ b/differential-dataflow/examples/graspan.rs
@@ -68,7 +68,7 @@ use differential_dataflow::operators::arrange::{Arranged, TraceAgent};
 
 type TraceKeyHandle<K,T,R> = TraceAgent<KeySpine<K, T, R>>;
 type TraceValHandle<K,V,T,R> = TraceAgent<ValSpine<K, V, T, R>>;
-type Arrange<G,K,V,R> = Arranged<G, TraceValHandle<K, V, <G as Scope>::Timestamp, R>>;
+type Arrange<G,K,V,R> = Arranged<G, TraceValHandle<K, V, G, R>>;
 
 /// An evolving set of edges.
 ///
@@ -78,7 +78,7 @@ type Arrange<G,K,V,R> = Arranged<G, TraceValHandle<K, V, <G as Scope>::Timestamp
 ///
 /// 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<Timestamp: Lattice>> {
+pub struct EdgeVariable<G: Timestamp + Lattice> {
     variable: VecVariable<G, Edge, Diff>,
     collection: VecCollection<G, Edge, Diff>,
     current: VecCollection<G, Edge, Diff>,
@@ -86,9 +86,9 @@ pub struct EdgeVariable<G: Scope<Timestamp: Lattice>> {
     reverse: Option<Arrange<G, Node, Node, Diff>>,
 }
 
-impl<G: Scope<Timestamp: Lattice>> EdgeVariable<G> {
+impl<G: Timestamp + Lattice> EdgeVariable<G> {
     /// Creates a new variable initialized with `source`.
-    pub fn from(source: VecCollection<G, Edge>, step: <G::Timestamp as Timestamp>::Summary) -> Self {
+    pub fn from(source: VecCollection<G, Edge>, step: <G as Timestamp>::Summary) -> Self {
         let (variable, collection) = VecVariable::new(&mut source.scope(), step);
         EdgeVariable {
             variable,
@@ -150,9 +150,9 @@ impl Query {
     }
 
     /// Creates a dataflow implementing the query, and returns input and trace handles.
-    pub fn render_in<G>(&self, scope: &mut G) -> BTreeMap<String, RelationHandles<G::Timestamp>>
+    pub fn render_in<G>(&self, scope: &mut Scope<G>) -> BTreeMap<String, RelationHandles<G>>
     where
-        G: Scope<Timestamp: Lattice+::timely::order::TotalOrder>,
+        G: Timestamp + Lattice + ::timely::order::TotalOrder,
     {
         // Create new input (handle, stream) pairs
         let mut input_map = BTreeMap::new();
diff --git a/differential-dataflow/examples/interpreted.rs b/differential-dataflow/examples/interpreted.rs
index 4c6e3429c..b087af00d 100644
--- a/differential-dataflow/examples/interpreted.rs
+++ b/differential-dataflow/examples/interpreted.rs
@@ -39,7 +39,7 @@ fn main() {
 
 fn interpret<G>(edges: VecCollection<G, Edge>, relations: &[(usize, usize)]) -> VecCollection<G, Vec<Node>>
 where
-    G: Scope<Timestamp: Lattice+Hash+Ord>,
+    G: timely::progress::Timestamp + Lattice + Hash + Ord,
 {
 
     // arrange the edge relation three ways.
diff --git a/differential-dataflow/examples/iterate_container.rs b/differential-dataflow/examples/iterate_container.rs
index 0a45fd7ab..b2b6daf97 100644
--- a/differential-dataflow/examples/iterate_container.rs
+++ b/differential-dataflow/examples/iterate_container.rs
@@ -33,7 +33,7 @@ impl<C: ResultsIn<TS>, TS> ResultsIn<TS> for ContainerWrapper<C> {
     #[inline(always)] fn results_in(self, step: &TS) -> Self { ContainerWrapper(self.0.results_in(step)) }
 }
 
-fn wrap<G: Scope, C: timely::Container>(stream: Stream<G, C>) -> Stream<G, ContainerWrapper<C>> {
+fn wrap<G: timely::progress::Timestamp, C: timely::Container>(stream: Stream<G, C>) -> Stream<G, ContainerWrapper<C>> {
     let mut builder = OperatorBuilder::new("Wrap".to_string(), stream.scope());
     let (mut output, stream_out) = builder.new_output();
     let mut input = builder.new_input(stream, Pipeline);
diff --git a/differential-dataflow/examples/monoid-bfs.rs b/differential-dataflow/examples/monoid-bfs.rs
index 00ce5f998..9400a1cdd 100644
--- a/differential-dataflow/examples/monoid-bfs.rs
+++ b/differential-dataflow/examples/monoid-bfs.rs
@@ -124,7 +124,7 @@ fn main() {
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
 fn bfs<G>(edges: VecCollection<G, Edge, MinSum>, roots: VecCollection<G, Node, MinSum>) -> VecCollection<G, Node, MinSum>
 where
-    G: Scope<Timestamp: Lattice+Ord>,
+    G: timely::progress::Timestamp + Lattice + Ord,
 {
     // repeatedly update minimal distances each node can be reached from each root
     let outer = roots.scope();
diff --git a/differential-dataflow/examples/pagerank.rs b/differential-dataflow/examples/pagerank.rs
index caf0e5822..2764dab23 100644
--- a/differential-dataflow/examples/pagerank.rs
+++ b/differential-dataflow/examples/pagerank.rs
@@ -79,7 +79,7 @@ fn main() {
 // to its PageRank in the input graph `edges`.
 fn pagerank<G>(iters: Iter, edges: VecCollection<G, Edge, Diff>) -> VecCollection<G, Node, Diff>
 where
-    G: Scope<Timestamp: Lattice>,
+    G: timely::progress::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 634e43d56..138de0c86 100644
--- a/differential-dataflow/examples/progress.rs
+++ b/differential-dataflow/examples/progress.rs
@@ -120,7 +120,7 @@ fn frontier<G, T>(
     times: VecCollection<G, (Location, T)>,
 ) -> VecCollection<G, (Location, T)>
 where
-    G: Scope<Timestamp: Lattice+Ord>,
+    G: Timestamp + Lattice + Ord,
     T: Timestamp<Summary: differential_dataflow::ExchangeData>+std::hash::Hash,
 {
     // Translate node and edge transitions into a common Location to Location edge with an associated Summary.
@@ -154,7 +154,7 @@ fn summarize<G, T>(
     edges: VecCollection<G, (Source, Target)>,
 ) -> VecCollection<G, (Location, (Location, T::Summary))>
 where
-    G: Scope<Timestamp: Lattice+Ord>,
+    G: Timestamp + Lattice + Ord,
     T: Timestamp<Summary: differential_dataflow::ExchangeData+std::hash::Hash>,
 {
     // Start from trivial reachability from each input to itself.
@@ -194,12 +194,12 @@ where
 
 
 /// Identifies cycles along paths that do not increment timestamps.
-fn find_cycles<G: Scope, T: Timestamp>(
+fn find_cycles<G: Timestamp, T: Timestamp>(
     nodes: VecCollection<G, (Target, Source, T::Summary)>,
     edges: VecCollection<G, (Source, Target)>,
 ) -> VecCollection<G, (Location, Location)>
 where
-    G: Scope<Timestamp: Lattice+Ord>,
+    G: Timestamp + Lattice + Ord,
     T: Timestamp<Summary: differential_dataflow::ExchangeData>,
 {
     // Retain node connections along "default" timestamp summaries.
diff --git a/differential-dataflow/examples/stackoverflow.rs b/differential-dataflow/examples/stackoverflow.rs
index 3fe521ee2..c88e7ea6f 100644
--- a/differential-dataflow/examples/stackoverflow.rs
+++ b/differential-dataflow/examples/stackoverflow.rs
@@ -107,7 +107,7 @@ fn main() {
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
 fn bfs<G>(edges: VecCollection<G, Edge>, roots: VecCollection<G, Node>) -> VecCollection<G, (Node, u32)>
 where
-    G: Scope<Timestamp: Lattice+Ord>,
+    G: timely::progress::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 1513622bd..79ff15e45 100644
--- a/differential-dataflow/src/algorithms/graphs/bfs.rs
+++ b/differential-dataflow/src/algorithms/graphs/bfs.rs
@@ -2,7 +2,7 @@
 
 use std::hash::Hash;
 
-use timely::dataflow::*;
+use timely::progress::Timestamp;
 
 use crate::{VecCollection, ExchangeData};
 use crate::operators::*;
@@ -11,7 +11,7 @@ use crate::lattice::Lattice;
 /// Returns pairs (node, dist) indicating distance of each node from a root.
 pub fn bfs<G, N>(edges: VecCollection<G, (N,N)>, roots: VecCollection<G, N>) -> VecCollection<G, (N,u32)>
 where
-    G: Scope<Timestamp: Lattice+Ord>,
+    G: Timestamp + Lattice + Ord,
     N: ExchangeData+Hash,
 {
     let edges = edges.arrange_by_key();
@@ -24,9 +24,9 @@ use crate::operators::arrange::Arranged;
 /// Returns pairs (node, dist) indicating distance of each node from a root.
 pub fn bfs_arranged<G, N, Tr>(edges: Arranged<G, Tr>, roots: VecCollection<G, N>) -> VecCollection<G, (N, u32)>
 where
-    G: Scope<Timestamp=Tr::Time>,
+    G: Timestamp + Lattice + Ord,
     N: ExchangeData+Hash,
-    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Diff=isize>+Clone+'static,
+    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Time=G, Diff=isize>+Clone+'static,
 {
     // initialize roots as reaching themselves at distance 0
     let nodes = roots.map(|x| (x, 0));
diff --git a/differential-dataflow/src/algorithms/graphs/bijkstra.rs b/differential-dataflow/src/algorithms/graphs/bijkstra.rs
index bfc5d7606..4ff6c32a2 100644
--- a/differential-dataflow/src/algorithms/graphs/bijkstra.rs
+++ b/differential-dataflow/src/algorithms/graphs/bijkstra.rs
@@ -3,7 +3,7 @@
 use std::hash::Hash;
 
 use timely::order::Product;
-use timely::dataflow::*;
+use timely::progress::Timestamp;
 
 use crate::{VecCollection, ExchangeData};
 use crate::lattice::Lattice;
@@ -21,7 +21,7 @@ use crate::operators::iterate::Variable;
 /// could be good insurance here.
 pub fn bidijkstra<G, N>(edges: VecCollection<G, (N,N)>, goals: VecCollection<G, (N,N)>) -> VecCollection<G, ((N,N), u32)>
 where
-    G: Scope<Timestamp: Lattice+Ord>,
+    G: Timestamp + Lattice + Ord,
     N: ExchangeData+Hash,
 {
     let forward = edges.clone().arrange_by_key();
@@ -39,9 +39,9 @@ pub fn bidijkstra_arranged<G, N, Tr>(
     goals: VecCollection<G, (N,N)>
 ) -> VecCollection<G, ((N,N), u32)>
 where
-    G: Scope<Timestamp=Tr::Time>,
+    G: Timestamp + Lattice + Ord,
     N: ExchangeData+Hash,
-    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Diff=isize>+Clone+'static,
+    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Time=G, Diff=isize>+Clone+'static,
 {
     let outer = forward.stream.scope();
     outer.iterative::<u64,_,_>(|inner| {
diff --git a/differential-dataflow/src/algorithms/graphs/propagate.rs b/differential-dataflow/src/algorithms/graphs/propagate.rs
index 07692e3bb..e08d788ab 100644
--- a/differential-dataflow/src/algorithms/graphs/propagate.rs
+++ b/differential-dataflow/src/algorithms/graphs/propagate.rs
@@ -2,7 +2,7 @@
 
 use std::hash::Hash;
 
-use timely::dataflow::*;
+use timely::progress::Timestamp;
 
 use crate::{VecCollection, ExchangeData};
 use crate::lattice::Lattice;
@@ -15,7 +15,7 @@ use crate::difference::{Abelian, Multiply};
 /// method to limit the introduction of labels.
 pub fn propagate<G, N, L, R>(edges: VecCollection<G, (N,N), R>, nodes: VecCollection<G,(N,L),R>) -> VecCollection<G,(N,L),R>
 where
-    G: Scope<Timestamp: Lattice+Ord+Hash>,
+    G: Timestamp + Lattice + Ord + Hash,
     N: ExchangeData+Hash,
     R: ExchangeData+Abelian,
     R: Multiply<R, Output=R>,
@@ -32,7 +32,7 @@ where
 /// method to limit the introduction of labels.
 pub fn propagate_at<G, N, L, F, R>(edges: VecCollection<G, (N,N), R>, nodes: VecCollection<G,(N,L),R>, logic: F) -> VecCollection<G,(N,L),R>
 where
-    G: Scope<Timestamp: Lattice+Ord+Hash>,
+    G: Timestamp + Lattice + Ord + Hash,
     N: ExchangeData+Hash,
     R: ExchangeData+Abelian,
     R: Multiply<R, Output=R>,
@@ -53,13 +53,13 @@ use crate::operators::arrange::arrangement::Arranged;
 /// of `logic should be a number in the interval \[0,64\],
 pub fn propagate_core<G, N, L, Tr, F, R>(edges: Arranged<G,Tr>, nodes: VecCollection<G,(N,L),R>, logic: F) -> VecCollection<G,(N,L),R>
 where
-    G: Scope<Timestamp=Tr::Time>,
+    G: Timestamp + Lattice + Ord + Hash,
     N: ExchangeData+Hash,
     R: ExchangeData+Abelian,
     R: Multiply<R, Output=R>,
     R: From<i8>,
     L: ExchangeData,
-    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Time:Hash, Diff=R>+Clone+'static,
+    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Time=G, Diff=R>+Clone+'static,
     F: Fn(&L)->u64+Clone+'static,
 {
     // Morally the code performs the following iterative computation. However, in the interest of a simplified
diff --git a/differential-dataflow/src/algorithms/graphs/scc.rs b/differential-dataflow/src/algorithms/graphs/scc.rs
index bd1eff850..8efaa85c8 100644
--- a/differential-dataflow/src/algorithms/graphs/scc.rs
+++ b/differential-dataflow/src/algorithms/graphs/scc.rs
@@ -3,7 +3,7 @@
 use std::mem;
 use std::hash::Hash;
 
-use timely::dataflow::*;
+use timely::progress::Timestamp;
 
 use crate::{VecCollection, ExchangeData};
 use crate::lattice::Lattice;
@@ -14,7 +14,7 @@ use super::propagate::propagate;
 /// Returns the subset of edges in the same strongly connected component.
 pub fn strongly_connected<G, N, R>(graph: VecCollection<G, (N,N), R>) -> VecCollection<G, (N,N), R>
 where
-    G: Scope<Timestamp: Lattice+Ord+Hash>,
+    G: Timestamp + Lattice + Ord + Hash,
     N: ExchangeData + Hash,
     R: ExchangeData + Abelian,
     R: Multiply<R, Output=R>,
@@ -39,7 +39,7 @@ where
 fn trim_edges<G, N, R>(cycle: VecCollection<G, (N,N), R>, edges: VecCollection<G, (N,N), R>)
     -> VecCollection<G, (N,N), R>
 where
-    G: Scope<Timestamp: Lattice+Ord+Hash>,
+    G: Timestamp + Lattice + Ord + Hash,
     N: ExchangeData + Hash,
     R: ExchangeData + Abelian,
     R: Multiply<R, Output=R>,
diff --git a/differential-dataflow/src/algorithms/graphs/sequential.rs b/differential-dataflow/src/algorithms/graphs/sequential.rs
index 354ad32c2..930e04930 100644
--- a/differential-dataflow/src/algorithms/graphs/sequential.rs
+++ b/differential-dataflow/src/algorithms/graphs/sequential.rs
@@ -2,7 +2,7 @@
 
 use std::hash::Hash;
 
-use timely::dataflow::*;
+use timely::progress::Timestamp;
 
 use crate::{VecCollection, ExchangeData};
 use crate::lattice::Lattice;
@@ -11,7 +11,7 @@ use crate::hashable::Hashable;
 
 fn _color<G, N>(edges: VecCollection<G, (N,N)>) -> VecCollection<G,(N,Option<u32>)>
 where
-    G: Scope<Timestamp: Lattice+Ord+Hash>,
+    G: Timestamp + Lattice + Ord + Hash,
     N: ExchangeData+Hash,
 {
     // need some bogus initial values.
@@ -45,7 +45,7 @@ pub fn sequence<G, N, V, F>(
     edges: VecCollection<G, (N,N)>,
     logic: F) -> VecCollection<G, (N,Option<V>)>
 where
-    G: Scope<Timestamp: Lattice+Hash+Ord>,
+    G: 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 267e4c453..d3dd28fd3 100644
--- a/differential-dataflow/src/algorithms/identifiers.rs
+++ b/differential-dataflow/src/algorithms/identifiers.rs
@@ -1,6 +1,6 @@
 //! Assign unique identifiers to records.
 
-use timely::dataflow::Scope;
+use timely::progress::Timestamp;
 
 use crate::{VecCollection, ExchangeData, Hashable};
 use crate::lattice::Lattice;
@@ -8,7 +8,7 @@ use crate::operators::*;
 use crate::difference::Abelian;
 
 /// Assign unique identifiers to elements of a collection.
-pub trait Identifiers<G: Scope, D: ExchangeData, R: ExchangeData+Abelian> {
+pub trait Identifiers<G: Timestamp, D: ExchangeData, R: ExchangeData+Abelian> {
     /// Assign unique identifiers to elements of a collection.
     ///
     /// # Example
@@ -32,7 +32,7 @@ pub trait Identifiers<G: Scope, D: ExchangeData, R: ExchangeData+Abelian> {
 
 impl<G, D, R> Identifiers<G, D, R> for VecCollection<G, D, R>
 where
-    G: Scope<Timestamp: Lattice>,
+    G: Timestamp + Lattice,
     D: ExchangeData + ::std::hash::Hash,
     R: ExchangeData + Abelian,
 {
diff --git a/differential-dataflow/src/algorithms/prefix_sum.rs b/differential-dataflow/src/algorithms/prefix_sum.rs
index f76f59d9c..39c8d56c3 100644
--- a/differential-dataflow/src/algorithms/prefix_sum.rs
+++ b/differential-dataflow/src/algorithms/prefix_sum.rs
@@ -1,13 +1,13 @@
 //! Implementation of Parallel Prefix Sum
 
-use timely::dataflow::Scope;
+use timely::progress::Timestamp;
 
 use crate::{VecCollection, ExchangeData};
 use crate::lattice::Lattice;
 use crate::operators::*;
 
 /// Extension trait for the prefix_sum method.
-pub trait PrefixSum<G: Scope, K, D> {
+pub trait PrefixSum<G: Timestamp, K, D> {
     /// Computes the prefix sum for each element in the collection.
     ///
     /// The prefix sum is data-parallel, in the sense that the sums are computed independently for
@@ -21,7 +21,7 @@ pub trait PrefixSum<G: Scope, K, D> {
 
 impl<G, K, D> PrefixSum<G, K, D> for VecCollection<G, ((usize, K), D)>
 where
-    G: Scope<Timestamp: Lattice>,
+    G: Timestamp + Lattice,
     K: ExchangeData + ::std::hash::Hash,
     D: ExchangeData + ::std::hash::Hash,
 {
@@ -42,7 +42,7 @@ where
 /// Accumulate data in `collection` into all powers-of-two intervals containing them.
 pub fn aggregate<G, K, D, F>(collection: VecCollection<G, ((usize, K), D)>, combine: F) -> VecCollection<G, ((usize, usize, K), D)>
 where
-    G: Scope<Timestamp: Lattice>,
+    G: Timestamp + Lattice,
     K: ExchangeData + ::std::hash::Hash,
     D: ExchangeData + ::std::hash::Hash,
     F: Fn(&K,&D,&D)->D + 'static,
@@ -79,7 +79,7 @@ pub fn broadcast<G, K, D, F>(
     zero: D,
     combine: F) -> VecCollection<G, ((usize, K), D)>
 where
-    G: Scope<Timestamp: Lattice + Ord + ::std::fmt::Debug>,
+    G: 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/capture.rs b/differential-dataflow/src/capture.rs
index 74cced0ca..e9a71f6b8 100644
--- a/differential-dataflow/src/capture.rs
+++ b/differential-dataflow/src/capture.rs
@@ -230,7 +230,8 @@ pub mod source {
     use timely::dataflow::{Scope, Stream, operators::{Capability, CapabilitySet}};
     use timely::dataflow::operators::generic::OutputBuilder;
     use timely::progress::Timestamp;
-    use timely::scheduling::SyncActivator;
+    use timely::worker::AsWorker;
+    use timely::scheduling::{Scheduler, SyncActivator};
 
     // TODO(guswynn): implement this generally in timely
     struct DropActivator {
@@ -250,12 +251,11 @@ pub mod source {
     /// The stream is built in the supplied `scope` and continues to run until
     /// the returned `Box<Any>` token is dropped. The `source_builder` argument
     /// is invoked with a `SyncActivator` that will re-activate the source.
-    pub fn build<G, B, I, D, T, R>(
-        scope: G,
+    pub fn build<B, I, D, T, R>(
+        scope: Scope<T>,
         source_builder: B,
-    ) -> (Box<dyn std::any::Any + Send + Sync>, Stream<G, Vec<(D, T, R)>>)
+    ) -> (Box<dyn std::any::Any + Send + Sync>, Stream<T, Vec<(D, T, R)>>)
     where
-        G: Scope<Timestamp = T>,
         B: FnOnce(SyncActivator) -> I,
         I: Iterator<Item = Message<D, T, R>> + 'static,
         D: ExchangeData + Hash,
@@ -563,6 +563,7 @@ pub mod sink {
     use timely::dataflow::{Scope, Stream};
     use timely::dataflow::channels::pact::{Exchange, Pipeline};
     use timely::dataflow::operators::generic::{builder_rc::OperatorBuilder, OutputBuilder};
+    use timely::scheduling::Scheduler;
 
     use crate::{lattice::Lattice, ExchangeData};
     use super::{Writer, Message, Progress};
@@ -573,13 +574,12 @@ pub mod sink {
     /// will *not* perform the consolidation on the stream's behalf. If this is not
     /// performed before calling the method, the recorded output may not be correctly
     /// reconstructed by readers.
-    pub fn build<G, BS, D, T, R>(
-        stream: Stream<G, Vec<(D, T, R)>>,
+    pub fn build<BS, D, T, R>(
+        stream: Stream<T, Vec<(D, T, R)>>,
         sink_hash: u64,
         updates_sink: Weak<RefCell<BS>>,
         progress_sink: Weak<RefCell<BS>>,
     ) where
-        G: Scope<Timestamp = T>,
         BS: Writer<Message<D,T,R>> + 'static,
         D: ExchangeData + Hash + Serialize + for<'a> Deserialize<'a>,
         T: ExchangeData + Hash + Serialize + for<'a> Deserialize<'a> + Timestamp + Lattice,
diff --git a/differential-dataflow/src/collection.rs b/differential-dataflow/src/collection.rs
index e5016ccd4..3720c90e1 100644
--- a/differential-dataflow/src/collection.rs
+++ b/differential-dataflow/src/collection.rs
@@ -10,7 +10,6 @@
 
 use timely::Container;
 use timely::progress::Timestamp;
-use timely::dataflow::scopes::Child;
 use timely::dataflow::{Scope, Stream};
 use timely::dataflow::operators::*;
 
@@ -22,7 +21,7 @@ use crate::difference::Abelian;
 /// in order to expose some of this functionality (e.g. negation, timestamp manipulation). Other actions
 /// on the containers, and streams of containers, are left to the container implementor to describe.
 #[derive(Clone)]
-pub struct Collection<G: Scope, C: 'static> {
+pub struct Collection<G: Timestamp, C: 'static> {
     /// The underlying timely dataflow stream.
     ///
     /// This field is exposed to support direct timely dataflow manipulation when required, but it is
@@ -34,7 +33,7 @@ pub struct Collection<G: Scope, C: 'static> {
     pub inner: Stream<G, C>,
 }
 
-impl<G: Scope, C> Collection<G, C> {
+impl<G: Timestamp, C> Collection<G, C> {
     /// Creates a new Collection from a timely dataflow stream.
     ///
     /// This method seems to be rarely used, with the `as_collection` method on streams being a more
@@ -46,7 +45,7 @@ impl<G: Scope, C> Collection<G, C> {
     /// method does not check it.
     pub fn new(stream: Stream<G, C>) -> Self { Self { inner: stream } }
 }
-impl<G: Scope, C: Container> Collection<G, C> {
+impl<G: Timestamp, C: Container> Collection<G, C> {
     /// Creates a new collection accumulating the contents of the two collections.
     ///
     /// Despite the name, differential dataflow collections are unordered. This method is so named because the
@@ -109,7 +108,7 @@ impl<G: Scope, C: Container> Collection<G, C> {
     ///
     /// This method is a specialization of `enter` to the case where the nested scope is a region.
     /// It removes the need for an operator that adjusts the timestamp.
-    pub fn enter_region<'a>(self, child: &Child<'a, G::Allocator, G::Timestamp>) -> Collection<Child<'a, G::Allocator, G::Timestamp>, C> {
+    pub fn enter_region(self, child: &Scope<G>) -> Self {
         self.inner
             .enter(child)
             .as_collection()
@@ -134,7 +133,7 @@ impl<G: Scope, C: Container> Collection<G, C> {
     /// ```
     pub fn inspect_container<F>(self, func: F) -> Self
     where
-        F: FnMut(Result<(&G::Timestamp, &C), &[G::Timestamp]>)+'static,
+        F: FnMut(Result<(&G, &C), &[G]>)+'static,
     {
         self.inner
             .inspect_container(func)
@@ -144,7 +143,7 @@ impl<G: Scope, C: Container> Collection<G, C> {
     ///
     /// This probe is used to determine when the state of the Collection has stabilized and can
     /// be read out.
-    pub fn probe(self) -> (probe::Handle<G::Timestamp>, Self) {
+    pub fn probe(self) -> (probe::Handle<G>, Self) {
         let (handle, stream) = self.inner.probe();
         (handle, stream.as_collection())
     }
@@ -154,11 +153,11 @@ impl<G: Scope, C: Container> Collection<G, C> {
     /// In addition, a probe is also often use to limit the number of rounds of input in flight at any moment; a
     /// computation can wait until the probe has caught up to the input before introducing more rounds of data, to
     /// avoid swamping the system.
-    pub fn probe_with(self, handle: &probe::Handle<G::Timestamp>) -> Self {
+    pub fn probe_with(self, handle: &probe::Handle<G>) -> Self {
         Self::new(self.inner.probe_with(handle))
     }
     /// The scope containing the underlying timely dataflow stream.
-    pub fn scope(&self) -> G {
+    pub fn scope(&self) -> Scope<G> {
         self.inner.scope()
     }
 
@@ -216,10 +215,10 @@ impl<G: Scope, C: Container> Collection<G, C> {
     ///     data.assert_eq(result);
     /// });
     /// ```
-    pub fn enter<'a, T>(self, child: &Child<'a, G::Allocator, T>) -> Collection<Child<'a, G::Allocator, T>, <C as containers::Enter<G::Timestamp, T>>::InnerContainer>
+    pub fn enter<T>(self, child: &Scope<T>) -> Collection<T, <C as containers::Enter<G, T>>::InnerContainer>
     where
-        C: containers::Enter<G::Timestamp, T, InnerContainer: Container>,
-        T: Refines<G::Timestamp>,
+        C: containers::Enter<G, T, InnerContainer: Container>,
+        T: Refines<G> + Timestamp,
     {
         use timely::dataflow::channels::pact::Pipeline;
         self.inner
@@ -250,9 +249,9 @@ impl<G: Scope, C: Container> Collection<G, C> {
     ///     data.results_in(summary1);
     /// });
     /// ```
-    pub fn results_in(self, step: <G::Timestamp as Timestamp>::Summary) -> Self
+    pub fn results_in(self, step: <G as Timestamp>::Summary) -> Self
     where
-        C: containers::ResultsIn<<G::Timestamp as Timestamp>::Summary>,
+        C: containers::ResultsIn<<G as Timestamp>::Summary>,
     {
         use timely::dataflow::channels::pact::Pipeline;
         self.inner
@@ -266,7 +265,7 @@ impl<G: Scope, C: Container> Collection<G, C> {
 use timely::progress::timestamp::Refines;
 
 /// Methods requiring a nested scope.
-impl<'a, A: timely::communication::Allocate, T: Timestamp, C: Container> Collection<Child<'a, A, T>, C>
+impl<T: Timestamp, C: Container> Collection<T, C>
 {
     /// Returns the final value of a Collection from a nested scope to its containing scope.
     ///
@@ -289,11 +288,11 @@ impl<'a, A: timely::communication::Allocate, T: Timestamp, C: Container> Collect
     ///     data.assert_eq(result);
     /// });
     /// ```
-    pub fn leave<G>(self, outer: &G) -> Collection<G, <C as containers::Leave<T, G::Timestamp>>::OuterContainer>
+    pub fn leave<TOuter>(self, outer: &Scope<TOuter>) -> Collection<TOuter, <C as containers::Leave<T, TOuter>>::OuterContainer>
     where
-        G: Scope<Allocator = A>,
-        T: Refines<G::Timestamp>,
-        C: containers::Leave<T, G::Timestamp, OuterContainer: Container>,
+        TOuter: Timestamp,
+        T: Refines<TOuter>,
+        C: containers::Leave<T, TOuter, OuterContainer: Container>,
     {
         use timely::dataflow::channels::pact::Pipeline;
         self.inner
@@ -303,18 +302,14 @@ impl<'a, A: timely::communication::Allocate, T: Timestamp, C: Container> Collect
             })
             .as_collection()
     }
-}
 
-/// Methods requiring a region as the scope.
-impl<'a, A: timely::communication::Allocate, T: Timestamp, C: Container+Clone+'static> Collection<Child<'a, A, T>, C>
-{
     /// Returns the value of a Collection from a nested region to its containing scope.
     ///
     /// This method is a specialization of `leave` to the case that of a nested region.
     /// It removes the need for an operator that adjusts the timestamp.
-    pub fn leave_region<G>(self, outer: &G) -> Collection<G, C>
+    pub fn leave_region(self, outer: &Scope<T>) -> Self
     where
-        G: Scope<Allocator = A, Timestamp = T>,
+        C: Clone + 'static,
     {
         self.inner
             .leave(outer)
@@ -330,7 +325,7 @@ pub mod vec {
 
     use timely::progress::Timestamp;
     use timely::order::Product;
-    use timely::dataflow::scopes::child::Iterative;
+    use timely::dataflow::scope::Iterative;
     use timely::dataflow::Scope;
     use timely::dataflow::operators::*;
     use timely::dataflow::operators::vec::*;
@@ -356,11 +351,11 @@ pub mod vec {
     /// The `R` parameter represents the types of changes that the data undergo, and is most commonly (and
     /// defaults to) `isize`, representing changes to the occurrence count of each record.
     ///
-    /// This type definition instantiates the [`Collection`] type with a `Vec<(D, G::Timestamp, R)>`.
-    pub type Collection<G, D, R = isize> = super::Collection<G, Vec<(D, <G as Scope>::Timestamp, R)>>;
+    /// This type definition instantiates the [`Collection`] type with a `Vec<(D, G, R)>`.
+    pub type Collection<G, D, R = isize> = super::Collection<G, Vec<(D, G, R)>>;
 
 
-    impl<G: Scope, D: Clone+'static, R: Clone+'static> Collection<G, D, R> {
+    impl<G: Timestamp, D: Clone+'static, R: Clone+'static> Collection<G, D, R> {
         /// Creates a new collection by applying the supplied function to each input element.
         ///
         /// # Examples
@@ -428,7 +423,7 @@ pub mod vec {
         /// ```
         pub fn flat_map<I, L>(self, mut logic: L) -> Collection<G, I::Item, R>
         where
-            G::Timestamp: Clone,
+            G: Clone,
             I: IntoIterator<Item: Clone+'static>,
             L: FnMut(D) -> I + 'static,
         {
@@ -514,10 +509,10 @@ pub mod vec {
         /// ```
         pub fn join_function<D2, R2, I, L>(self, mut logic: L) -> Collection<G, D2, <R2 as Multiply<R>>::Output>
         where
-            G::Timestamp: Lattice,
+            G: Lattice,
             D2: Clone+'static,
             R2: Semigroup+Multiply<R, Output: Semigroup+'static>,
-            I: IntoIterator<Item=(D2,G::Timestamp,R2)>,
+            I: IntoIterator<Item=(D2,G,R2)>,
             L: FnMut(D)->I+'static,
         {
             self.inner
@@ -549,11 +544,11 @@ pub mod vec {
         ///     data.assert_eq(result);
         /// });
         /// ```
-        pub fn enter_at<'a, T, F>(self, child: &Iterative<'a, G::Allocator, G::Timestamp, T>, mut initial: F) -> Collection<Iterative<'a, G::Allocator, G::Timestamp, T>, D, R>
+        pub fn enter_at<T, F>(self, child: &Iterative<G, T>, mut initial: F) -> Collection<Product<G, T>, D, R>
         where
             T: Timestamp+Hash,
             F: FnMut(&D) -> T + Clone + 'static,
-            G::Timestamp: Hash,
+            G: Hash,
         {
             self.inner
                 .enter(child)
@@ -573,8 +568,8 @@ pub mod vec {
         /// to all of the data timestamps).
         pub fn delay<F>(self, func: F) -> Collection<G, D, R>
         where
-            G::Timestamp: Hash,
-            F: FnMut(&G::Timestamp) -> G::Timestamp + Clone + 'static,
+            G: Hash,
+            F: FnMut(&G) -> G + Clone + 'static,
         {
             let mut func1 = func.clone();
             let mut func2 = func.clone();
@@ -610,7 +605,7 @@ pub mod vec {
         /// ```
         pub fn inspect<F>(self, func: F) -> Collection<G, D, R>
         where
-            F: FnMut(&(D, G::Timestamp, R))+'static,
+            F: FnMut(&(D, G, R))+'static,
         {
             self.inner
                 .inspect(func)
@@ -636,7 +631,7 @@ pub mod vec {
         /// ```
         pub fn inspect_batch<F>(self, mut func: F) -> Collection<G, D, R>
         where
-            F: FnMut(&G::Timestamp, &[(D, G::Timestamp, R)])+'static,
+            F: FnMut(&G, &[(D, G, R)])+'static,
         {
             self.inner
                 .inspect_batch(move |time, data| func(time, data))
@@ -666,7 +661,7 @@ pub mod vec {
         where
             D: crate::ExchangeData+Hashable,
             R: crate::ExchangeData+Hashable + Semigroup,
-            G::Timestamp: Lattice+Ord,
+            G: Lattice+Ord,
         {
             self.consolidate()
                 .inspect(|x| panic!("Assertion failed: non-empty collection: {:?}", x));
@@ -674,7 +669,7 @@ pub mod vec {
     }
 
     /// Methods requiring an Abelian difference, to support negation.
-    impl<G: Scope<Timestamp: Clone+'static>, D: Clone+'static, R: Abelian+'static> Collection<G, D, R> {
+    impl<G: Timestamp + Clone + 'static, 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
@@ -702,7 +697,7 @@ pub mod vec {
         where
             D: crate::ExchangeData+Hashable,
             R: crate::ExchangeData+Hashable,
-            G::Timestamp: Lattice+Ord,
+            G: Lattice+Ord,
         {
             self.negate()
                 .concat(other)
@@ -715,7 +710,7 @@ pub mod vec {
 
     impl <G, K, V, R> Collection<G, (K, V), R>
     where
-        G: Scope<Timestamp: Lattice+Ord>,
+        G: Timestamp + Lattice + Ord,
         K: crate::ExchangeData+Hashable,
         V: crate::ExchangeData,
         R: crate::ExchangeData+Semigroup,
@@ -792,7 +787,7 @@ pub mod vec {
         /// ```
         pub 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, ValOwn = V, Time=G::Timestamp, Diff: Abelian>+'static,
+            T2: for<'a> Trace<Key<'a>= &'a K, ValOwn = V, Time=G, Diff: Abelian>+'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)>)+'static,
         {
@@ -811,7 +806,7 @@ pub mod vec {
         pub fn reduce_core<L, Bu, T2>(self, name: &str, logic: L) -> Arranged<G, TraceAgent<T2>>
         where
             V: Clone+'static,
-            T2: for<'a> Trace<Key<'a>=&'a K, ValOwn = V, Time=G::Timestamp>+'static,
+            T2: for<'a> Trace<Key<'a>=&'a K, ValOwn = V, Time=G>+'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,
         {
@@ -826,7 +821,7 @@ pub mod vec {
 
     impl<G, K, R1> Collection<G, K, R1>
     where
-        G: Scope<Timestamp: Lattice+Ord>,
+        G: Timestamp + Lattice + Ord,
         K: crate::ExchangeData+Hashable,
         R1: crate::ExchangeData+Semigroup
     {
@@ -885,7 +880,7 @@ pub mod vec {
             use crate::trace::implementations::{KeyBuilder, KeySpine};
 
             self.arrange_by_self_named(&format!("Arrange: {}", name))
-                .reduce_abelian::<_,KeyBuilder<K,G::Timestamp,R2>,KeySpine<K,G::Timestamp,R2>,_>(
+                .reduce_abelian::<_,KeyBuilder<K,G,R2>,KeySpine<K,G,R2>,_>(
                     name,
                     move |k,s,t| t.push(((), thresh(k, &s[0].1))),
                     |vec, key, upds| { vec.clear(); vec.extend(upds.drain(..).map(|(v,t,r)| ((key.clone(), v),t,r))); },
@@ -897,7 +892,7 @@ pub mod vec {
 
     impl<G, K, R> Collection<G, K, R>
     where
-        G: Scope<Timestamp: Lattice+Ord>,
+        G: Timestamp + Lattice + Ord,
         K: crate::ExchangeData+Hashable,
         R: crate::ExchangeData+Semigroup
     {
@@ -926,7 +921,7 @@ pub mod vec {
         pub fn count_core<R2: Ord + Abelian + From<i8> + 'static>(self) -> Collection<G, (K, R), R2> {
             use crate::trace::implementations::{ValBuilder, ValSpine};
             self.arrange_by_self_named("Arrange: Count")
-                .reduce_abelian::<_,ValBuilder<K,R,G::Timestamp,R2>,ValSpine<K,R,G::Timestamp,R2>,_>(
+                .reduce_abelian::<_,ValBuilder<K,R,G,R2>,ValSpine<K,R,G,R2>,_>(
                     "Count",
                     |_k,s,t| t.push((s[0].1.clone(), R2::from(1i8))),
                     |vec, key, upds| { vec.clear(); vec.extend(upds.drain(..).map(|(v,t,r)| ((key.clone(), v),t,r))); },
@@ -938,7 +933,7 @@ pub mod vec {
     /// Methods which require data be arrangeable.
     impl<G, D, R> Collection<G, D, R>
     where
-        G: Scope<Timestamp: Clone+'static+Lattice>,
+        G: Timestamp + Clone + 'static + Lattice,
         D: crate::ExchangeData+Hashable,
         R: crate::ExchangeData+Semigroup,
     {
@@ -972,8 +967,8 @@ pub mod vec {
         /// and provide the function `reify` to produce owned keys and values..
         pub fn consolidate_named<Ba, Bu, Tr, F>(self, name: &str, reify: F) -> Self
         where
-            Ba: crate::trace::Batcher<Input=Vec<((D,()),G::Timestamp,R)>, Time=G::Timestamp> + 'static,
-            Tr: for<'a> crate::trace::Trace<Time=G::Timestamp,Diff=R>+'static,
+            Ba: crate::trace::Batcher<Input=Vec<((D,()),G,R)>, Time=G> + 'static,
+            Tr: for<'a> crate::trace::Trace<Time=G,Diff=R>+'static,
             Bu: crate::trace::Builder<Time=Tr::Time, Input=Ba::Output, Output=Tr::Batch>,
             F: Fn(Tr::Key<'_>, Tr::Val<'_>) -> D + 'static,
         {
@@ -1031,35 +1026,35 @@ pub mod vec {
     use crate::trace::implementations::{KeySpine, KeyBatcher, KeyBuilder};
     use crate::operators::arrange::Arrange;
 
-    impl<G, K, V, R> Arrange<G, Vec<((K, V), G::Timestamp, R)>> for Collection<G, (K, V), R>
+    impl<G, K, V, R> Arrange<G, Vec<((K, V), G, R)>> for Collection<G, (K, V), R>
     where
-        G: Scope<Timestamp: Lattice>,
+        G: Timestamp + Lattice,
         K: crate::ExchangeData + Hashable,
         V: crate::ExchangeData,
         R: crate::ExchangeData + Semigroup,
     {
         fn arrange_named<Ba, Bu, Tr>(self, name: &str) -> Arranged<G, TraceAgent<Tr>>
         where
-            Ba: crate::trace::Batcher<Input=Vec<((K, V), G::Timestamp, R)>, Time=G::Timestamp> + 'static,
-            Bu: crate::trace::Builder<Time=G::Timestamp, Input=Ba::Output, Output = Tr::Batch>,
-            Tr: crate::trace::Trace<Time=G::Timestamp> + 'static,
+            Ba: crate::trace::Batcher<Input=Vec<((K, V), G, R)>, Time=G> + 'static,
+            Bu: crate::trace::Builder<Time=G, Input=Ba::Output, Output = Tr::Batch>,
+            Tr: crate::trace::Trace<Time=G> + 'static,
         {
-            let exchange = timely::dataflow::channels::pact::Exchange::new(move |update: &((K,V),G::Timestamp,R)| (update.0).0.hashed().into());
+            let exchange = timely::dataflow::channels::pact::Exchange::new(move |update: &((K,V),G,R)| (update.0).0.hashed().into());
             crate::operators::arrange::arrangement::arrange_core::<_, _, Ba, Bu, _>(self.inner, exchange, name)
         }
     }
 
-    impl<G, K: crate::ExchangeData+Hashable, R: crate::ExchangeData+Semigroup> Arrange<G, Vec<((K, ()), G::Timestamp, R)>> for Collection<G, K, R>
+    impl<G, K: crate::ExchangeData+Hashable, R: crate::ExchangeData+Semigroup> Arrange<G, Vec<((K, ()), G, R)>> for Collection<G, K, R>
     where
-        G: Scope<Timestamp: Lattice+Ord>,
+        G: Timestamp + Lattice + Ord,
     {
         fn arrange_named<Ba, Bu, Tr>(self, name: &str) -> Arranged<G, TraceAgent<Tr>>
         where
-            Ba: crate::trace::Batcher<Input=Vec<((K,()),G::Timestamp,R)>, Time=G::Timestamp> + 'static,
-            Bu: crate::trace::Builder<Time=G::Timestamp, Input=Ba::Output, Output = Tr::Batch>,
-            Tr: crate::trace::Trace<Time=G::Timestamp> + 'static,
+            Ba: crate::trace::Batcher<Input=Vec<((K,()),G,R)>, Time=G> + 'static,
+            Bu: crate::trace::Builder<Time=G, Input=Ba::Output, Output = Tr::Batch>,
+            Tr: crate::trace::Trace<Time=G> + 'static,
         {
-            let exchange = timely::dataflow::channels::pact::Exchange::new(move |update: &((K,()),G::Timestamp,R)| (update.0).0.hashed().into());
+            let exchange = timely::dataflow::channels::pact::Exchange::new(move |update: &((K,()),G,R)| (update.0).0.hashed().into());
             crate::operators::arrange::arrangement::arrange_core::<_,_,Ba,Bu,_>(self.map(|k| (k, ())).inner, exchange, name)
         }
     }
@@ -1067,38 +1062,38 @@ pub mod vec {
 
     impl<G, K: crate::ExchangeData+Hashable, V: crate::ExchangeData, R: crate::ExchangeData+Semigroup> Collection<G, (K,V), R>
     where
-        G: Scope<Timestamp: Lattice+Ord>,
+        G: 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.
         /// This trace is current for all times completed by the output stream, which can be used to
         /// safely identify the stable times and values in the trace.
-        pub fn arrange_by_key(self) -> Arranged<G, TraceAgent<ValSpine<K, V, G::Timestamp, R>>> {
+        pub fn arrange_by_key(self) -> Arranged<G, TraceAgent<ValSpine<K, V, G, R>>> {
             self.arrange_by_key_named("ArrangeByKey")
         }
 
         /// As `arrange_by_key` but with the ability to name the arrangement.
-        pub fn arrange_by_key_named(self, name: &str) -> Arranged<G, TraceAgent<ValSpine<K, V, G::Timestamp, R>>> {
+        pub fn arrange_by_key_named(self, name: &str) -> Arranged<G, TraceAgent<ValSpine<K, V, G, R>>> {
             self.arrange_named::<ValBatcher<_,_,_,_>,ValBuilder<_,_,_,_>,_>(name)
         }
     }
 
     impl<G, K: crate::ExchangeData+Hashable, R: crate::ExchangeData+Semigroup> Collection<G, K, R>
     where
-        G: Scope<Timestamp: Lattice+Ord>,
+        G: Timestamp + Lattice + Ord,
     {
         /// Arranges a collection of `Key` records by `Key`.
         ///
         /// This operator arranges a collection of records into a shared trace, whose contents it maintains.
         /// This trace is current for all times complete in the output stream, which can be used to safely
         /// identify the stable times and values in the trace.
-        pub fn arrange_by_self(self) -> Arranged<G, TraceAgent<KeySpine<K, G::Timestamp, R>>> {
+        pub fn arrange_by_self(self) -> Arranged<G, TraceAgent<KeySpine<K, G, R>>> {
             self.arrange_by_self_named("ArrangeBySelf")
         }
 
         /// As `arrange_by_self` but with the ability to name the arrangement.
-        pub fn arrange_by_self_named(self, name: &str) -> Arranged<G, TraceAgent<KeySpine<K, G::Timestamp, R>>> {
+        pub fn arrange_by_self_named(self, name: &str) -> Arranged<G, TraceAgent<KeySpine<K, G, R>>> {
             self.map(|k| (k, ()))
                 .arrange_named::<KeyBatcher<_,_,_>,KeyBuilder<_,_,_>,_>(name)
         }
@@ -1106,7 +1101,7 @@ pub mod vec {
 
     impl<G, K, V, R> Collection<G, (K, V), R>
     where
-        G: Scope<Timestamp: Lattice+Ord>,
+        G: Timestamp + Lattice + Ord,
         K: crate::ExchangeData+Hashable,
         V: crate::ExchangeData,
         R: crate::ExchangeData+Semigroup,
@@ -1252,7 +1247,7 @@ pub mod vec {
         /// ```
         pub 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> crate::trace::TraceReader<Key<'a>=&'a K, Time=G::Timestamp>+Clone+'static,
+            Tr2: for<'a> crate::trace::TraceReader<Key<'a>=&'a K, Time=G>+Clone+'static,
             R: Multiply<Tr2::Diff, Output: Semigroup+'static>,
             I: IntoIterator<Item: crate::Data>,
             L: FnMut(&K,&V,Tr2::Val<'_>)->I+'static,
@@ -1264,12 +1259,12 @@ pub mod vec {
 }
 
 /// Conversion to a differential dataflow Collection.
-pub trait AsCollection<G: Scope, C> {
+pub trait AsCollection<G: Timestamp, C> {
     /// Converts the type to a differential dataflow collection.
     fn as_collection(self) -> Collection<G, C>;
 }
 
-impl<G: Scope, C> AsCollection<G, C> for Stream<G, C> {
+impl<G: Timestamp, C> AsCollection<G, C> for Stream<G, C> {
     /// Converts the type to a differential dataflow collection.
     ///
     /// By calling this method, you guarantee that the timestamp invariant (as documented on
@@ -1300,9 +1295,9 @@ impl<G: Scope, C> AsCollection<G, C> for Stream<G, C> {
 ///         .assert_eq(data);
 /// });
 /// ```
-pub fn concatenate<G, C, I>(scope: &mut G, iterator: I) -> Collection<G, C>
+pub fn concatenate<G, C, I>(scope: &mut Scope<G>, iterator: I) -> Collection<G, C>
 where
-    G: Scope,
+    G: Timestamp,
     C: Container,
     I: IntoIterator<Item=Collection<G, C>>,
 {
diff --git a/differential-dataflow/src/dynamic/mod.rs b/differential-dataflow/src/dynamic/mod.rs
index 19c5472a6..9efe58f6c 100644
--- a/differential-dataflow/src/dynamic/mod.rs
+++ b/differential-dataflow/src/dynamic/mod.rs
@@ -13,7 +13,6 @@
 
 pub mod pointstamp;
 
-use timely::dataflow::Scope;
 use timely::order::Product;
 use timely::progress::Timestamp;
 use timely::dataflow::operators::generic::{OutputBuilder, builder_rc::OperatorBuilder};
@@ -26,9 +25,8 @@ use crate::collection::AsCollection;
 use crate::dynamic::pointstamp::PointStamp;
 use crate::dynamic::pointstamp::PointStampSummary;
 
-impl<G, D, R, T, TOuter> VecCollection<G, D, R>
+impl<D, R, T, TOuter> VecCollection<Product<TOuter, PointStamp<T>>, D, R>
 where
-    G: Scope<Timestamp = Product<TOuter, PointStamp<T>>>,
     D: Data,
     R: Semigroup+'static,
     T: Timestamp+Default,
diff --git a/differential-dataflow/src/input.rs b/differential-dataflow/src/input.rs
index 024aeb10d..0ef606ac7 100644
--- a/differential-dataflow/src/input.rs
+++ b/differential-dataflow/src/input.rs
@@ -41,7 +41,7 @@ pub trait Input : TimelyInput {
     ///
     /// }).unwrap();
     /// ```
-    fn new_collection<D, R>(&mut self) -> (InputSession<Self::Timestamp, D, R>, VecCollection<Self, D, R>)
+    fn new_collection<D, R>(&mut self) -> (InputSession<Self::Timestamp, D, R>, VecCollection<Self::Timestamp, D, R>)
     where D: Data, R: Semigroup+'static;
     /// Create a new collection and input handle from initial data.
     ///
@@ -67,7 +67,7 @@ pub trait Input : TimelyInput {
     ///
     /// }).unwrap();
     /// ```
-    fn new_collection_from<I>(&mut self, data: I) -> (InputSession<Self::Timestamp, I::Item, isize>, VecCollection<Self, I::Item, isize>)
+    fn new_collection_from<I>(&mut self, data: I) -> (InputSession<Self::Timestamp, I::Item, isize>, VecCollection<Self::Timestamp, I::Item, isize>)
     where I: IntoIterator<Item: Data> + 'static;
     /// Create a new collection and input handle from initial data.
     ///
@@ -93,28 +93,28 @@ pub trait Input : TimelyInput {
     ///
     /// }).unwrap();
     /// ```
-    fn new_collection_from_raw<D, R, I>(&mut self, data: I) -> (InputSession<Self::Timestamp, D, R>, VecCollection<Self, D, R>)
+    fn new_collection_from_raw<D, R, I>(&mut self, data: I) -> (InputSession<Self::Timestamp, D, R>, VecCollection<Self::Timestamp, D, R>)
     where I: IntoIterator<Item=(D,Self::Timestamp,R)>+'static, D: Data, R: Semigroup+'static;
 }
 
 use crate::lattice::Lattice;
-impl<G: TimelyInput> Input for G where G::Timestamp: Lattice {
-    fn new_collection<D, R>(&mut self) -> (InputSession<G::Timestamp, D, R>, VecCollection<G, D, R>)
+impl<T: Timestamp + Lattice + timely::order::TotalOrder> Input for Scope<T> {
+    fn new_collection<D, R>(&mut self) -> (InputSession<T, D, R>, VecCollection<T, D, R>)
     where
         D: Data, R: Semigroup+'static,
     {
         let (handle, stream) = self.new_input();
         (InputSession::from(handle), stream.as_collection())
     }
-    fn new_collection_from<I>(&mut self, data: I) -> (InputSession<G::Timestamp, I::Item, isize>, VecCollection<G, I::Item, isize>)
+    fn new_collection_from<I>(&mut self, data: I) -> (InputSession<T, I::Item, isize>, VecCollection<T, I::Item, isize>)
     where I: IntoIterator+'static, I::Item: Data {
-        self.new_collection_from_raw(data.into_iter().map(|d| (d, <G::Timestamp as timely::progress::Timestamp>::minimum(), 1)))
+        self.new_collection_from_raw(data.into_iter().map(|d| (d, <T as timely::progress::Timestamp>::minimum(), 1)))
     }
-    fn new_collection_from_raw<D,R,I>(&mut self, data: I) -> (InputSession<G::Timestamp, D, R>, VecCollection<G, D, R>)
+    fn new_collection_from_raw<D,R,I>(&mut self, data: I) -> (InputSession<T, D, R>, VecCollection<T, D, R>)
     where
         D: Data,
         R: Semigroup+'static,
-        I: IntoIterator<Item=(D,Self::Timestamp,R)>+'static,
+        I: IntoIterator<Item=(D,T,R)>+'static,
     {
         use timely::dataflow::operators::ToStream;
 
@@ -122,7 +122,8 @@ impl<G: TimelyInput> Input for G where G::Timestamp: Lattice {
         let source = data.to_stream(self).as_collection();
 
         (InputSession::from(handle), stream.as_collection().concat(source))
-    }}
+    }
+}
 
 /// An input session wrapping a single timely dataflow capability.
 ///
@@ -198,9 +199,9 @@ impl<T: Timestamp+Clone, D: Data> InputSession<T, D, isize> {
 impl<T: Timestamp+Clone, D: Data, R: Semigroup+'static> InputSession<T, D, R> {
 
     /// Introduces a handle as collection.
-    pub fn to_collection<G: TimelyInput>(&mut self, scope: &mut G) -> VecCollection<G, D, R>
+    pub fn to_collection(&mut self, scope: &mut Scope<T>) -> VecCollection<T, D, R>
     where
-        G: Scope<Timestamp=T>,
+        T: timely::order::TotalOrder,
     {
         scope
             .input_from(&mut self.handle)
diff --git a/differential-dataflow/src/logging.rs b/differential-dataflow/src/logging.rs
index 4fb6ef430..1ba9833f8 100644
--- a/differential-dataflow/src/logging.rs
+++ b/differential-dataflow/src/logging.rs
@@ -10,9 +10,8 @@ pub type DifferentialEventBuilder = timely::container::CapacityContainerBuilder<
 pub type Logger = ::timely::logging_core::TypedLogger<DifferentialEventBuilder, DifferentialEvent>;
 
 /// Enables logging of differential dataflow events.
-pub fn enable<A, W>(worker: &mut timely::worker::Worker<A>, writer: W) -> Option<Box<dyn std::any::Any+'static>>
+pub fn enable<W>(worker: &mut timely::worker::Worker, writer: W) -> Option<Box<dyn std::any::Any+'static>>
 where
-    A: timely::communication::Allocate,
     W: std::io::Write + 'static,
 {
     worker.log_register().and_then(|mut log_register| {
diff --git a/differential-dataflow/src/operators/arrange/agent.rs b/differential-dataflow/src/operators/arrange/agent.rs
index 715542f55..7da94dc84 100644
--- a/differential-dataflow/src/operators/arrange/agent.rs
+++ b/differential-dataflow/src/operators/arrange/agent.rs
@@ -9,6 +9,7 @@ use timely::dataflow::operators::generic::{OperatorInfo, source};
 use timely::progress::Timestamp;
 use timely::progress::{Antichain, frontier::AntichainRef};
 use timely::dataflow::operators::CapabilitySet;
+use timely::scheduling::Scheduler;
 
 use crate::trace::{Trace, TraceReader, BatchReader};
 use crate::trace::wrappers::rc::TraceBox;
@@ -215,17 +216,13 @@ impl<Tr: TraceReader+'static> TraceAgent<Tr> {
     ///
     /// }).unwrap();
     /// ```
-    pub fn import<G>(&mut self, scope: &G) -> Arranged<G, TraceAgent<Tr>>
-    where
-        G: Scope<Timestamp=Tr::Time>,
+    pub fn import(&mut self, scope: &Scope<Tr::Time>) -> Arranged<Tr::Time, TraceAgent<Tr>>
     {
         self.import_named(scope, "ArrangedSource")
     }
 
     /// Same as `import`, but allows to name the source.
-    pub fn import_named<G>(&mut self, scope: &G, name: &str) -> Arranged<G, TraceAgent<Tr>>
-    where
-        G: Scope<Timestamp=Tr::Time>,
+    pub fn import_named(&mut self, scope: &Scope<Tr::Time>, name: &str) -> Arranged<Tr::Time, TraceAgent<Tr>>
     {
         // Drop ShutdownButton and return only the arrangement.
         self.import_core(scope, name).0
@@ -278,9 +275,7 @@ impl<Tr: TraceReader+'static> TraceAgent<Tr> {
     ///
     /// }).unwrap();
     /// ```
-    pub fn import_core<G>(&mut self, scope: &G, name: &str) -> (Arranged<G, TraceAgent<Tr>>, ShutdownButton<CapabilitySet<Tr::Time>>)
-    where
-        G: Scope<Timestamp=Tr::Time>,
+    pub fn import_core(&mut self, scope: &Scope<Tr::Time>, name: &str) -> (Arranged<Tr::Time, TraceAgent<Tr>>, ShutdownButton<CapabilitySet<Tr::Time>>)
     {
         let trace = self.clone();
 
@@ -393,9 +388,8 @@ impl<Tr: TraceReader+'static> TraceAgent<Tr> {
     ///
     /// }).unwrap();
     /// ```
-    pub fn import_frontier<G>(&mut self, scope: &G, name: &str) -> (Arranged<G, TraceFrontier<TraceAgent<Tr>>>, ShutdownButton<CapabilitySet<Tr::Time>>)
+    pub fn import_frontier(&mut self, scope: &Scope<Tr::Time>, name: &str) -> (Arranged<Tr::Time, TraceFrontier<TraceAgent<Tr>>>, ShutdownButton<CapabilitySet<Tr::Time>>)
     where
-        G: Scope<Timestamp=Tr::Time>,
         Tr: TraceReader,
     {
         // This frontier describes our only guarantee on the compaction frontier.
@@ -411,9 +405,8 @@ impl<Tr: TraceReader+'static> TraceAgent<Tr> {
     ///
     /// Invoking this method with an `until` of `Antichain::new()` will perform no filtering, as the empty
     /// frontier indicates the end of times.
-    pub fn import_frontier_core<G>(&mut self, scope: &G, name: &str, since: Antichain<Tr::Time>, until: Antichain<Tr::Time>) -> (Arranged<G, TraceFrontier<TraceAgent<Tr>>>, ShutdownButton<CapabilitySet<Tr::Time>>)
+    pub fn import_frontier_core(&mut self, scope: &Scope<Tr::Time>, name: &str, since: Antichain<Tr::Time>, until: Antichain<Tr::Time>) -> (Arranged<Tr::Time, TraceFrontier<TraceAgent<Tr>>>, ShutdownButton<CapabilitySet<Tr::Time>>)
     where
-        G: Scope<Timestamp=Tr::Time>,
         Tr: TraceReader,
     {
         let trace = self.clone();
diff --git a/differential-dataflow/src/operators/arrange/arrangement.rs b/differential-dataflow/src/operators/arrange/arrangement.rs
index cd0d00dfc..dcfa0bcf8 100644
--- a/differential-dataflow/src/operators/arrange/arrangement.rs
+++ b/differential-dataflow/src/operators/arrange/arrangement.rs
@@ -25,6 +25,8 @@ use timely::dataflow::channels::pact::{ParallelizationContract, Pipeline};
 use timely::progress::Timestamp;
 use timely::progress::Antichain;
 use timely::dataflow::operators::Capability;
+use timely::scheduling::Scheduler;
+use timely::worker::AsWorker;
 
 use crate::{Data, VecCollection, AsCollection};
 use crate::difference::Semigroup;
@@ -43,7 +45,7 @@ use super::TraceAgent;
 /// computation, memory) required to produce and maintain an indexed representation of a collection.
 pub struct Arranged<G, Tr>
 where
-    G: Scope<Timestamp: Lattice+Ord>,
+    G: Timestamp,
     Tr: TraceReader+Clone,
 {
     /// A stream containing arranged updates.
@@ -60,8 +62,8 @@ where
 
 impl<G, Tr> Clone for Arranged<G, Tr>
 where
-    G: Scope<Timestamp=Tr::Time>,
-    Tr: TraceReader + Clone,
+    G: Timestamp,
+    Tr: TraceReader<Time = G> + Clone,
 {
     fn clone(&self) -> Self {
         Arranged {
@@ -71,24 +73,23 @@ where
     }
 }
 
-use ::timely::dataflow::scopes::Child;
 use ::timely::progress::timestamp::Refines;
 use timely::Container;
 
 impl<G, Tr> Arranged<G, Tr>
 where
-    G: Scope<Timestamp=Tr::Time>,
-    Tr: TraceReader + Clone,
+    G: Timestamp,
+    Tr: TraceReader<Time = G> + Clone,
 {
     /// Brings an arranged collection into a nested scope.
     ///
     /// This method produces a proxy trace handle that uses the same backing data, but acts as if the timestamps
     /// have all been extended with an additional coordinate with the default value. The resulting collection does
     /// not vary with the new timestamp coordinate.
-    pub fn enter<'a, TInner>(self, child: &Child<'a, G::Allocator, TInner>)
-        -> Arranged<Child<'a, G::Allocator, TInner>, TraceEnter<Tr, TInner>>
+    pub fn enter<TInner>(self, child: &Scope<TInner>)
+        -> Arranged<TInner, TraceEnter<Tr, TInner>>
         where
-            TInner: Refines<G::Timestamp>+Lattice+Timestamp+Clone,
+            TInner: Refines<G>+Lattice+Timestamp+Clone,
     {
         Arranged {
             stream: self.stream.enter(child).map(|bw| BatchEnter::make_from(bw)),
@@ -100,8 +101,7 @@ where
     ///
     /// This method only applies to *regions*, which are subscopes with the same timestamp
     /// as their containing scope. In this case, the trace type does not need to change.
-    pub fn enter_region<'a>(self, child: &Child<'a, G::Allocator, G::Timestamp>)
-        -> Arranged<Child<'a, G::Allocator, G::Timestamp>, Tr> {
+    pub fn enter_region(self, child: &Scope<G>) -> Self {
         Arranged {
             stream: self.stream.enter(child),
             trace: self.trace,
@@ -113,10 +113,10 @@ where
     /// This method produces a proxy trace handle that uses the same backing data, but acts as if the timestamps
     /// have all been extended with an additional coordinate with the default value. The resulting collection does
     /// not vary with the new timestamp coordinate.
-    pub fn enter_at<'a, TInner, F, P>(self, child: &Child<'a, G::Allocator, TInner>, logic: F, prior: P)
-        -> Arranged<Child<'a, G::Allocator, TInner>, TraceEnterAt<Tr, TInner, F, P>>
+    pub fn enter_at<TInner, F, P>(self, child: &Scope<TInner>, logic: F, prior: P)
+        -> Arranged<TInner, TraceEnterAt<Tr, TInner, F, P>>
         where
-            TInner: Refines<G::Timestamp>+Lattice+Timestamp+Clone+'static,
+            TInner: Refines<G>+Lattice+Timestamp+Clone+'static,
             F: FnMut(Tr::Key<'_>, Tr::Val<'_>, Tr::TimeGat<'_>)->TInner+Clone+'static,
             P: FnMut(&TInner)->Tr::Time+Clone+'static,
         {
@@ -233,8 +233,8 @@ use crate::difference::Multiply;
 // Direct join implementations.
 impl<G, T1> Arranged<G, T1>
 where
-    G: Scope<Timestamp=T1::Time>,
-    T1: TraceReader + Clone + 'static,
+    G: Timestamp + Lattice,
+    T1: TraceReader<Time = G> + Clone + 'static,
 {
     /// A convenience method to join and produce `VecCollection` output.
     ///
@@ -246,7 +246,7 @@ where
         I: IntoIterator<Item: Data>,
         L: FnMut(T1::Key<'_>,T1::Val<'_>,T2::Val<'_>)->I+'static
     {
-        let mut result = move |k: T1::Key<'_>, v1: T1::Val<'_>, v2: T2::Val<'_>, t: &G::Timestamp, r1: &T1::Diff, r2: &T2::Diff| {
+        let mut result = move |k: T1::Key<'_>, v1: T1::Val<'_>, v2: T2::Val<'_>, t: &G, r1: &T1::Diff, r2: &T2::Diff| {
             let t = t.clone();
             let r = (r1.clone()).multiply(r2);
             result(k, v1, v2).into_iter().map(move |d| (d, t.clone(), r.clone()))
@@ -270,8 +270,8 @@ where
 use crate::difference::Abelian;
 impl<G, T1> Arranged<G, T1>
 where
-    G: Scope<Timestamp = T1::Time>,
-    T1: TraceReader + Clone + 'static,
+    G: Timestamp + Lattice,
+    T1: TraceReader<Time = G> + Clone + 'static,
 {
     /// A direct implementation of `ReduceCore::reduce_abelian`.
     pub fn reduce_abelian<L, Bu, T2, P>(self, name: &str, mut logic: L, push: P) -> Arranged<G, TraceAgent<T2>>
@@ -283,7 +283,7 @@ where
             Time=T1::Time,
             Diff: Abelian,
         >+'static,
-        Bu: Builder<Time=G::Timestamp, Output = T2::Batch, Input: Default>,
+        Bu: Builder<Time=G, Output = T2::Batch, Input: Default>,
         L: FnMut(T1::Key<'_>, &[(T1::Val<'_>, T1::Diff)], &mut Vec<(T2::ValOwn, T2::Diff)>)+'static,
         P: FnMut(&mut Bu::Input, T1::Key<'_>, &mut Vec<(T2::ValOwn, T2::Time, T2::Diff)>) + 'static,
     {
@@ -305,7 +305,7 @@ where
             ValOwn: Data,
             Time=T1::Time,
         >+'static,
-        Bu: Builder<Time=G::Timestamp, Output = T2::Batch, Input: Default>,
+        Bu: Builder<Time=G, Output = T2::Batch, Input: Default>,
         L: FnMut(T1::Key<'_>, &[(T1::Val<'_>, T1::Diff)], &mut Vec<(T2::ValOwn, T2::Diff)>, &mut Vec<(T2::ValOwn, T2::Diff)>)+'static,
         P: FnMut(&mut Bu::Input, T1::Key<'_>, &mut Vec<(T2::ValOwn, T2::Time, T2::Diff)>) + 'static,
     {
@@ -315,18 +315,15 @@ where
 }
 
 
-impl<'a, A, Tr> Arranged<Child<'a, A, Tr::Time>, Tr>
+impl<Tr> Arranged<Tr::Time, Tr>
 where
-    A: timely::communication::Allocate,
     Tr: TraceReader + Clone,
 {
     /// Brings an arranged collection out of a nested region.
     ///
     /// This method only applies to *regions*, which are subscopes with the same timestamp
     /// as their containing scope. In this case, the trace type does not need to change.
-    pub fn leave_region<G>(self, outer: &G) -> Arranged<G, Tr>
-    where
-        G: Scope<Allocator = A, Timestamp = Tr::Time>,
+    pub fn leave_region(self, outer: &Scope<Tr::Time>) -> Self
     {
         use timely::dataflow::operators::Leave;
         Arranged {
@@ -339,14 +336,14 @@ where
 /// A type that can be arranged as if a collection of updates.
 pub trait Arrange<G, C> : Sized
 where
-    G: Scope<Timestamp: Lattice>,
+    G: Timestamp + Lattice,
 {
     /// Arranges updates into a shared trace.
     fn arrange<Ba, Bu, Tr>(self) -> Arranged<G, TraceAgent<Tr>>
     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,
+        Ba: Batcher<Input=C, Time=G> + 'static,
+        Bu: Builder<Time=G, Input=Ba::Output, Output = Tr::Batch>,
+        Tr: Trace<Time=G> + 'static,
     {
         self.arrange_named::<Ba, Bu, Tr>("Arrange")
     }
@@ -354,9 +351,9 @@ where
     /// Arranges updates into a shared trace, with a supplied name.
     fn arrange_named<Ba, Bu, Tr>(self, name: &str) -> Arranged<G, TraceAgent<Tr>>
     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,
+        Ba: Batcher<Input=C, Time=G> + 'static,
+        Bu: Builder<Time=G, Input=Ba::Output, Output = Tr::Batch>,
+        Tr: Trace<Time=G> + 'static,
     ;
 }
 
@@ -367,11 +364,11 @@ where
 /// be consistently by key (though this is the most common).
 pub fn arrange_core<G, P, Ba, Bu, Tr>(stream: Stream<G, Ba::Input>, pact: P, name: &str) -> Arranged<G, TraceAgent<Tr>>
 where
-    G: Scope<Timestamp: Lattice>,
-    P: ParallelizationContract<G::Timestamp, Ba::Input>,
-    Ba: Batcher<Time=G::Timestamp,Input: Container> + 'static,
-    Bu: Builder<Time=G::Timestamp, Input=Ba::Output, Output = Tr::Batch>,
-    Tr: Trace<Time=G::Timestamp>+'static,
+    G: Timestamp + Lattice,
+    P: ParallelizationContract<G, Ba::Input>,
+    Ba: Batcher<Time=G,Input: Container> + 'static,
+    Bu: Builder<Time=G, Input=Ba::Output, Output = Tr::Batch>,
+    Tr: Trace<Time=G>+'static,
 {
     // The `Arrange` operator is tasked with reacting to an advancing input
     // frontier by producing the sequence of batches whose lower and upper
@@ -403,7 +400,7 @@ where
         let mut batcher = Ba::new(logger.clone(), info.global_id);
 
         // Capabilities for the lower envelope of updates in `batcher`.
-        let mut capabilities = Antichain::<Capability<G::Timestamp>>::new();
+        let mut capabilities = Antichain::<Capability<G>>::new();
 
         let activator = Some(scope.activator_for(info.address.clone()));
         let mut empty_trace = Tr::new(info.clone(), logger.clone(), activator);
@@ -417,7 +414,7 @@ where
         *reader_ref = Some(reader_local);
 
         // Initialize to the minimal input frontier.
-        let mut prev_frontier = Antichain::from_elem(<G::Timestamp as Timestamp>::minimum());
+        let mut prev_frontier = Antichain::from_elem(<G as Timestamp>::minimum());
 
         move |(input, frontier), output| {
 
diff --git a/differential-dataflow/src/operators/arrange/upsert.rs b/differential-dataflow/src/operators/arrange/upsert.rs
index a8322eaa3..bedf8d02f 100644
--- a/differential-dataflow/src/operators/arrange/upsert.rs
+++ b/differential-dataflow/src/operators/arrange/upsert.rs
@@ -107,6 +107,8 @@ use timely::dataflow::channels::pact::Exchange;
 use timely::progress::Timestamp;
 use timely::progress::Antichain;
 use timely::dataflow::operators::Capability;
+use timely::scheduling::Scheduler;
+use timely::worker::AsWorker;
 
 use crate::operators::arrange::arrangement::Arranged;
 use crate::trace::{Builder, Description};
@@ -128,20 +130,21 @@ use super::TraceAgent;
 /// understand what a "sequence" of upserts would mean for partially ordered
 /// timestamps.
 pub fn arrange_from_upsert<G, Bu, Tr, K, V>(
-    stream: Stream<G, Vec<(K, Option<V>, G::Timestamp)>>,
+    stream: Stream<G, Vec<(K, Option<V>, G)>>,
     name: &str,
 ) -> Arranged<G, TraceAgent<Tr>>
 where
-    G: Scope<Timestamp=Tr::Time>,
+    G: Timestamp,
     K: ExchangeData+Hashable+std::hash::Hash,
     V: ExchangeData,
     Tr: for<'a> Trace<
         Key<'a> = &'a K,
         Val<'a> = &'a V,
-        Time: TotalOrder+ExchangeData,
+        Time = G,
         Diff=isize,
     >+'static,
-    Bu: Builder<Time=G::Timestamp, Input = Vec<((K, V), Tr::Time, Tr::Diff)>, Output = Tr::Batch>,
+    G: TotalOrder+ExchangeData,
+    Bu: Builder<Time=G, Input = Vec<((K, V), Tr::Time, Tr::Diff)>, Output = Tr::Batch>,
 {
     let mut reader: Option<TraceAgent<Tr>> = None;
 
@@ -150,7 +153,7 @@ where
 
         let reader = &mut reader;
 
-        let exchange = Exchange::new(move |update: &(K,Option<V>,G::Timestamp)| (update.0).hashed().into());
+        let exchange = Exchange::new(move |update: &(K,Option<V>,G)| (update.0).hashed().into());
 
         let scope = stream.scope();
         stream.unary_frontier(exchange, name, move |_capability, info| {
@@ -159,7 +162,7 @@ where
             let logger = scope.logger_for::<crate::logging::DifferentialEventBuilder>("differential/arrange").map(Into::into);
 
             // Tracks the lower envelope of times in `priority_queue`.
-            let mut capabilities = Antichain::<Capability<G::Timestamp>>::new();
+            let mut capabilities = Antichain::<Capability<G>>::new();
             // Form the trace we will both use internally and publish.
             let activator = Some(scope.activator_for(info.address.clone()));
             let mut empty_trace = Tr::new(info.clone(), logger.clone(), activator);
@@ -173,10 +176,10 @@ where
             *reader = Some(reader_local.clone());
 
             // Tracks the input frontier, used to populate the lower bound of new batches.
-            let mut prev_frontier = Antichain::from_elem(<G::Timestamp as Timestamp>::minimum());
+            let mut prev_frontier = Antichain::from_elem(<G as Timestamp>::minimum());
 
             // For stashing input upserts, ordered increasing by time (`BinaryHeap` is a max-heap).
-            let mut priority_queue = BinaryHeap::<std::cmp::Reverse<(G::Timestamp, K, Option<V>)>>::new();
+            let mut priority_queue = BinaryHeap::<std::cmp::Reverse<(G, K, Option<V>)>>::new();
             let mut updates = Vec::new();
 
             move |(input, frontier), output| {
@@ -279,7 +282,7 @@ where
                                     updates.sort();
                                     builder.push(&mut updates);
                                 }
-                                let description = Description::new(prev_frontier.clone(), upper.clone(), Antichain::from_elem(G::Timestamp::minimum()));
+                                let description = Description::new(prev_frontier.clone(), upper.clone(), Antichain::from_elem(G::minimum()));
                                 let batch = builder.done(description);
                                 prev_frontier.clone_from(&upper);
 
diff --git a/differential-dataflow/src/operators/count.rs b/differential-dataflow/src/operators/count.rs
index 713c73c86..5c0e2988e 100644
--- a/differential-dataflow/src/operators/count.rs
+++ b/differential-dataflow/src/operators/count.rs
@@ -1,7 +1,7 @@
 //! Count the number of occurrences of each element.
 
 use timely::order::TotalOrder;
-use timely::dataflow::*;
+use timely::progress::Timestamp;
 use timely::dataflow::operators::Operator;
 use timely::dataflow::channels::pact::Pipeline;
 
@@ -14,7 +14,7 @@ use crate::operators::arrange::Arranged;
 use crate::trace::{BatchReader, Cursor, TraceReader};
 
 /// Extension trait for the `count` differential dataflow method.
-pub trait CountTotal<G: Scope<Timestamp: TotalOrder+Lattice+Ord>, K: ExchangeData, R: Semigroup> : Sized {
+pub trait CountTotal<G: Timestamp + TotalOrder + Lattice + Ord, K: ExchangeData, R: Semigroup> : Sized {
     /// Counts the number of occurrences of each element.
     ///
     /// # Examples
@@ -44,7 +44,7 @@ pub trait CountTotal<G: Scope<Timestamp: TotalOrder+Lattice+Ord>, K: ExchangeDat
 
 impl<G, K: ExchangeData+Hashable, R: ExchangeData+Semigroup> CountTotal<G, K, R> for VecCollection<G, K, R>
 where
-    G: Scope<Timestamp: TotalOrder+Lattice+Ord>,
+    G: Timestamp + TotalOrder + Lattice + Ord,
 {
     fn count_total_core<R2: Semigroup + From<i8> + 'static>(self) -> VecCollection<G, (K, R), R2> {
         self.arrange_by_self_named("Arrange: CountTotal")
@@ -54,11 +54,11 @@ where
 
 impl<G, K, T1> CountTotal<G, K, T1::Diff> for Arranged<G, T1>
 where
-    G: Scope<Timestamp=T1::Time>,
+    G: Timestamp + TotalOrder + Lattice + Ord,
     T1: for<'a> TraceReader<
         Key<'a> = &'a K,
         Val<'a>=&'a (),
-        Time: TotalOrder,
+        Time = G,
         Diff: ExchangeData+Semigroup<T1::DiffGat<'a>>
     >+Clone+'static,
     K: ExchangeData,
@@ -70,8 +70,8 @@ where
         self.stream.unary_frontier(Pipeline, "CountTotal", move |_,_| {
 
             // tracks the lower and upper limit of received batches.
-            let mut lower_limit = timely::progress::frontier::Antichain::from_elem(<G::Timestamp as timely::progress::Timestamp>::minimum());
-            let mut upper_limit = timely::progress::frontier::Antichain::from_elem(<G::Timestamp as timely::progress::Timestamp>::minimum());
+            let mut lower_limit = timely::progress::frontier::Antichain::from_elem(<G as timely::progress::Timestamp>::minimum());
+            let mut upper_limit = timely::progress::frontier::Antichain::from_elem(<G as timely::progress::Timestamp>::minimum());
 
             move |(input, _frontier), output| {
 
diff --git a/differential-dataflow/src/operators/iterate.rs b/differential-dataflow/src/operators/iterate.rs
index 3dd3412b2..ec130448f 100644
--- a/differential-dataflow/src/operators/iterate.rs
+++ b/differential-dataflow/src/operators/iterate.rs
@@ -37,7 +37,7 @@ use timely::progress::Timestamp;
 use timely::order::Product;
 
 use timely::dataflow::*;
-use timely::dataflow::scopes::child::Iterative;
+use timely::dataflow::scope::Iterative;
 use timely::dataflow::operators::{Feedback, ConnectLoop};
 use timely::dataflow::operators::feedback::Handle;
 
@@ -46,7 +46,7 @@ use crate::difference::{Semigroup, Abelian};
 use crate::lattice::Lattice;
 
 /// An extension trait for the `iterate` method.
-pub trait Iterate<G: Scope<Timestamp: Lattice>, D: Data, R: Semigroup> {
+pub trait Iterate<G: Timestamp + Lattice, D: Data, R: Semigroup> {
     /// Iteratively apply `logic` to the source collection until convergence.
     ///
     /// Importantly, this method does not automatically consolidate results.
@@ -75,13 +75,13 @@ pub trait Iterate<G: Scope<Timestamp: Lattice>, D: Data, R: Semigroup> {
     /// ```
     fn iterate<F>(self, logic: F) -> VecCollection<G, D, R>
     where
-        for<'a> F: FnOnce(Iterative<'a, G::Allocator, G::Timestamp, u64>, VecCollection<Iterative<'a, G::Allocator, G::Timestamp, u64>, D, R>)->VecCollection<Iterative<'a, G::Allocator, G::Timestamp, u64>, D, R>;
+        for<'a> F: FnOnce(Iterative<G, u64>, VecCollection<Product<G, u64>, D, R>)->VecCollection<Product<G, u64>, D, R>;
 }
 
-impl<G: Scope<Timestamp: Lattice>, D: Ord+Data+Debug, R: Abelian+'static> Iterate<G, D, R> for VecCollection<G, D, R> {
+impl<G: Timestamp + Lattice, D: Ord+Data+Debug, R: Abelian+'static> Iterate<G, D, R> for VecCollection<G, D, R> {
     fn iterate<F>(self, logic: F) -> VecCollection<G, D, R>
     where
-        for<'a> F: FnOnce(Iterative<'a, G::Allocator, G::Timestamp, u64>, VecCollection<Iterative<'a, G::Allocator, G::Timestamp, u64>, D, R>)->VecCollection<Iterative<'a, G::Allocator, G::Timestamp, u64>, D, R>,
+        for<'a> F: FnOnce(Iterative<G, u64>, VecCollection<Product<G, u64>, D, R>)->VecCollection<Product<G, u64>, D, R>,
     {
         let outer = self.inner.scope();
         outer.scoped("Iterate", |subgraph| {
@@ -99,10 +99,10 @@ impl<G: Scope<Timestamp: Lattice>, D: Ord+Data+Debug, R: Abelian+'static> Iterat
     }
 }
 
-impl<G: Scope<Timestamp: Lattice>, D: Ord+Data+Debug, R: Semigroup+'static> Iterate<G, D, R> for G {
+impl<G: Timestamp + Lattice, D: Ord+Data+Debug, R: Semigroup+'static> Iterate<G, D, R> for Scope<G> {
     fn iterate<F>(self, logic: F) -> VecCollection<G, D, R>
     where
-        for<'a> F: FnOnce(Iterative<'a, G::Allocator, G::Timestamp, u64>, VecCollection<Iterative<'a, G::Allocator, G::Timestamp, u64>, D, R>)->VecCollection<Iterative<'a, G::Allocator, G::Timestamp, u64>, D, R>,
+        for<'a> F: FnOnce(Iterative<G, u64>, VecCollection<Product<G, u64>, D, R>)->VecCollection<Product<G, u64>, D, R>,
     {
         let outer = self.clone();
         self.scoped("Iterate", |subgraph| {
@@ -192,21 +192,21 @@ impl<G: Scope<Timestamp: Lattice>, D: Ord+Data+Debug, R: Semigroup+'static> Iter
 /// large, and the edits to perform are relatively smaller.
 pub struct Variable<G, C>
 where
-    G: Scope<Timestamp: Lattice>,
+    G: Timestamp + Lattice,
     C: Container,
 {
     feedback: Handle<G, C>,
     source: Option<Collection<G, C>>,
-    step: <G::Timestamp as Timestamp>::Summary,
+    step: <G as Timestamp>::Summary,
 }
 
 /// A `Variable` specialized to a vector container of update triples (data, time, diff).
-pub type VecVariable<G, D, R> = Variable<G, Vec<(D, <G as Scope>::Timestamp, R)>>;
+pub type VecVariable<G, D, R> = Variable<G, Vec<(D, G, R)>>;
 
 impl<G, C: Container> Variable<G, C>
 where
-    G: Scope<Timestamp: Lattice>,
-    C: crate::collection::containers::ResultsIn<<G::Timestamp as Timestamp>::Summary>,
+    G: Timestamp + Lattice,
+    C: crate::collection::containers::ResultsIn<<G as Timestamp>::Summary>,
 {
     /// Creates a new initially empty `Variable` and its associated `Collection`.
     ///
@@ -219,7 +219,7 @@ where
     /// will produce its fixed point in the outer scope.
     ///
     /// In a non-iterative scope the mechanics are the same, but the interpretation varies.
-    pub fn new(scope: &mut G, step: <G::Timestamp as Timestamp>::Summary) -> (Self, Collection<G, C>) {
+    pub fn new(scope: &mut Scope<G>, step: <G as Timestamp>::Summary) -> (Self, Collection<G, C>) {
         let (feedback, updates) = scope.feedback(step.clone());
         let collection = Collection::<G, C>::new(updates);
         (Self { feedback, source: None, step }, collection)
@@ -250,7 +250,7 @@ where
     /// adding the source, doing the logic, then subtracting the source, it is appropriate to do.
     /// For example, if the logic modifies a few records it is possible to produce this update
     /// directly without using the backstop implementation this method provides.
-    pub fn new_from(source: Collection<G, C>, step: <G::Timestamp as Timestamp>::Summary) -> (Self, Collection<G, C>) where C: Clone + crate::collection::containers::Negate {
+    pub fn new_from(source: Collection<G, C>, step: <G as Timestamp>::Summary) -> (Self, Collection<G, C>) where C: Clone + crate::collection::containers::Negate {
         let (feedback, updates) = source.inner.scope().feedback(step.clone());
         let collection = Collection::<G, C>::new(updates).concat(source.clone());
         (Variable { feedback, source: Some(source.negate()), step }, collection)
diff --git a/differential-dataflow/src/operators/join.rs b/differential-dataflow/src/operators/join.rs
index dae4d31b3..a4c2cedf7 100644
--- a/differential-dataflow/src/operators/join.rs
+++ b/differential-dataflow/src/operators/join.rs
@@ -9,10 +9,12 @@ use timely::{Accountable, ContainerBuilder};
 use timely::container::PushInto;
 use timely::order::PartialOrder;
 use timely::progress::Timestamp;
-use timely::dataflow::{Scope, Stream};
+use timely::dataflow::Stream;
 use timely::dataflow::operators::generic::{Operator, OutputBuilderSession, Session};
 use timely::dataflow::channels::pact::Pipeline;
 use timely::dataflow::operators::Capability;
+use timely::scheduling::Scheduler;
+use timely::worker::AsWorker;
 
 use crate::lattice::Lattice;
 use crate::operators::arrange::Arranged;
@@ -68,10 +70,10 @@ impl<CB: PushInto<D>, D> PushInto<D> for EffortBuilder<CB> {
 /// [`AsCollection`]: crate::collection::AsCollection
 pub fn join_traces<G, T1, T2, L, CB>(arranged1: Arranged<G,T1>, arranged2: Arranged<G,T2>, mut result: L) -> Stream<G, CB::Container>
 where
-    G: Scope<Timestamp=T1::Time>,
-    T1: TraceReader+Clone+'static,
-    T2: for<'a> TraceReader<Key<'a>=T1::Key<'a>, Time=T1::Time>+Clone+'static,
-    L: FnMut(T1::Key<'_>,T1::Val<'_>,T2::Val<'_>,&G::Timestamp,&T1::Diff,&T2::Diff,&mut JoinSession<T1::Time, CB, Capability<T1::Time>>)+'static,
+    G: Timestamp + Lattice,
+    T1: TraceReader<Time = G>+Clone+'static,
+    T2: for<'a> TraceReader<Key<'a>=T1::Key<'a>, Time = G>+Clone+'static,
+    L: FnMut(T1::Key<'_>,T1::Val<'_>,T2::Val<'_>,&G,&T1::Diff,&T2::Diff,&mut JoinSession<G, CB, Capability<G>>)+'static,
     CB: ContainerBuilder,
 {
     // Rename traces for symmetry from here on out.
@@ -97,8 +99,8 @@ where
         // the physical compaction frontier of their corresponding trace.
         // Should we ever *drop* a trace, these are 1. much harder to maintain correctly, but 2. no longer used.
         use timely::progress::frontier::Antichain;
-        let mut acknowledged1 = Antichain::from_elem(<G::Timestamp>::minimum());
-        let mut acknowledged2 = Antichain::from_elem(<G::Timestamp>::minimum());
+        let mut acknowledged1 = Antichain::from_elem(<G>::minimum());
+        let mut acknowledged2 = Antichain::from_elem(<G>::minimum());
 
         // deferred work of batches from each input.
         let mut todo1 = std::collections::VecDeque::new();
diff --git a/differential-dataflow/src/operators/reduce.rs b/differential-dataflow/src/operators/reduce.rs
index 909199295..8f2e86db9 100644
--- a/differential-dataflow/src/operators/reduce.rs
+++ b/differential-dataflow/src/operators/reduce.rs
@@ -9,9 +9,10 @@ use crate::Data;
 
 use timely::progress::frontier::Antichain;
 use timely::progress::Timestamp;
-use timely::dataflow::*;
 use timely::dataflow::operators::Operator;
 use timely::dataflow::channels::pact::Pipeline;
+use timely::scheduling::Scheduler;
+use timely::worker::AsWorker;
 
 use crate::operators::arrange::{Arranged, TraceAgent};
 use crate::trace::{BatchReader, Cursor, Trace, Builder, ExertionLogic, Description};
@@ -34,9 +35,9 @@ use crate::trace::TraceReader;
 /// key's computation to another, and will likely introduce non-determinism.
 pub fn reduce_trace<G, T1, Bu, T2, L, P>(trace: Arranged<G, T1>, name: &str, mut logic: L, mut push: P) -> Arranged<G, TraceAgent<T2>>
 where
-    G: Scope<Timestamp=T1::Time>,
-    T1: TraceReader + Clone + 'static,
-    T2: for<'a> Trace<Key<'a>=T1::Key<'a>, ValOwn: Data, Time=T1::Time> + 'static,
+    G: Timestamp + crate::lattice::Lattice,
+    T1: TraceReader<Time = G> + Clone + 'static,
+    T2: for<'a> Trace<Key<'a>=T1::Key<'a>, ValOwn: Data, Time = G> + 'static,
     Bu: Builder<Time=T2::Time, Output = T2::Batch, Input: Default>,
     L: FnMut(T1::Key<'_>, &[(T1::Val<'_>, T1::Diff)], &mut Vec<(T2::ValOwn,T2::Diff)>, &mut Vec<(T2::ValOwn, T2::Diff)>)+'static,
     P: FnMut(&mut Bu::Input, T1::Key<'_>, &mut Vec<(T2::ValOwn, T2::Time, T2::Diff)>) + 'static,
@@ -66,7 +67,7 @@ where
 
             *result_trace = Some(output_reader.clone());
 
-            let mut new_interesting_times = Vec::<G::Timestamp>::new();
+            let mut new_interesting_times = Vec::<G>::new();
 
             // Our implementation maintains a list of outstanding `(key, time)` synthetic interesting times,
             // sorted by (key, time), as well as capabilities for the lower envelope of the times.
@@ -74,18 +75,18 @@ where
             let mut pending_time = T1::TimeContainer::with_capacity(0);
             let mut next_pending_keys = T1::KeyContainer::with_capacity(0);
             let mut next_pending_time = T1::TimeContainer::with_capacity(0);
-            let mut capabilities = timely::dataflow::operators::CapabilitySet::<G::Timestamp>::default();
+            let mut capabilities = timely::dataflow::operators::CapabilitySet::<G>::default();
 
             // buffers and logic for computing per-key interesting times "efficiently".
-            let mut interesting_times = Vec::<G::Timestamp>::new();
+            let mut interesting_times = Vec::<G>::new();
 
             // Upper and lower frontiers for the pending input and output batches to process.
-            let mut upper_limit = Antichain::from_elem(<G::Timestamp as timely::progress::Timestamp>::minimum());
-            let mut lower_limit = Antichain::from_elem(<G::Timestamp as timely::progress::Timestamp>::minimum());
+            let mut upper_limit = Antichain::from_elem(<G as timely::progress::Timestamp>::minimum());
+            let mut lower_limit = Antichain::from_elem(<G as timely::progress::Timestamp>::minimum());
 
             // Output batches may need to be built piecemeal, and these temp storage help there.
-            let mut output_upper = Antichain::from_elem(<G::Timestamp as timely::progress::Timestamp>::minimum());
-            let mut output_lower = Antichain::from_elem(<G::Timestamp as timely::progress::Timestamp>::minimum());
+            let mut output_upper = Antichain::from_elem(<G as timely::progress::Timestamp>::minimum());
+            let mut output_lower = Antichain::from_elem(<G as timely::progress::Timestamp>::minimum());
 
             move |(input, frontier), output| {
 
@@ -137,7 +138,7 @@ where
                         // Prepare an output buffer and builder for each capability.
                         // TODO: It would be better if all updates went into one batch, but timely dataflow prevents
                         //       this as long as it requires that there is only one capability for each message.
-                        let mut buffers = Vec::<(G::Timestamp, Vec<(T2::ValOwn, G::Timestamp, T2::Diff)>)>::new();
+                        let mut buffers = Vec::<(G, Vec<(T2::ValOwn, G, T2::Diff)>)>::new();
                         let mut builders = Vec::new();
                         for cap in capabilities.iter() {
                             buffers.push((cap.time().clone(), Vec::new()));
@@ -252,7 +253,7 @@ where
 
                             if output_upper.borrow() != output_lower.borrow() {
 
-                                let description = Description::new(output_lower.clone(), output_upper.clone(), Antichain::from_elem(G::Timestamp::minimum()));
+                                let description = Description::new(output_lower.clone(), output_upper.clone(), Antichain::from_elem(G::minimum()));
                                 let batch = builder.done(description);
 
                                 // ship batch to the output, and commit to the output trace.
@@ -272,7 +273,7 @@ where
                         pending_time.clear(); std::mem::swap(&mut next_pending_time, &mut pending_time);
 
                         // Update `capabilities` to reflect pending times.
-                        let mut frontier = Antichain::<G::Timestamp>::new();
+                        let mut frontier = Antichain::<G>::new();
                         let mut owned_time = T1::Time::minimum();
                         for pos in 0 .. pending_time.len() {
                             T1::clone_time_onto(pending_time.index(pos), &mut owned_time);
diff --git a/differential-dataflow/src/operators/threshold.rs b/differential-dataflow/src/operators/threshold.rs
index 91bbd16fe..e8bcea2e5 100644
--- a/differential-dataflow/src/operators/threshold.rs
+++ b/differential-dataflow/src/operators/threshold.rs
@@ -4,7 +4,7 @@
 //! `distinct` and `distinct_u` operators for the case in which time is totally ordered.
 
 use timely::order::TotalOrder;
-use timely::dataflow::*;
+use timely::progress::Timestamp;
 use timely::dataflow::operators::Operator;
 use timely::dataflow::channels::pact::Pipeline;
 
@@ -17,7 +17,7 @@ use crate::operators::arrange::Arranged;
 use crate::trace::{BatchReader, Cursor, TraceReader};
 
 /// Extension trait for the `distinct` differential dataflow method.
-pub trait ThresholdTotal<G: Scope<Timestamp: TotalOrder+Lattice+Ord>, K: ExchangeData, R: ExchangeData+Semigroup> : Sized {
+pub trait ThresholdTotal<G: Timestamp + TotalOrder + Lattice + Ord, K: ExchangeData, R: ExchangeData+Semigroup> : Sized {
     /// Reduces the collection to one occurrence of each distinct element.
     fn threshold_semigroup<R2, F>(self, thresh: F) -> VecCollection<G, K, R2>
     where
@@ -84,9 +84,9 @@ pub trait ThresholdTotal<G: Scope<Timestamp: TotalOrder+Lattice+Ord>, K: Exchang
 
 }
 
-impl<G: Scope, K: ExchangeData+Hashable, R: ExchangeData+Semigroup> ThresholdTotal<G, K, R> for VecCollection<G, K, R>
+impl<G, K: ExchangeData+Hashable, R: ExchangeData+Semigroup> ThresholdTotal<G, K, R> for VecCollection<G, K, R>
 where
-    G: Scope<Timestamp: TotalOrder+Lattice+Ord>,
+    G: Timestamp + TotalOrder + Lattice + Ord,
 {
     fn threshold_semigroup<R2, F>(self, thresh: F) -> VecCollection<G, K, R2>
     where
@@ -100,11 +100,11 @@ where
 
 impl<G, K, T1> ThresholdTotal<G, K, T1::Diff> for Arranged<G, T1>
 where
-    G: Scope<Timestamp=T1::Time>,
+    G: Timestamp + TotalOrder + Lattice + Ord,
     T1: for<'a> TraceReader<
         Key<'a>=&'a K,
         Val<'a>=&'a (),
-        Time: TotalOrder,
+        Time = G,
         Diff : ExchangeData + Semigroup<T1::DiffGat<'a>>,
     >+Clone+'static,
     K: ExchangeData,
@@ -120,8 +120,8 @@ where
         self.stream.unary_frontier(Pipeline, "ThresholdTotal", move |_,_| {
 
             // tracks the lower and upper limit of received batches.
-            let mut lower_limit = timely::progress::frontier::Antichain::from_elem(<G::Timestamp as timely::progress::Timestamp>::minimum());
-            let mut upper_limit = timely::progress::frontier::Antichain::from_elem(<G::Timestamp as timely::progress::Timestamp>::minimum());
+            let mut lower_limit = timely::progress::frontier::Antichain::from_elem(<G as timely::progress::Timestamp>::minimum());
+            let mut upper_limit = timely::progress::frontier::Antichain::from_elem(<G as timely::progress::Timestamp>::minimum());
 
             move |(input, _frontier), output| {
 
diff --git a/differential-dataflow/tests/bfs.rs b/differential-dataflow/tests/bfs.rs
index fd6aea26c..917fccc93 100644
--- a/differential-dataflow/tests/bfs.rs
+++ b/differential-dataflow/tests/bfs.rs
@@ -204,7 +204,7 @@ fn bfs_differential(
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
 fn bfs<G>(edges: VecCollection<G, Edge>, roots: VecCollection<G, Node>) -> VecCollection<G, (Node, usize)>
 where
-    G: Scope<Timestamp: Lattice+Ord>,
+    G: timely::progress::Timestamp + Lattice + Ord,
 {
     // initialize roots as reaching themselves at distance 0
     let nodes = roots.map(|x| (x, 0));
diff --git a/differential-dataflow/tests/scc.rs b/differential-dataflow/tests/scc.rs
index 52eecdf1d..87712bf68 100644
--- a/differential-dataflow/tests/scc.rs
+++ b/differential-dataflow/tests/scc.rs
@@ -217,7 +217,7 @@ fn scc_differential(
 
 fn _strongly_connected<G>(graph: VecCollection<G, Edge>) -> VecCollection<G, Edge>
 where
-    G: Scope<Timestamp: Lattice+Ord+Hash>,
+    G: timely::progress::Timestamp + Lattice + Ord + Hash,
 {
     graph.clone().iterate(|scope, inner| {
         let edges = graph.enter(&scope);
@@ -228,7 +228,7 @@ where
 
 fn _trim_edges<G>(cycle: VecCollection<G, Edge>, edges: VecCollection<G, Edge>) -> VecCollection<G, Edge>
 where
-    G: Scope<Timestamp: Lattice+Ord+Hash>,
+    G: timely::progress::Timestamp + Lattice + Ord + Hash,
 {
     let nodes = edges.clone()
                      .map_in_place(|x| x.0 = x.1)
@@ -246,7 +246,7 @@ where
 
 fn _reachability<G>(edges: VecCollection<G, Edge>, nodes: VecCollection<G, (Node, Node)>) -> VecCollection<G, Edge>
 where
-    G: Scope<Timestamp: Lattice+Ord+Hash>,
+    G: timely::progress::Timestamp + Lattice + Ord + Hash,
 {
     edges.clone()   // <-- wth is this.
          .filter(|_| false)
diff --git a/dogsdogsdogs/examples/ngo.rs b/dogsdogsdogs/examples/ngo.rs
index 340b6c988..13a906c51 100644
--- a/dogsdogsdogs/examples/ngo.rs
+++ b/dogsdogsdogs/examples/ngo.rs
@@ -38,9 +38,9 @@ fn main() {
     }).unwrap();
 }
 
-fn triangles<G: Scope>(edges: VecCollection<G, Edge>) -> VecCollection<G, (Node, Node, Node)>
+fn triangles<G>(edges: VecCollection<G, Edge>) -> VecCollection<G, (Node, Node, Node)>
 where
-    G: Scope<Timestamp: Lattice+Hash+Ord>,
+    G: timely::progress::Timestamp + Lattice + Hash + Ord,
 {
     // only use forward-pointing edges.
     let edges = edges.filter(|&(src, dst)| src < dst);
diff --git a/dogsdogsdogs/src/calculus.rs b/dogsdogsdogs/src/calculus.rs
index c6f057dcb..b24694b76 100644
--- a/dogsdogsdogs/src/calculus.rs
+++ b/dogsdogsdogs/src/calculus.rs
@@ -13,7 +13,7 @@
 //! almost everywhere empty (and so has a low memory footprint, if the system works as planned).
 
 use timely::dataflow::Scope;
-use timely::dataflow::scopes::Child;
+use timely::progress::Timestamp;
 use timely::dataflow::operators::vec::{Filter, Map};
 use differential_dataflow::{AsCollection, VecCollection, Data};
 use differential_dataflow::difference::Abelian;
@@ -21,23 +21,23 @@ use differential_dataflow::difference::Abelian;
 use crate::altneu::AltNeu;
 
 /// Produce a collection containing the changes at the moments they happen.
-pub trait Differentiate<G: Scope, D: Data, R: Abelian> {
-    fn differentiate<'a>(self, child: &Child<'a, G::Allocator, AltNeu<G::Timestamp>>) -> VecCollection<Child<'a, G::Allocator, AltNeu<G::Timestamp>>, D, R>;
+pub trait Differentiate<G: Timestamp, D: Data, R: Abelian> {
+    fn differentiate(self, child: &Scope<AltNeu<G>>) -> VecCollection<AltNeu<G>, D, R>;
 }
 
 /// Collect instantaneous changes back in to a collection.
-pub trait Integrate<G: Scope, D: Data, R: Abelian> {
-    fn integrate(self, outer: &G) -> VecCollection<G, D, R>;
+pub trait Integrate<G: Timestamp, D: Data, R: Abelian> {
+    fn integrate(self, outer: &Scope<G>) -> VecCollection<G, D, R>;
 }
 
 impl<G, D, R> Differentiate<G, D, R> for VecCollection<G, D, R>
 where
-    G: Scope,
+    G: Timestamp,
     D: Data,
     R: Abelian + 'static,
 {
     // For each (data, Alt(time), diff) we add a (data, Neu(time), -diff).
-    fn differentiate<'a>(self, child: &Child<'a, G::Allocator, AltNeu<G::Timestamp>>) -> VecCollection<Child<'a, G::Allocator, AltNeu<G::Timestamp>>, D, R> {
+    fn differentiate(self, child: &Scope<AltNeu<G>>) -> VecCollection<AltNeu<G>, D, R> {
         self.enter(child)
             .inner
             .flat_map(|(data, time, diff)| {
@@ -51,14 +51,14 @@ where
     }
 }
 
-impl<'a, G, D, R> Integrate<G, D, R> for VecCollection<Child<'a, G::Allocator, AltNeu<G::Timestamp>>, D, R>
+impl<G, D, R> Integrate<G, D, R> for VecCollection<AltNeu<G>, D, R>
 where
-    G: Scope,
+    G: Timestamp,
     D: Data,
     R: Abelian + 'static,
 {
     // We discard each `neu` variant and strip off the `alt` wrapper.
-    fn integrate(self, outer: &G) -> VecCollection<G, D, R> {
+    fn integrate(self, outer: &Scope<G>) -> VecCollection<G, D, R> {
         self.inner
             .filter(|(_d,t,_r)| !t.neu)
             .as_collection()
diff --git a/dogsdogsdogs/src/lib.rs b/dogsdogsdogs/src/lib.rs
index f704d5988..c34dc2fca 100644
--- a/dogsdogsdogs/src/lib.rs
+++ b/dogsdogsdogs/src/lib.rs
@@ -20,7 +20,7 @@ pub mod operators;
     Implementors of `PrefixExtension` provide types and methods for extending a differential dataflow collection,
     via the three methods `count`, `propose`, and `validate`.
 **/
-pub trait PrefixExtender<G: Scope, R: Monoid+Multiply<Output = R>> {
+pub trait PrefixExtender<G: Timestamp, R: Monoid+Multiply<Output = R>> {
     /// The required type of prefix to extend.
     type Prefix;
     /// The type to be produced as extension.
@@ -33,14 +33,14 @@ pub trait PrefixExtender<G: Scope, R: Monoid+Multiply<Output = R>> {
     fn validate(&mut self, extensions: VecCollection<G, (Self::Prefix, Self::Extension), R>) -> VecCollection<G, (Self::Prefix, Self::Extension), R>;
 }
 
-pub trait ProposeExtensionMethod<G: Scope, P: ExchangeData+Ord, R: Monoid+Multiply<Output = R>> {
+pub trait ProposeExtensionMethod<G: Timestamp, P: ExchangeData+Ord, R: Monoid+Multiply<Output = R>> {
     fn propose_using<PE: PrefixExtender<G, R, Prefix=P>>(self, extender: &mut PE) -> VecCollection<G, (P, PE::Extension), R>;
     fn extend<E: ExchangeData+Ord>(self, extenders: &mut [&mut dyn PrefixExtender<G,R,Prefix=P,Extension=E>]) -> VecCollection<G, (P, E), R>;
 }
 
 impl<G, P, R> ProposeExtensionMethod<G, P, R> for VecCollection<G, P, R>
 where
-    G: Scope,
+    G: Timestamp,
     P: ExchangeData+Ord,
     R: Monoid+Multiply<Output = R>+'static,
 {
@@ -81,11 +81,11 @@ where
     }
 }
 
-pub trait ValidateExtensionMethod<G: Scope, R: Monoid+Multiply<Output = R>, P, E> {
+pub trait ValidateExtensionMethod<G: Timestamp, R: Monoid+Multiply<Output = R>, P, E> {
     fn validate_using<PE: PrefixExtender<G, R, Prefix=P, Extension=E>>(self, extender: &mut PE) -> VecCollection<G, (P, E), R>;
 }
 
-impl<G: Scope, R: Monoid+Multiply<Output = R>, P, E> ValidateExtensionMethod<G, R, P, E> for VecCollection<G, (P, E), R> {
+impl<G: Timestamp, R: Monoid+Multiply<Output = R>, P, E> ValidateExtensionMethod<G, R, P, E> for VecCollection<G, (P, E), R> {
     fn validate_using<PE: PrefixExtender<G, R, Prefix=P, Extension=E>>(self, extender: &mut PE) -> VecCollection<G, (P, E), R> {
         extender.validate(self)
     }
@@ -137,7 +137,7 @@ where
     R: Monoid+Multiply<Output = R>+ExchangeData,
 {
 
-    pub fn index<G: Scope<Timestamp = T>>(collection: VecCollection<G, (K, V), R>) -> Self {
+    pub fn index(collection: VecCollection<T, (K, V), R>) -> Self {
         // We need to count the number of (k, v) pairs and not rely on the given Monoid R and its binary addition operation.
         // counts and validate can share the base arrangement
         let arranged = collection.clone().arrange_by_self();
@@ -180,9 +180,9 @@ where
     key_selector: F,
 }
 
-impl<G, K, V, R, P, F> PrefixExtender<G, R> for CollectionExtender<K, V, G::Timestamp, R, P, F>
+impl<G, K, V, R, P, F> PrefixExtender<G, R> for CollectionExtender<K, V, G, R, P, F>
 where
-    G: Scope<Timestamp: Lattice+ExchangeData+Hash>,
+    G: Timestamp + Lattice + ExchangeData + Hash,
     K: ExchangeData+Hash+Default,
     V: ExchangeData+Hash+Default,
     P: ExchangeData,
diff --git a/dogsdogsdogs/src/operators/count.rs b/dogsdogsdogs/src/operators/count.rs
index 42367a2e1..b6a3b587c 100644
--- a/dogsdogsdogs/src/operators/count.rs
+++ b/dogsdogsdogs/src/operators/count.rs
@@ -1,4 +1,4 @@
-use timely::dataflow::Scope;
+use timely::progress::Timestamp;
 
 use differential_dataflow::{ExchangeData, VecCollection, Hashable};
 use differential_dataflow::difference::{Semigroup, Monoid, Multiply};
@@ -18,8 +18,8 @@ pub fn count<G, Tr, K, R, F, P>(
     index: usize,
 ) -> VecCollection<G, (P, usize, usize), R>
 where
-    G: Scope<Timestamp=Tr::Time>,
-    Tr: TraceReader<Time: std::hash::Hash, Diff=isize>+Clone+'static,
+    G: Timestamp + std::hash::Hash,
+    Tr: TraceReader<Time = G, Diff=isize>+Clone+'static,
     Tr::KeyContainer: differential_dataflow::trace::implementations::BatchContainer<Owned=K>,
     for<'a> Tr::Diff : Semigroup<Tr::DiffGat<'a>>,
     K: Hashable + Ord + Default + 'static,
diff --git a/dogsdogsdogs/src/operators/half_join.rs b/dogsdogsdogs/src/operators/half_join.rs
index 16aa59876..4492ad6a8 100644
--- a/dogsdogsdogs/src/operators/half_join.rs
+++ b/dogsdogsdogs/src/operators/half_join.rs
@@ -38,9 +38,10 @@ use std::time::Instant;
 use timely::ContainerBuilder;
 use timely::container::CapacityContainerBuilder;
 use timely::dataflow::{Scope, Stream};
+use timely::scheduling::Scheduler;
 use timely::dataflow::channels::pact::{Pipeline, Exchange};
 use timely::dataflow::operators::{Capability, Operator, generic::Session};
-use timely::progress::Antichain;
+use timely::progress::{Antichain, Timestamp};
 use timely::progress::frontier::AntichainRef;
 
 use differential_dataflow::{ExchangeData, VecCollection, AsCollection, Hashable};
@@ -74,26 +75,27 @@ use differential_dataflow::trace::implementations::BatchContainer;
 /// once out of the "delta flow region", the updates will be `delay`d to the
 /// times specified in the payloads.
 pub fn half_join<G, K, V, R, Tr, FF, CF, DOut, S>(
-    stream: VecCollection<G, (K, V, G::Timestamp), R>,
+    stream: VecCollection<G, (K, V, G), R>,
     arrangement: Arranged<G, Tr>,
     frontier_func: FF,
     comparison: CF,
     mut output_func: S,
-) -> VecCollection<G, (DOut, G::Timestamp), <R as Mul<Tr::Diff>>::Output>
+) -> VecCollection<G, (DOut, G), <R as Mul<Tr::Diff>>::Output>
 where
-    G: Scope<Timestamp = Tr::Time>,
+    G: Timestamp + Lattice,
     K: Hashable + ExchangeData,
     V: ExchangeData,
     R: ExchangeData + Monoid,
-    Tr: TraceReader<Time: std::hash::Hash>+Clone+'static,
+    Tr: TraceReader<Time = G>+Clone+'static,
+    G: std::hash::Hash,
     Tr::KeyContainer: BatchContainer<Owned=K>,
     R: Mul<Tr::Diff, Output: Semigroup>,
-    FF: Fn(&G::Timestamp, &mut Antichain<G::Timestamp>) + 'static,
-    CF: Fn(Tr::TimeGat<'_>, &G::Timestamp) -> bool + 'static,
+    FF: Fn(&G, &mut Antichain<G>) + 'static,
+    CF: Fn(Tr::TimeGat<'_>, &G) -> bool + 'static,
     DOut: Clone+'static,
     S: FnMut(&K, &V, Tr::Val<'_>)->DOut+'static,
 {
-    let output_func = move |session: &mut SessionFor<G, _>, k: &K, v1: &V, v2: Tr::Val<'_>, initial: &G::Timestamp, diff1: &R, output: &mut Vec<(G::Timestamp, Tr::Diff)>| {
+    let output_func = move |session: &mut SessionFor<G, _>, k: &K, v1: &V, v2: Tr::Val<'_>, initial: &G, diff1: &R, output: &mut Vec<(G, Tr::Diff)>| {
         for (time, diff2) in output.drain(..) {
             let diff = diff1.clone() * diff2.clone();
             let dout = (output_func(k, v1, v2), time.clone());
@@ -109,9 +111,9 @@ where
 /// This is a shorthand primarily for the reson of readability.
 type SessionFor<'a, 'b, G, CB> =
     Session<'a, 'b,
-        <G as Scope>::Timestamp,
+        G,
         CB,
-        Capability<<G as Scope>::Timestamp>,
+        Capability<G>,
     >;
 
 /// An unsafe variant of `half_join` where the `output_func` closure takes
@@ -140,7 +142,7 @@ type SessionFor<'a, 'b, G, CB> =
 /// records. Note this is not the number of *output* records, owing mainly to
 /// the number of matched records being easiest to record with low overhead.
 pub fn half_join_internal_unsafe<G, K, V, R, Tr, FF, CF, Y, S, CB>(
-    stream: VecCollection<G, (K, V, G::Timestamp), R>,
+    stream: VecCollection<G, (K, V, G), R>,
     mut arrangement: Arranged<G, Tr>,
     frontier_func: FF,
     comparison: CF,
@@ -148,16 +150,17 @@ pub fn half_join_internal_unsafe<G, K, V, R, Tr, FF, CF, Y, S, CB>(
     mut output_func: S,
 ) -> Stream<G, CB::Container>
 where
-    G: Scope<Timestamp = Tr::Time>,
+    G: Timestamp + Lattice,
     K: Hashable + ExchangeData,
     V: ExchangeData,
     R: ExchangeData + Monoid,
-    Tr: TraceReader<Time: std::hash::Hash>+Clone+'static,
+    Tr: TraceReader<Time = G>+Clone+'static,
+    G: std::hash::Hash,
     Tr::KeyContainer: BatchContainer<Owned=K>,
-    FF: Fn(&G::Timestamp, &mut Antichain<G::Timestamp>) + 'static,
+    FF: Fn(&G, &mut Antichain<G>) + 'static,
     CF: Fn(Tr::TimeGat<'_>, &Tr::Time) -> bool + 'static,
     Y: Fn(std::time::Instant, usize) -> bool + 'static,
-    S: FnMut(&mut SessionFor<G, CB>, &K, &V, Tr::Val<'_>, &G::Timestamp, &R, &mut Vec<(G::Timestamp, Tr::Diff)>) + 'static,
+    S: FnMut(&mut SessionFor<G, CB>, &K, &V, Tr::Val<'_>, &G, &R, &mut Vec<(G, Tr::Diff)>) + 'static,
     CB: ContainerBuilder,
 {
     // No need to block physical merging for this operator.
@@ -167,7 +170,7 @@ where
 
     let mut stash = HashMap::new();
 
-    let exchange = Exchange::new(move |update: &((K, V, G::Timestamp),G::Timestamp,R)| (update.0).0.hashed().into());
+    let exchange = Exchange::new(move |update: &((K, V, G),G,R)| (update.0).0.hashed().into());
 
     // Stash for (time, diff) accumulation.
     let mut output_buffer = Vec::new();
@@ -313,12 +316,12 @@ fn process_proposals<G, Tr, CF, Y, S, CB, K, V, R>(
     frontier: AntichainRef<Tr::Time>
 ) -> bool
 where
-    G: Scope<Timestamp = Tr::Time>,
-    Tr: TraceReader,
+    G: Timestamp + Lattice,
+    Tr: TraceReader<Time = G>,
     Tr::KeyContainer: BatchContainer<Owned=K>,
     CF: Fn(Tr::TimeGat<'_>, &Tr::Time) -> bool + 'static,
     Y: Fn(Instant, usize) -> bool + 'static,
-    S: FnMut(&mut SessionFor<G, CB>, &K, &V, Tr::Val<'_>, &G::Timestamp, &R, &mut Vec<(G::Timestamp, Tr::Diff)>) + 'static,
+    S: FnMut(&mut SessionFor<G, CB>, &K, &V, Tr::Val<'_>, &G, &R, &mut Vec<(G, Tr::Diff)>) + 'static,
     CB: ContainerBuilder,
     K: Ord,
     V: Ord,
diff --git a/dogsdogsdogs/src/operators/half_join2.rs b/dogsdogsdogs/src/operators/half_join2.rs
index 08029f96e..c8ef7ae8e 100644
--- a/dogsdogsdogs/src/operators/half_join2.rs
+++ b/dogsdogsdogs/src/operators/half_join2.rs
@@ -23,6 +23,7 @@ use std::ops::Mul;
 use timely::ContainerBuilder;
 use timely::container::CapacityContainerBuilder;
 use timely::dataflow::{Scope, Stream};
+use timely::scheduling::Scheduler;
 use timely::dataflow::channels::pact::{Pipeline, Exchange};
 use timely::dataflow::operators::Operator;
 use timely::PartialOrder;
@@ -62,26 +63,27 @@ use timely::dataflow::operators::CapabilitySet;
 /// once out of the "delta flow region", the updates will be `delay`d to the
 /// times specified in the payloads.
 pub fn half_join<G, K, V, R, Tr, FF, CF, DOut, S>(
-    stream: VecCollection<G, (K, V, G::Timestamp), R>,
+    stream: VecCollection<G, (K, V, G), R>,
     arrangement: Arranged<G, Tr>,
     frontier_func: FF,
     comparison: CF,
     mut output_func: S,
-) -> VecCollection<G, (DOut, G::Timestamp), <R as Mul<Tr::Diff>>::Output>
+) -> VecCollection<G, (DOut, G), <R as Mul<Tr::Diff>>::Output>
 where
-    G: Scope<Timestamp = Tr::Time>,
+    G: Timestamp + Lattice,
     K: Hashable + ExchangeData,
     V: ExchangeData,
     R: ExchangeData + Monoid,
-    Tr: TraceReader<Time: std::hash::Hash>+Clone+'static,
+    Tr: TraceReader<Time = G>+Clone+'static,
+    G: std::hash::Hash,
     Tr::KeyContainer: BatchContainer<Owned=K>,
     R: Mul<Tr::Diff, Output: Semigroup>,
-    FF: Fn(&G::Timestamp, &mut Antichain<G::Timestamp>) + 'static,
-    CF: Fn(Tr::TimeGat<'_>, &G::Timestamp) -> bool + 'static,
+    FF: Fn(&G, &mut Antichain<G>) + 'static,
+    CF: Fn(Tr::TimeGat<'_>, &G) -> bool + 'static,
     DOut: Clone+'static,
     S: FnMut(&K, &V, Tr::Val<'_>)->DOut+'static,
 {
-    let output_func = move |builder: &mut CapacityContainerBuilder<Vec<_>>, k: &K, v1: &V, v2: Tr::Val<'_>, initial: &G::Timestamp, diff1: &R, output: &mut Vec<(G::Timestamp, Tr::Diff)>| {
+    let output_func = move |builder: &mut CapacityContainerBuilder<Vec<_>>, k: &K, v1: &V, v2: Tr::Val<'_>, initial: &G, diff1: &R, output: &mut Vec<(G, Tr::Diff)>| {
         for (time, diff2) in output.drain(..) {
             let diff = diff1.clone() * diff2.clone();
             let dout = (output_func(k, v1, v2), time.clone());
@@ -119,7 +121,7 @@ where
 /// records. Note this is not the number of *output* records, owing mainly to
 /// the number of matched records being easiest to record with low overhead.
 pub fn half_join_internal_unsafe<G, K, V, R, Tr, FF, CF, Y, S, CB>(
-    stream: VecCollection<G, (K, V, G::Timestamp), R>,
+    stream: VecCollection<G, (K, V, G), R>,
     mut arrangement: Arranged<G, Tr>,
     frontier_func: FF,
     comparison: CF,
@@ -127,16 +129,17 @@ pub fn half_join_internal_unsafe<G, K, V, R, Tr, FF, CF, Y, S, CB>(
     mut output_func: S,
 ) -> Stream<G, CB::Container>
 where
-    G: Scope<Timestamp = Tr::Time>,
+    G: Timestamp + Lattice,
     K: Hashable + ExchangeData,
     V: ExchangeData,
     R: ExchangeData + Monoid,
-    Tr: TraceReader<Time: std::hash::Hash>+Clone+'static,
+    Tr: TraceReader<Time = G>+Clone+'static,
+    G: std::hash::Hash,
     Tr::KeyContainer: BatchContainer<Owned=K>,
-    FF: Fn(&G::Timestamp, &mut Antichain<G::Timestamp>) + 'static,
+    FF: Fn(&G, &mut Antichain<G>) + 'static,
     CF: Fn(Tr::TimeGat<'_>, &Tr::Time) -> bool + 'static,
     Y: Fn(std::time::Instant, usize) -> bool + 'static,
-    S: FnMut(&mut CB, &K, &V, Tr::Val<'_>, &G::Timestamp, &R, &mut Vec<(G::Timestamp, Tr::Diff)>) + 'static,
+    S: FnMut(&mut CB, &K, &V, Tr::Val<'_>, &G, &R, &mut Vec<(G, Tr::Diff)>) + 'static,
     CB: ContainerBuilder,
 {
     // No need to block physical merging for this operator.
@@ -144,7 +147,7 @@ where
     let mut arrangement_trace = Some(arrangement.trace);
     let arrangement_stream = arrangement.stream;
 
-    let exchange = Exchange::new(move |update: &((K, V, G::Timestamp),G::Timestamp,R)| (update.0).0.hashed().into());
+    let exchange = Exchange::new(move |update: &((K, V, G),G,R)| (update.0).0.hashed().into());
 
     // Stash for (time, diff) accumulation.
     let mut output_buffer = Vec::new();
@@ -152,7 +155,7 @@ where
     // Unified blobs: each blob holds data in (T, D, R) order, with a stuck_count
     // tracking how many elements at the back are not yet eligible for processing.
     // The ready prefix is sorted by (D, T, R) for cursor traversal.
-    let mut blobs: Vec<Blob<(K, V, G::Timestamp), G::Timestamp, R>> = Vec::new();
+    let mut blobs: Vec<Blob<(K, V, G), G, R>> = Vec::new();
 
     let scope = stream.scope();
     stream.inner.binary_frontier(arrangement_stream, exchange, Pipeline, "HalfJoin", move |_,info| {
@@ -163,7 +166,7 @@ where
         move |(input1, frontier1), (input2, frontier2), output| {
 
             // Drain all input into a single buffer.
-            let mut arriving: Vec<(G::Timestamp, (K, V, G::Timestamp), R)> = Vec::new();
+            let mut arriving: Vec<(G, (K, V, G), R)> = Vec::new();
             let mut caps = CapabilitySet::new();
             input1.for_each(|capability, data| {
                 caps.insert(capability.retain(0));
@@ -189,7 +192,7 @@ where
                 if let Some(min_time) = frontier.iter().min() {
                     time_con.push_own(min_time);
                 }
-                let eligible = |initial: &G::Timestamp| -> bool {
+                let eligible = |initial: &G| -> bool {
                     !(0..time_con.len()).any(|i| comparison(time_con.index(i), initial))
                 };
 
@@ -265,7 +268,7 @@ where
 
                     let (mut cursor, storage) = trace.cursor();
                     let mut key_con = Tr::KeyContainer::with_capacity(1);
-                    let mut removals: ChangeBatch<G::Timestamp> = ChangeBatch::new();
+                    let mut removals: ChangeBatch<G> = ChangeBatch::new();
 
                     // Process ready elements from the front.
                     while blob.data.len() > blob.stuck_count {
diff --git a/dogsdogsdogs/src/operators/lookup_map.rs b/dogsdogsdogs/src/operators/lookup_map.rs
index 65108ed59..394cd4442 100644
--- a/dogsdogsdogs/src/operators/lookup_map.rs
+++ b/dogsdogsdogs/src/operators/lookup_map.rs
@@ -1,10 +1,9 @@
 use std::collections::HashMap;
 
 use timely::PartialOrder;
-use timely::dataflow::Scope;
 use timely::dataflow::channels::pact::{Pipeline, Exchange};
 use timely::dataflow::operators::Operator;
-use timely::progress::Antichain;
+use timely::progress::{Antichain, Timestamp};
 
 use differential_dataflow::{ExchangeData, VecCollection, AsCollection, Hashable};
 use differential_dataflow::difference::{IsZero, Semigroup, Monoid};
@@ -27,9 +26,9 @@ pub fn lookup_map<G, D, K, R, Tr, F, DOut, ROut, S>(
     supplied_key2: K,
 ) -> VecCollection<G, DOut, ROut>
 where
-    G: Scope<Timestamp=Tr::Time>,
+    G: Timestamp + std::hash::Hash,
     Tr: for<'a> TraceReader<
-        Time: std::hash::Hash,
+        Time = G,
         Diff : Semigroup<Tr::DiffGat<'a>>+Monoid+ExchangeData,
     >+Clone+'static,
     Tr::KeyContainer: BatchContainer<Owned=K>,
@@ -51,7 +50,7 @@ where
     let mut logic2 = key_selector.clone();
 
     let mut key: K = supplied_key0;
-    let exchange = Exchange::new(move |update: &(D,G::Timestamp,R)| {
+    let exchange = Exchange::new(move |update: &(D,G,R)| {
         logic1(&update.0, &mut key);
         key.hashed().into()
     });
diff --git a/dogsdogsdogs/src/operators/propose.rs b/dogsdogsdogs/src/operators/propose.rs
index 6cdcb130d..508c5aafd 100644
--- a/dogsdogsdogs/src/operators/propose.rs
+++ b/dogsdogsdogs/src/operators/propose.rs
@@ -1,4 +1,4 @@
-use timely::dataflow::Scope;
+use timely::progress::Timestamp;
 
 use differential_dataflow::{ExchangeData, VecCollection, Hashable};
 use differential_dataflow::difference::{Semigroup, Monoid, Multiply};
@@ -19,10 +19,10 @@ pub fn propose<G, Tr, K, F, P, V>(
     key_selector: F,
 ) -> VecCollection<G, (P, V), Tr::Diff>
 where
-    G: Scope<Timestamp=Tr::Time>,
+    G: Timestamp + std::hash::Hash,
     Tr: for<'a> TraceReader<
         ValOwn = V,
-        Time: std::hash::Hash,
+        Time = G,
         Diff: Monoid+Multiply<Output = Tr::Diff>+ExchangeData+Semigroup<Tr::DiffGat<'a>>,
     >+Clone+'static,
     Tr::KeyContainer: differential_dataflow::trace::implementations::BatchContainer<Owned=K>,
@@ -53,10 +53,10 @@ pub fn propose_distinct<G, Tr, K, F, P, V>(
     key_selector: F,
 ) -> VecCollection<G, (P, V), Tr::Diff>
 where
-    G: Scope<Timestamp=Tr::Time>,
+    G: Timestamp + std::hash::Hash,
     Tr: for<'a> TraceReader<
         ValOwn = V,
-        Time: std::hash::Hash,
+        Time = G,
         Diff : Semigroup<Tr::DiffGat<'a>>+Monoid+Multiply<Output = Tr::Diff>+ExchangeData,
     >+Clone+'static,
     Tr::KeyContainer: differential_dataflow::trace::implementations::BatchContainer<Owned=K>,
diff --git a/dogsdogsdogs/src/operators/validate.rs b/dogsdogsdogs/src/operators/validate.rs
index 0ab7297bb..7ac81692d 100644
--- a/dogsdogsdogs/src/operators/validate.rs
+++ b/dogsdogsdogs/src/operators/validate.rs
@@ -1,6 +1,6 @@
 use std::hash::Hash;
 
-use timely::dataflow::Scope;
+use timely::progress::Timestamp;
 
 use differential_dataflow::{ExchangeData, VecCollection};
 use differential_dataflow::difference::{Semigroup, Monoid, Multiply};
@@ -18,9 +18,9 @@ pub fn validate<G, K, V, Tr, F, P>(
     key_selector: F,
 ) -> VecCollection<G, (P, V), Tr::Diff>
 where
-    G: Scope<Timestamp=Tr::Time>,
+    G: Timestamp + std::hash::Hash,
     Tr: for<'a> TraceReader<
-        Time: std::hash::Hash,
+        Time = G,
         Diff : Semigroup<Tr::DiffGat<'a>>+Monoid+Multiply<Output = Tr::Diff>+ExchangeData,
     >+Clone+'static,
     Tr::KeyContainer: differential_dataflow::trace::implementations::BatchContainer<Owned=(K,V)>,
diff --git a/experiments/Cargo.toml b/experiments/Cargo.toml
index edcf55fb3..ff46dd329 100644
--- a/experiments/Cargo.toml
+++ b/experiments/Cargo.toml
@@ -12,7 +12,7 @@ workspace = true
 [dependencies]
 core_affinity = "0.5.9"
 rand="0.3.13"
-timely = { workspace = true }
+timely = { workspace = true, features = ["getopts"] }
 differential-dataflow = { workspace = true }
 graph_map = { git = "https://github.com/frankmcsherry/graph-map" }
 serde = { version = "1.0", features = ["derive"] }
diff --git a/experiments/src/bin/deals-interactive.rs b/experiments/src/bin/deals-interactive.rs
index 83c7ae960..a0e3c90df 100644
--- a/experiments/src/bin/deals-interactive.rs
+++ b/experiments/src/bin/deals-interactive.rs
@@ -13,7 +13,7 @@ use differential_dataflow::trace::implementations::ValSpine;
 use differential_dataflow::operators::arrange::TraceAgent;
 use differential_dataflow::operators::arrange::Arranged;
 
-type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, <G as Scope>::Timestamp, R>>>;
+type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, G, R>>>;
 
 type Node = u32;
 
@@ -204,13 +204,12 @@ fn main() {
     }).unwrap();
 }
 
-fn interactive<G: Scope>(
+fn interactive<G: timely::progress::Timestamp + Lattice>(
     edges: Arrange<G, Node, Node, isize>,
     tc_1: VecCollection<G, Node>,
     tc_2: VecCollection<G, Node>,
     sg_x: VecCollection<G, Node>
-) -> VecCollection<G, Node>
-where G::Timestamp: Lattice{
+) -> VecCollection<G, Node> {
 
     // descendants of tc_1:
     let tc_1_enter = tc_1.clone();
diff --git a/experiments/src/bin/deals.rs b/experiments/src/bin/deals.rs
index f67e34146..47d7892d9 100644
--- a/experiments/src/bin/deals.rs
+++ b/experiments/src/bin/deals.rs
@@ -11,9 +11,10 @@ use differential_dataflow::operators::arrange::TraceAgent;
 use differential_dataflow::operators::arrange::Arranged;
 use differential_dataflow::operators::arrange::Arrange;
 use differential_dataflow::operators::iterate::Variable;
+use differential_dataflow::lattice::Lattice;
 use differential_dataflow::difference::Present;
 
-type EdgeArranged<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, <G as Scope>::Timestamp, R>>>;
+type EdgeArranged<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, G, R>>>;
 
 type Node = u32;
 type Edge = (Node, Node);
@@ -83,7 +84,7 @@ fn main() {
 use timely::order::Product;
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn tc<G: Scope<Timestamp=()>>(edges: EdgeArranged<G, Node, Node, Present>) -> VecCollection<G, Edge, Present> {
+fn tc<G: timely::progress::Timestamp + Lattice + Default + timely::order::Empty>(edges: EdgeArranged<G, Node, Node, Present>) -> VecCollection<G, Edge, Present> {
 
     // repeatedly update minimal distances each node can be reached from each root
     let outer = edges.stream.scope();
@@ -109,7 +110,7 @@ fn tc<G: Scope<Timestamp=()>>(edges: EdgeArranged<G, Node, Node, Present>) -> Ve
 }
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn sg<G: Scope<Timestamp=()>>(edges: EdgeArranged<G, Node, Node, Present>) -> VecCollection<G, Edge, Present> {
+fn sg<G: timely::progress::Timestamp + Lattice + Default + timely::order::Empty>(edges: EdgeArranged<G, Node, Node, Present>) -> VecCollection<G, Edge, Present> {
 
     let peers = edges.clone().join_core(edges.clone(), |_,&x,&y| Some((x,y))).filter(|&(x,y)| x != y);
 
diff --git a/experiments/src/bin/graphs-interactive-alt.rs b/experiments/src/bin/graphs-interactive-alt.rs
index d7533d4a0..ddcaf349a 100644
--- a/experiments/src/bin/graphs-interactive-alt.rs
+++ b/experiments/src/bin/graphs-interactive-alt.rs
@@ -3,6 +3,7 @@
 use rand::{Rng, SeedableRng, StdRng};
 
 use timely::dataflow::*;
+use timely::progress::Timestamp;
 use timely::dataflow::operators::probe::Handle;
 use timely::order::Product;
 
@@ -258,14 +259,14 @@ use differential_dataflow::trace::implementations::ValSpine;
 use differential_dataflow::operators::arrange::TraceAgent;
 use differential_dataflow::operators::arrange::Arranged;
 
-type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, <G as Scope>::Timestamp, R>>>;
+type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, G, R>>>;
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn three_hop<G: Scope>(
+fn three_hop<G: Timestamp + Lattice + Ord>(
     forward_graph: Arrange<G, Node, Node, isize>,
     reverse_graph: Arrange<G, Node, Node, isize>,
     goals: VecCollection<G, (Node, Node)>) -> VecCollection<G, ((Node, Node), u32)>
-where G::Timestamp: Lattice+Ord {
+{
 
     let sources = goals.clone().map(|(x,_)| x);
     let targets = goals.map(|(_,y)| y);
@@ -288,11 +289,11 @@ where G::Timestamp: Lattice+Ord {
 }
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn _bidijkstra<G: Scope>(
+fn _bidijkstra<G: Timestamp + Lattice + Ord>(
     forward_graph: Arrange<G, Node, Node, isize>,
     reverse_graph: Arrange<G, Node, Node, isize>,
     goals: VecCollection<G, (Node, Node)>) -> VecCollection<G, ((Node, Node), u32)>
-where G::Timestamp: Lattice+Ord {
+{
 
     let outer = goals.scope();
     outer.iterative::<Iter,_,_>(|inner| {
@@ -362,8 +363,9 @@ where G::Timestamp: Lattice+Ord {
 }
 
 
-fn connected_components<G: Scope>(graph: Arrange<G, Node, Node, isize>) -> VecCollection<G, (Node, Node)>
-where G::Timestamp: Lattice + std::hash::Hash {
+fn connected_components<G: Timestamp + Lattice + Ord>(graph: Arrange<G, Node, Node, isize>) -> VecCollection<G, (Node, Node)>
+where G: Lattice + std::hash::Hash
+{
 
     // each edge (x,y) means that we need at least a label for the min of x and y.
     let nodes =
diff --git a/experiments/src/bin/graphs-interactive-neu-zwei.rs b/experiments/src/bin/graphs-interactive-neu-zwei.rs
index 62675f93f..f2f1bc5be 100644
--- a/experiments/src/bin/graphs-interactive-neu-zwei.rs
+++ b/experiments/src/bin/graphs-interactive-neu-zwei.rs
@@ -1,6 +1,7 @@
 use rand::{Rng, SeedableRng, StdRng};
 
 use timely::dataflow::*;
+use timely::progress::Timestamp;
 use timely::dataflow::operators::probe::Handle;
 
 use differential_dataflow::input::Input;
@@ -226,14 +227,14 @@ use differential_dataflow::trace::implementations::ValSpine;
 use differential_dataflow::operators::arrange::TraceAgent;
 use differential_dataflow::operators::arrange::Arranged;
 
-type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, <G as Scope>::Timestamp, R>>>;
+type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, G, R>>>;
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn three_hop<G: Scope>(
+fn three_hop<G: Timestamp + Lattice + Ord>(
     forward_graph: Arrange<G, Node, Node, isize>,
     reverse_graph: Arrange<G, Node, Node, isize>,
     goals: VecCollection<G, (Node, Node)>) -> VecCollection<G, ((Node, Node), u32)>
-where G::Timestamp: Lattice+Ord {
+{
 
     let sources = goals.clone().map(|(x,_)| x);
     let targets = goals.map(|(_,y)| y);
@@ -256,12 +257,12 @@ where G::Timestamp: Lattice+Ord {
 }
 
 // // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-// fn bidijkstra<G: Scope>(
+// fn bidijkstra<G: Timestamp + Lattice + Ord>(
 //     forward_graph: &Arrange<G, Node, Node, isize>,
 //     reverse_graph: &Arrange<G, Node, Node, isize>,
 //     goals: VecCollection<G, (Node, Node)>,
 //     bound: u64) -> VecCollection<G, ((Node, Node), u32)>
-// where G::Timestamp: Lattice+Ord {
+// where G: Lattice+Ord {
 
 //     goals.scope().scoped(|inner| {
 
diff --git a/experiments/src/bin/graphs-interactive-neu.rs b/experiments/src/bin/graphs-interactive-neu.rs
index dcc00b0b9..935fe6735 100644
--- a/experiments/src/bin/graphs-interactive-neu.rs
+++ b/experiments/src/bin/graphs-interactive-neu.rs
@@ -3,6 +3,7 @@
 use rand::{Rng, SeedableRng, StdRng};
 
 use timely::dataflow::*;
+use timely::progress::Timestamp;
 use timely::dataflow::operators::probe::Handle;
 use timely::order::Product;
 
@@ -291,14 +292,14 @@ use differential_dataflow::trace::implementations::ValSpine;
 use differential_dataflow::operators::arrange::TraceAgent;
 use differential_dataflow::operators::arrange::Arranged;
 
-type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, <G as Scope>::Timestamp, R>>>;
+type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, G, R>>>;
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn three_hop<G: Scope>(
+fn three_hop<G: Timestamp + Lattice + Ord>(
     forward_graph: Arrange<G, Node, Node, isize>,
     reverse_graph: Arrange<G, Node, Node, isize>,
     goals: VecCollection<G, (Node, Node)>) -> VecCollection<G, ((Node, Node), u32)>
-where G::Timestamp: Lattice+Ord {
+{
 
     let sources = goals.clone().map(|(x,_)| x);
     let targets = goals.map(|(_,y)| y);
@@ -321,11 +322,11 @@ where G::Timestamp: Lattice+Ord {
 }
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn _bidijkstra<G: Scope>(
+fn _bidijkstra<G: Timestamp + Lattice + Ord>(
     forward_graph: Arrange<G, Node, Node, isize>,
     reverse_graph: Arrange<G, Node, Node, isize>,
     goals: VecCollection<G, (Node, Node)>) -> VecCollection<G, ((Node, Node), u32)>
-where G::Timestamp: Lattice+Ord {
+{
 
     let outer = goals.scope();
     outer.iterative::<Iter,_,_>(|inner| {
diff --git a/experiments/src/bin/graphs-interactive.rs b/experiments/src/bin/graphs-interactive.rs
index 54fc27309..8c099dc0d 100644
--- a/experiments/src/bin/graphs-interactive.rs
+++ b/experiments/src/bin/graphs-interactive.rs
@@ -1,6 +1,7 @@
 use rand::{Rng, SeedableRng, StdRng};
 
 use timely::dataflow::*;
+use timely::progress::Timestamp;
 use timely::dataflow::operators::probe::Handle;
 use timely::order::Product;
 
@@ -194,15 +195,15 @@ use differential_dataflow::trace::implementations::ValSpine;
 use differential_dataflow::operators::arrange::TraceAgent;
 use differential_dataflow::operators::arrange::Arranged;
 
-type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, <G as Scope>::Timestamp, R>>>;
+type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, G, R>>>;
 
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn three_hop<G: Scope>(
+fn three_hop<G: Timestamp + Lattice + Ord>(
     forward_graph: Arrange<G, Node, Node, isize>,
     reverse_graph: Arrange<G, Node, Node, isize>,
     goals: VecCollection<G, (Node, Node)>) -> VecCollection<G, ((Node, Node), u32)>
-where G::Timestamp: Lattice+Ord {
+{
 
     let sources = goals.clone().map(|(x,_)| x);
     let targets = goals.map(|(_,y)| y);
@@ -225,11 +226,11 @@ where G::Timestamp: Lattice+Ord {
 }
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn _bidijkstra<G: Scope>(
+fn _bidijkstra<G: Timestamp + Lattice + Ord>(
     forward_graph: Arrange<G, Node, Node, isize>,
     reverse_graph: Arrange<G, Node, Node, isize>,
     goals: VecCollection<G, (Node, Node)>) -> VecCollection<G, ((Node, Node), u32)>
-where G::Timestamp: Lattice+Ord {
+{
 
     let outer = goals.scope();
     outer.iterative::<usize,_,_>(|inner| {
diff --git a/experiments/src/bin/graphs-static.rs b/experiments/src/bin/graphs-static.rs
index 7c382d645..cd3a0567f 100644
--- a/experiments/src/bin/graphs-static.rs
+++ b/experiments/src/bin/graphs-static.rs
@@ -106,10 +106,10 @@ use differential_dataflow::operators::arrange::TraceAgent;
 
 type TraceHandle = TraceAgent<GraphTrace>;
 
-fn reach<G: Scope<Timestamp = ()>> (
+fn reach(
     graph: &mut TraceHandle,
-    roots: VecCollection<G, Node, Diff>
-) -> VecCollection<G, Node, Diff> {
+    roots: VecCollection<(), Node, Diff>
+) -> VecCollection<(), Node, Diff> {
 
     let graph = graph.import(&roots.scope());
 
@@ -132,10 +132,10 @@ fn reach<G: Scope<Timestamp = ()>> (
 }
 
 
-fn bfs<G: Scope<Timestamp = ()>> (
+fn bfs(
     graph: &mut TraceHandle,
-    roots: VecCollection<G, Node, Diff>
-) -> VecCollection<G, (Node, u32), Diff> {
+    roots: VecCollection<(), Node, Diff>
+) -> VecCollection<(), (Node, u32), Diff> {
 
     let graph = graph.import(&roots.scope());
     let roots = roots.map(|r| (r,0));
@@ -157,11 +157,11 @@ fn bfs<G: Scope<Timestamp = ()>> (
     })
 }
 
-fn connected_components<G: Scope<Timestamp = ()>>(
-    scope: &mut G,
+fn connected_components(
+    scope: &mut timely::dataflow::Scope<()>,
     forward: &mut TraceHandle,
     reverse: &mut TraceHandle,
-) -> VecCollection<G, (Node, Node), Diff> {
+) -> VecCollection<(), (Node, Node), Diff> {
 
     let forward = forward.import(scope);
     let reverse = reverse.import(scope);
diff --git a/experiments/src/bin/graphs.rs b/experiments/src/bin/graphs.rs
index ea7420120..b5846595d 100644
--- a/experiments/src/bin/graphs.rs
+++ b/experiments/src/bin/graphs.rs
@@ -88,10 +88,10 @@ use differential_dataflow::operators::arrange::TraceAgent;
 
 type TraceHandle = TraceAgent<GraphTrace>;
 
-fn reach<G: Scope<Timestamp = ()>> (
+fn reach(
     graph: &mut TraceHandle,
-    roots: VecCollection<G, Node>
-) -> VecCollection<G, Node> {
+    roots: VecCollection<(), Node>
+) -> VecCollection<(), Node> {
 
     let graph = graph.import(&roots.scope());
 
@@ -110,10 +110,10 @@ fn reach<G: Scope<Timestamp = ()>> (
 }
 
 
-fn bfs<G: Scope<Timestamp = ()>> (
+fn bfs(
     graph: &mut TraceHandle,
-    roots: VecCollection<G, Node>
-) -> VecCollection<G, (Node, u32)> {
+    roots: VecCollection<(), Node>
+) -> VecCollection<(), (Node, u32)> {
 
     let graph = graph.import(&roots.scope());
     let roots = roots.map(|r| (r,0));
@@ -129,9 +129,9 @@ fn bfs<G: Scope<Timestamp = ()>> (
     })
 }
 
-// fn connected_components<G: Scope<Timestamp = ()>>(
+// fn connected_components(
 //     graph: &mut TraceHandle<Node>
-// ) -> VecCollection<G, (Node, Node)> {
+// ) -> VecCollection<(), (Node, Node)> {
 
 //     // each edge (x,y) means that we need at least a label for the min of x and y.
 //     let nodes =
diff --git a/interactive/src/command.rs b/interactive/src/command.rs
index 5d110ea70..ba83fca60 100644
--- a/interactive/src/command.rs
+++ b/interactive/src/command.rs
@@ -4,7 +4,6 @@ use std::hash::Hash;
 use std::io::Write;
 use serde::{Deserialize, Serialize};
 
-use timely::communication::Allocate;
 use timely::worker::Worker;
 
 use timely::logging::TimelyEvent;
@@ -48,7 +47,7 @@ where
 {
 
     /// Executes a command.
-    pub fn execute<A: Allocate>(self, manager: &mut Manager<V>, worker: &mut Worker<A>) {
+    pub fn execute(self, manager: &mut Manager<V>, worker: &mut Worker) {
 
         match self {
 
diff --git a/interactive/src/logging.rs b/interactive/src/logging.rs
index 322dd16d2..0b076f36f 100644
--- a/interactive/src/logging.rs
+++ b/interactive/src/logging.rs
@@ -3,7 +3,6 @@
 use std::hash::Hash;
 use std::time::Duration;
 
-use timely::communication::Allocate;
 use timely::worker::Worker;
 use timely::logging::TimelyEvent;
 use timely::dataflow::operators::capture::event::EventIterator;
@@ -20,16 +19,15 @@ pub trait LoggingValue : VectorFrom<TimelyEvent>+VectorFrom<DifferentialEvent> {
 impl<V: VectorFrom<TimelyEvent>+VectorFrom<DifferentialEvent>> LoggingValue for V { }
 
 /// Timely logging capture and arrangement.
-pub fn publish_timely_logging<V, A, I>(
+pub fn publish_timely_logging<V, I>(
     manager: &mut Manager<V>,
-    worker: &mut Worker<A>,
+    worker: &mut Worker,
     granularity_ns: u64,
     name: &str,
     events: I
 )
 where
     V: ExchangeData+Hash+LoggingValue+Datum,
-    A: Allocate,
     I : IntoIterator,
     <I as IntoIterator>::Item: EventIterator<Duration, Vec<(Duration, usize, TimelyEvent)>>+'static
 {
@@ -209,16 +207,15 @@ where
 }
 
 /// Timely logging capture and arrangement.
-pub fn publish_differential_logging<V, A, I>(
+pub fn publish_differential_logging<V, I>(
     manager: &mut Manager<V>,
-    worker: &mut Worker<A>,
+    worker: &mut Worker,
     granularity_ns: u64,
     name: &str,
     events: I
 )
 where
     V: ExchangeData+Hash+LoggingValue+Datum,
-    A: Allocate,
     I : IntoIterator,
     <I as IntoIterator>::Item: EventIterator<Duration, Vec<(Duration, usize, DifferentialEvent)>>+'static
 {
diff --git a/interactive/src/manager.rs b/interactive/src/manager.rs
index 8579a538e..f9a0f3872 100644
--- a/interactive/src/manager.rs
+++ b/interactive/src/manager.rs
@@ -5,7 +5,6 @@ use std::hash::Hash;
 // use std::time::Duration;
 
 use timely::dataflow::ProbeHandle;
-use timely::communication::Allocate;
 use timely::worker::Worker;
 use timely::logging::TimelyEventBuilder;
 
@@ -79,7 +78,7 @@ impl<V: ExchangeData+Datum> Manager<V>
     // }
 
     /// Clear the managed inputs and traces.
-    pub fn shutdown<A: Allocate>(&mut self, worker: &mut Worker<A>) {
+    pub fn shutdown(&mut self, worker: &mut Worker) {
         self.inputs.sessions.clear();
         self.traces.inputs.clear();
         self.traces.arrangements.clear();
diff --git a/interactive/src/plan/concat.rs b/interactive/src/plan/concat.rs
index 4c27941bb..149b81049 100644
--- a/interactive/src/plan/concat.rs
+++ b/interactive/src/plan/concat.rs
@@ -19,10 +19,10 @@ impl<V: ExchangeData+Hash+Datum> Render for Concat<V> {
 
     type Value = V;
 
-    fn render<S: Scope<Timestamp = Time>>(
+    fn render(
         &self,
-        scope: &mut S,
-        arrangements: &mut TraceManager<V>) -> VecCollection<S, Vec<Self::Value>, Diff>
+        scope: &mut Scope<Time>,
+        arrangements: &mut TraceManager<V>) -> VecCollection<Time, Vec<Self::Value>, Diff>
     {
         use timely::dataflow::operators::Concatenate;
         use differential_dataflow::AsCollection;
diff --git a/interactive/src/plan/filter.rs b/interactive/src/plan/filter.rs
index ba508f151..7157d7d4f 100644
--- a/interactive/src/plan/filter.rs
+++ b/interactive/src/plan/filter.rs
@@ -84,12 +84,12 @@ impl<V: ExchangeData+Hash+Datum> Render for Filter<V> {
 
     type Value = V;
 
-    fn render<S: Scope<Timestamp = Time>>(
+    fn render(
         &self,
-        scope: &mut S,
-        collections: &mut std::collections::HashMap<Plan<Self::Value>, VecCollection<S, Vec<Self::Value>, Diff>>,
+        scope: &mut Scope<Time>,
+        collections: &mut std::collections::HashMap<Plan<Self::Value>, VecCollection<Time, Vec<Self::Value>, Diff>>,
         arrangements: &mut TraceManager<Self::Value>,
-    ) -> VecCollection<S, Vec<Self::Value>, Diff>
+    ) -> VecCollection<Time, Vec<Self::Value>, Diff>
     {
         let predicate = self.predicate.clone();
         self.plan
diff --git a/interactive/src/plan/join.rs b/interactive/src/plan/join.rs
index 956fab419..e4b89e3a4 100644
--- a/interactive/src/plan/join.rs
+++ b/interactive/src/plan/join.rs
@@ -26,12 +26,12 @@ impl<V: ExchangeData+Hash+Datum> Render for Join<V> {
 
     type Value = V;
 
-    fn render<S: Scope<Timestamp = Time>>(
+    fn render(
         &self,
-        scope: &mut S,
-        collections: &mut std::collections::HashMap<Plan<Self::Value>, VecCollection<S, Vec<Self::Value>, Diff>>,
+        scope: &mut Scope<Time>,
+        collections: &mut std::collections::HashMap<Plan<Self::Value>, VecCollection<Time, Vec<Self::Value>, Diff>>,
         arrangements: &mut TraceManager<Self::Value>,
-    ) -> VecCollection<S, Vec<Self::Value>, Diff>
+    ) -> VecCollection<Time, Vec<Self::Value>, Diff>
     {
         // acquire arrangements for each input.
         let keys1 = self.keys.iter().map(|key| key.0).collect::<Vec<_>>();
diff --git a/interactive/src/plan/map.rs b/interactive/src/plan/map.rs
index 20647ce81..4f1f29775 100644
--- a/interactive/src/plan/map.rs
+++ b/interactive/src/plan/map.rs
@@ -25,12 +25,12 @@ pub struct Map<V: Datum> {
 impl<V: ExchangeData+Hash+Datum> Render for Map<V> {
     type Value = V;
 
-    fn render<S: Scope<Timestamp = Time>>(
+    fn render(
         &self,
-        scope: &mut S,
-        collections: &mut std::collections::HashMap<Plan<Self::Value>, VecCollection<S, Vec<Self::Value>, Diff>>,
+        scope: &mut Scope<Time>,
+        collections: &mut std::collections::HashMap<Plan<Self::Value>, VecCollection<Time, Vec<Self::Value>, Diff>>,
         arrangements: &mut TraceManager<Self::Value>,
-    ) -> VecCollection<S, Vec<Self::Value>, Diff>
+    ) -> VecCollection<Time, Vec<Self::Value>, Diff>
     {
         let expressions = self.expressions.clone();
 
diff --git a/interactive/src/plan/mod.rs b/interactive/src/plan/mod.rs
index 31d99041d..dd079282c 100644
--- a/interactive/src/plan/mod.rs
+++ b/interactive/src/plan/mod.rs
@@ -32,13 +32,12 @@ pub trait Render : Sized {
     ///
     /// This method has access to arranged data, and may rely on and update the set
     /// of arrangements based on the needs and offerings of the rendering process.
-    fn render<S: Scope<Timestamp = Time>>(
+    fn render(
         &self,
-        scope: &mut S,
-        collections: &mut std::collections::HashMap<Plan<Self::Value>, VecCollection<S, Vec<Self::Value>, Diff>>,
+        scope: &mut Scope<Time>,
+        collections: &mut std::collections::HashMap<Plan<Self::Value>, VecCollection<Time, Vec<Self::Value>, Diff>>,
         arrangements: &mut TraceManager<Self::Value>,
-    ) -> VecCollection<S, Vec<Self::Value>, Diff>;
-}
+    ) -> VecCollection<Time, Vec<Self::Value>, Diff>;}
 
 /// Possible query plan types.
 #[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
@@ -142,12 +141,12 @@ impl<V: ExchangeData+Hash+Datum> Render for Plan<V> {
 
     type Value = V;
 
-    fn render<S: Scope<Timestamp = Time>>(
+    fn render(
         &self,
-        scope: &mut S,
-        collections: &mut std::collections::HashMap<Plan<Self::Value>, VecCollection<S, Vec<Self::Value>, Diff>>,
+        scope: &mut Scope<Time>,
+        collections: &mut std::collections::HashMap<Plan<Self::Value>, VecCollection<Time, Vec<Self::Value>, Diff>>,
         arrangements: &mut TraceManager<Self::Value>,
-    ) -> VecCollection<S, Vec<Self::Value>, Diff>
+    ) -> VecCollection<Time, Vec<Self::Value>, Diff>
     {
         if collections.get(self).is_none() {
 
diff --git a/interactive/src/plan/sfw.rs b/interactive/src/plan/sfw.rs
index c4a8a44a0..d9e7a2f49 100644
--- a/interactive/src/plan/sfw.rs
+++ b/interactive/src/plan/sfw.rs
@@ -65,12 +65,12 @@ impl<V: ExchangeData+Hash+Datum> Render for MultiwayJoin<V> {
 
     type Value = V;
 
-    fn render<S: Scope<Timestamp = Time>>(
+    fn render(
         &self,
-        scope: &mut S,
-        collections: &mut std::collections::HashMap<Plan<Self::Value>, VecCollection<S, Vec<Self::Value>, Diff>>,
+        scope: &mut Scope<Time>,
+        collections: &mut std::collections::HashMap<Plan<Self::Value>, VecCollection<Time, Vec<Self::Value>, Diff>>,
         arrangements: &mut TraceManager<Self::Value>,
-    ) -> VecCollection<S, Vec<Self::Value>, Diff>
+    ) -> VecCollection<Time, Vec<Self::Value>, Diff>
     {
         // The idea here is the following:
         //
diff --git a/mdbook/src/chapter_2/chapter_2_1.md b/mdbook/src/chapter_2/chapter_2_1.md
index ecc749447..1d0e9ed9a 100644
--- a/mdbook/src/chapter_2/chapter_2_1.md
+++ b/mdbook/src/chapter_2/chapter_2_1.md
@@ -7,11 +7,10 @@ As an example, our example program used `map` to reverse the pairs of identifier
 ```rust
 # extern crate timely;
 # extern crate differential_dataflow;
-# use timely::dataflow::Scope;
+# use timely::progress::Timestamp;
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::lattice::Lattice;
-# fn example<G: Scope>(manages: VecCollection<G, (u64, u64)>)
-# where G::Timestamp: Lattice
+# fn example<G: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<G, (u64, u64)>)
 # {
     manages
         .clone()
@@ -26,11 +25,10 @@ If instead we had just written
 ```rust
 # extern crate timely;
 # extern crate differential_dataflow;
-# use timely::dataflow::Scope;
+# use timely::progress::Timestamp;
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::lattice::Lattice;
-# fn example<G: Scope>(manages: VecCollection<G, (u64, u64)>)
-# where G::Timestamp: Lattice
+# fn example<G: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<G, (u64, u64)>)
 # {
     manages
         .map(|(m2, m1)| m2);
diff --git a/mdbook/src/chapter_2/chapter_2_2.md b/mdbook/src/chapter_2/chapter_2_2.md
index b30d779ef..976ba87ea 100644
--- a/mdbook/src/chapter_2/chapter_2_2.md
+++ b/mdbook/src/chapter_2/chapter_2_2.md
@@ -7,11 +7,10 @@ As an example, we might select out those management relation where the manager h
 ```rust
 # extern crate timely;
 # extern crate differential_dataflow;
-# use timely::dataflow::Scope;
+# use timely::progress::Timestamp;
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::lattice::Lattice;
-# fn example<G: Scope>(manages: VecCollection<G, (u64, u64)>)
-# where G::Timestamp: Lattice
+# fn example<G: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<G, (u64, u64)>)
 # {
     manages
         .filter(|&(m2, m1)| m2 > m1);
diff --git a/mdbook/src/chapter_2/chapter_2_3.md b/mdbook/src/chapter_2/chapter_2_3.md
index b61a02a57..fee20b65d 100644
--- a/mdbook/src/chapter_2/chapter_2_3.md
+++ b/mdbook/src/chapter_2/chapter_2_3.md
@@ -7,11 +7,10 @@ For example, we might form the symmetric "management relation" by concatenating
 ```rust
 # extern crate timely;
 # extern crate differential_dataflow;
-# use timely::dataflow::Scope;
+# use timely::progress::Timestamp;
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::lattice::Lattice;
-# fn example<G: Scope>(manages: VecCollection<G, (u64, u64)>)
-# where G::Timestamp: Lattice
+# fn example<G: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<G, (u64, u64)>)
 # {
     manages
         .clone()
diff --git a/mdbook/src/chapter_2/chapter_2_4.md b/mdbook/src/chapter_2/chapter_2_4.md
index 2c2ad4f4b..9afb42941 100644
--- a/mdbook/src/chapter_2/chapter_2_4.md
+++ b/mdbook/src/chapter_2/chapter_2_4.md
@@ -9,11 +9,10 @@ As an example, if we were to inspect
 ```rust
 # extern crate timely;
 # extern crate differential_dataflow;
-# use timely::dataflow::Scope;
+# use timely::progress::Timestamp;
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::lattice::Lattice;
-# fn example<G: Scope>(manages: VecCollection<G, (u64, u64)>)
-# where G::Timestamp: Lattice
+# fn example<G: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<G, (u64, u64)>)
 # {
     manages
         .clone()
@@ -35,11 +34,10 @@ However, by introducing `consolidate`
 ```rust
 # extern crate timely;
 # extern crate differential_dataflow;
-# use timely::dataflow::Scope;
+# use timely::progress::Timestamp;
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::lattice::Lattice;
-# fn example<G: Scope>(manages: VecCollection<G, (u64, u64)>)
-# where G::Timestamp: Lattice
+# fn example<G: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<G, (u64, u64)>)
 # {
     manages
         .clone()
diff --git a/mdbook/src/chapter_2/chapter_2_5.md b/mdbook/src/chapter_2/chapter_2_5.md
index 8de590eb2..aee1ecce8 100644
--- a/mdbook/src/chapter_2/chapter_2_5.md
+++ b/mdbook/src/chapter_2/chapter_2_5.md
@@ -7,11 +7,10 @@ Our example from earlier uses a join to match up pairs `(m2, m1)` and `(m1, p)`
 ```rust
 # extern crate timely;
 # extern crate differential_dataflow;
-# use timely::dataflow::Scope;
+# use timely::progress::Timestamp;
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::lattice::Lattice;
-# fn example<G: Scope>(manages: VecCollection<G, (u64, u64)>)
-# where G::Timestamp: Lattice
+# fn example<G: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<G, (u64, u64)>)
 # {
     manages
         .clone()
diff --git a/mdbook/src/chapter_2/chapter_2_6.md b/mdbook/src/chapter_2/chapter_2_6.md
index 74b5020f4..bd017f8fe 100644
--- a/mdbook/src/chapter_2/chapter_2_6.md
+++ b/mdbook/src/chapter_2/chapter_2_6.md
@@ -7,11 +7,10 @@ For example, to produce for each manager their managee with the lowest identifie
 ```rust
 # extern crate timely;
 # extern crate differential_dataflow;
-# use timely::dataflow::Scope;
+# use timely::progress::Timestamp;
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::lattice::Lattice;
-# fn example<G: Scope>(manages: VecCollection<G, (u64, u64), i64>)
-# where G::Timestamp: Lattice
+# fn example<G: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<G, (u64, u64), i64>)
 # {
     manages
         .reduce(|_key, input, output| {
diff --git a/mdbook/src/chapter_2/chapter_2_7.md b/mdbook/src/chapter_2/chapter_2_7.md
index 4692fc007..c18f9dd68 100644
--- a/mdbook/src/chapter_2/chapter_2_7.md
+++ b/mdbook/src/chapter_2/chapter_2_7.md
@@ -7,12 +7,11 @@ As an example, we can take our `manages` relation and determine for all employee
 ```rust
 # extern crate timely;
 # extern crate differential_dataflow;
-# use timely::dataflow::Scope;
+# use timely::progress::Timestamp;
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::operators::Iterate;
 # use differential_dataflow::lattice::Lattice;
-# fn example<G: Scope>(manages: VecCollection<G, (u64, u64)>)
-# where G::Timestamp: Lattice
+# fn example<G: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<G, (u64, u64)>)
 # {
     manages   // transitive contains (manager, person) for many hops.
         .iterate(|_scope, transitive| {
@@ -44,12 +43,11 @@ In the example above, we could rewrite
 ```rust
 # extern crate timely;
 # extern crate differential_dataflow;
-# use timely::dataflow::Scope;
+# use timely::progress::Timestamp;
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::operators::{Iterate, iterate::VecVariable};
 # use differential_dataflow::lattice::Lattice;
-# fn example<G: Scope>(manages: VecCollection<G, (u64, u64)>)
-# where G::Timestamp: Lattice
+# fn example<G: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<G, (u64, u64)>)
 # {
     manages   // transitive contains (manager, person) for many hops.
         .clone()
@@ -84,24 +82,22 @@ As an example, the implementation of the `iterate` operator looks something like
 ```rust
 # extern crate timely;
 # extern crate differential_dataflow;
+# use timely::progress::Timestamp;
 # use timely::dataflow::Scope;
-# use timely::dataflow::scopes::Child;
 # use timely::progress::Antichain;
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::operators::{Iterate, iterate::VecVariable};
 # use differential_dataflow::lattice::Lattice;
-# fn logic<'a, G: Scope>(collection: VecCollection<Child<'a, G::Allocator, G::Timestamp>, (u64, u64), isize>) -> VecCollection<Child<'a, G::Allocator, G::Timestamp>, (u64, u64)>
-# where G::Timestamp: Lattice
+# fn logic<G: Timestamp + Lattice>(collection: VecCollection<G, (u64, u64), isize>) -> VecCollection<G, (u64, u64)>
 # {
 #     collection
 # }
-# fn example<'a, G: Scope<Timestamp=u64>>(collection: VecCollection<G, (u64, u64)>) //, logic: impl Fn(&VecVariable<Child<'a, G::Allocator, G::Timestamp>, (u64, u64), isize>) -> VecCollection<Child<'a, G::Allocator, G::Timestamp>, (u64, u64)>)
-#    where G::Timestamp: Lattice
+# fn example(collection: VecCollection<u64, (u64, u64)>)
 # {
     let outer = collection.scope();
     outer.scoped::<u64,_,_>("inner", |subgraph| {
         let (variable, collection) = VecVariable::new_from(collection.enter(subgraph), 1);
-        let result = logic::<G>(collection);
+        let result = logic(collection);
         variable.set(result.clone());
         result.leave(&outer)
     });
diff --git a/server/Cargo.toml b/server/Cargo.toml
index dcc50ade8..4a67a1489 100644
--- a/server/Cargo.toml
+++ b/server/Cargo.toml
@@ -12,4 +12,4 @@ workspace = true
 [dependencies]
 libloading = "0.8"
 differential-dataflow = { workspace = true }
-timely = { workspace = true }
+timely = { workspace = true, features = ["getopts"] }
diff --git a/server/src/lib.rs b/server/src/lib.rs
index d13579876..14c06d048 100644
--- a/server/src/lib.rs
+++ b/server/src/lib.rs
@@ -5,8 +5,7 @@ use std::time::Instant;
 
 use libloading::Library;
 
-use timely::communication::Allocator;
-use timely::dataflow::scopes::Child;
+use timely::dataflow::Scope;
 use timely::dataflow::operators::probe::Handle as ProbeHandle;
 
 // stuff for talking about shared trace types ...
@@ -19,8 +18,8 @@ type TraceSpine = ValSpine<usize, usize, RootTime, isize>;
 pub type TraceHandle = TraceAgent<TraceSpine>;
 
 /// Arguments provided to each shared library to help build their dataflows and register their results.
-pub type Environment<'a, 'b> = (
-    &'a mut Child<'b, Allocator, usize>,
+pub type Environment<'a> = (
+    &'a mut Scope<usize>,
     &'a mut TraceHandler,
     &'a mut ProbeHandle<RootTime>,
     &'a Instant,

From f7d1d55144a5457eaeb065eb203c213e93451e03 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Thu, 9 Apr 2026 09:41:01 -0400
Subject: [PATCH 04/13] Remove unused, and Arranged impls

---
 differential-dataflow/examples/accumulate.rs  |  7 +--
 differential-dataflow/examples/bfs.rs         |  1 -
 .../examples/columnar/main.rs                 |  1 -
 differential-dataflow/examples/dynamic.rs     |  1 -
 differential-dataflow/examples/interpreted.rs |  1 -
 .../examples/iterate_container.rs             |  2 +-
 differential-dataflow/examples/monoid-bfs.rs  |  1 -
 differential-dataflow/examples/progress.rs    |  1 -
 .../examples/stackoverflow.rs                 |  1 -
 differential-dataflow/src/capture.rs          |  3 +-
 differential-dataflow/src/collection.rs       |  1 -
 .../src/operators/arrange/arrangement.rs      | 56 +++++++++----------
 .../src/operators/arrange/upsert.rs           |  2 +-
 differential-dataflow/src/operators/join.rs   |  1 -
 differential-dataflow/src/operators/reduce.rs | 27 +++++----
 differential-dataflow/tests/bfs.rs            |  1 -
 differential-dataflow/tests/scc.rs            |  1 -
 dogsdogsdogs/examples/delta_query.rs          |  1 -
 dogsdogsdogs/examples/delta_query2.rs         |  1 -
 dogsdogsdogs/examples/delta_query_wcoj.rs     |  1 -
 dogsdogsdogs/examples/ngo.rs                  |  1 -
 dogsdogsdogs/src/lib.rs                       |  1 -
 dogsdogsdogs/src/operators/half_join.rs       |  3 +-
 dogsdogsdogs/src/operators/half_join2.rs      |  3 +-
 dogsdogsdogs/src/operators/lookup_map.rs      |  1 -
 experiments/src/bin/deals-interactive.rs      |  1 -
 experiments/src/bin/deals.rs                  |  2 -
 experiments/src/bin/graphs-interactive-alt.rs |  1 -
 .../src/bin/graphs-interactive-neu-zwei.rs    |  1 -
 experiments/src/bin/graphs-interactive-neu.rs |  1 -
 experiments/src/bin/graphs-interactive.rs     |  1 -
 experiments/src/bin/graphs-static.rs          |  2 -
 experiments/src/bin/graphs.rs                 |  2 -
 experiments/src/bin/graspan1.rs               |  1 -
 experiments/src/bin/graspan2.rs               |  1 -
 35 files changed, 46 insertions(+), 87 deletions(-)

diff --git a/differential-dataflow/examples/accumulate.rs b/differential-dataflow/examples/accumulate.rs
index b04fe52b1..a29b711ae 100644
--- a/differential-dataflow/examples/accumulate.rs
+++ b/differential-dataflow/examples/accumulate.rs
@@ -7,7 +7,7 @@ fn main() {
     let keys: usize = std::env::args().nth(1).unwrap().parse().unwrap();
     let batch: usize = 10_000;
 
-    // This computation demonstrates in-place accumulation of arbitrarily large 
+    // This computation demonstrates in-place accumulation of arbitrarily large
     // volumes of input data, consuming space bounded by the number of distinct keys.
     timely::execute_from_args(std::env::args().skip(2), move |worker| {
 
@@ -17,7 +17,6 @@ fn main() {
         let mut input = worker.dataflow::<(), _, _>(|scope| {
             let (input, data) = scope.new_collection::<_, isize>();
 
-            use timely::dataflow::Scope;
             let outer = scope.clone();
             scope.iterative::<u32,_,_>(|inner| {
                 data.enter_at(inner, |_| 0)
@@ -42,7 +41,7 @@ fn main() {
             }
             counter += batch;
 
-            worker.step(); 
+            worker.step();
             let elapsed = timer.elapsed();
 
             if elapsed.as_secs() as usize > last_sec {
@@ -55,4 +54,4 @@ fn main() {
         }
 
     }).unwrap();
-}
\ No newline at end of file
+}
diff --git a/differential-dataflow/examples/bfs.rs b/differential-dataflow/examples/bfs.rs
index 5c78c938b..cdbfd7842 100644
--- a/differential-dataflow/examples/bfs.rs
+++ b/differential-dataflow/examples/bfs.rs
@@ -1,6 +1,5 @@
 use rand::{Rng, SeedableRng, StdRng};
 
-use timely::dataflow::*;
 use timely::dataflow::operators::probe::Handle;
 
 use differential_dataflow::input::Input;
diff --git a/differential-dataflow/examples/columnar/main.rs b/differential-dataflow/examples/columnar/main.rs
index 9d58f154d..02fc56970 100644
--- a/differential-dataflow/examples/columnar/main.rs
+++ b/differential-dataflow/examples/columnar/main.rs
@@ -93,7 +93,6 @@ fn main() {
 mod reachability {
 
     use timely::order::Product;
-    use timely::dataflow::Scope;
     use differential_dataflow::Collection;
     use differential_dataflow::AsCollection;
     use differential_dataflow::operators::iterate::Variable;
diff --git a/differential-dataflow/examples/dynamic.rs b/differential-dataflow/examples/dynamic.rs
index 345f40ab4..a4c121f98 100644
--- a/differential-dataflow/examples/dynamic.rs
+++ b/differential-dataflow/examples/dynamic.rs
@@ -1,6 +1,5 @@
 use rand::{Rng, SeedableRng, StdRng};
 
-use timely::dataflow::*;
 use timely::dataflow::operators::probe::Handle;
 
 use differential_dataflow::input::Input;
diff --git a/differential-dataflow/examples/interpreted.rs b/differential-dataflow/examples/interpreted.rs
index b087af00d..68ebaafee 100644
--- a/differential-dataflow/examples/interpreted.rs
+++ b/differential-dataflow/examples/interpreted.rs
@@ -1,5 +1,4 @@
 use std::hash::Hash;
-use timely::dataflow::*;
 use timely::dataflow::operators::*;
 
 use differential_dataflow::VecCollection;
diff --git a/differential-dataflow/examples/iterate_container.rs b/differential-dataflow/examples/iterate_container.rs
index b2b6daf97..78a516a8a 100644
--- a/differential-dataflow/examples/iterate_container.rs
+++ b/differential-dataflow/examples/iterate_container.rs
@@ -3,7 +3,7 @@
 use timely::dataflow::channels::pact::Pipeline;
 use timely::dataflow::operators::Operator;
 use timely::order::Product;
-use timely::dataflow::{Scope, Stream};
+use timely::dataflow::Stream;
 use timely::dataflow::operators::generic::builder_rc::OperatorBuilder;
 use differential_dataflow::{AsCollection, Collection};
 use differential_dataflow::input::Input;
diff --git a/differential-dataflow/examples/monoid-bfs.rs b/differential-dataflow/examples/monoid-bfs.rs
index 9400a1cdd..9c5267fb2 100644
--- a/differential-dataflow/examples/monoid-bfs.rs
+++ b/differential-dataflow/examples/monoid-bfs.rs
@@ -1,7 +1,6 @@
 use rand::{Rng, SeedableRng, StdRng};
 use serde::{Deserialize, Serialize};
 
-use timely::dataflow::*;
 use timely::dataflow::operators::probe::Handle;
 
 use differential_dataflow::input::Input;
diff --git a/differential-dataflow/examples/progress.rs b/differential-dataflow/examples/progress.rs
index 138de0c86..0229263d8 100644
--- a/differential-dataflow/examples/progress.rs
+++ b/differential-dataflow/examples/progress.rs
@@ -1,7 +1,6 @@
 //! A demonstration of timely dataflow progress tracking, using differential dataflow operators.
 
 use timely::PartialOrder;
-use timely::dataflow::*;
 use timely::dataflow::operators::probe::Handle;
 
 use differential_dataflow::input::Input;
diff --git a/differential-dataflow/examples/stackoverflow.rs b/differential-dataflow/examples/stackoverflow.rs
index c88e7ea6f..0e3c51ce0 100644
--- a/differential-dataflow/examples/stackoverflow.rs
+++ b/differential-dataflow/examples/stackoverflow.rs
@@ -1,7 +1,6 @@
 use std::io::{BufRead, BufReader};
 use std::fs::File;
 
-use timely::dataflow::*;
 use timely::dataflow::operators::probe::Handle;
 
 use differential_dataflow::input::InputSession;
diff --git a/differential-dataflow/src/capture.rs b/differential-dataflow/src/capture.rs
index e9a71f6b8..f36501448 100644
--- a/differential-dataflow/src/capture.rs
+++ b/differential-dataflow/src/capture.rs
@@ -230,7 +230,6 @@ pub mod source {
     use timely::dataflow::{Scope, Stream, operators::{Capability, CapabilitySet}};
     use timely::dataflow::operators::generic::OutputBuilder;
     use timely::progress::Timestamp;
-    use timely::worker::AsWorker;
     use timely::scheduling::{Scheduler, SyncActivator};
 
     // TODO(guswynn): implement this generally in timely
@@ -560,7 +559,7 @@ pub mod sink {
 
     use timely::order::PartialOrder;
     use timely::progress::{Antichain, ChangeBatch, Timestamp};
-    use timely::dataflow::{Scope, Stream};
+    use timely::dataflow::Stream;
     use timely::dataflow::channels::pact::{Exchange, Pipeline};
     use timely::dataflow::operators::generic::{builder_rc::OperatorBuilder, OutputBuilder};
     use timely::scheduling::Scheduler;
diff --git a/differential-dataflow/src/collection.rs b/differential-dataflow/src/collection.rs
index 3720c90e1..d0e4fd5c4 100644
--- a/differential-dataflow/src/collection.rs
+++ b/differential-dataflow/src/collection.rs
@@ -326,7 +326,6 @@ pub mod vec {
     use timely::progress::Timestamp;
     use timely::order::Product;
     use timely::dataflow::scope::Iterative;
-    use timely::dataflow::Scope;
     use timely::dataflow::operators::*;
     use timely::dataflow::operators::vec::*;
 
diff --git a/differential-dataflow/src/operators/arrange/arrangement.rs b/differential-dataflow/src/operators/arrange/arrangement.rs
index dcfa0bcf8..d00515d38 100644
--- a/differential-dataflow/src/operators/arrange/arrangement.rs
+++ b/differential-dataflow/src/operators/arrange/arrangement.rs
@@ -60,10 +60,9 @@ where
     // returns when invoked, so as to not duplicate work with multiple calls to `as_collection`.
 }
 
-impl<G, Tr> Clone for Arranged<G, Tr>
+impl<Tr> Clone for Arranged<Tr::Time, Tr>
 where
-    G: Timestamp,
-    Tr: TraceReader<Time = G> + Clone,
+    Tr: TraceReader + Clone,
 {
     fn clone(&self) -> Self {
         Arranged {
@@ -76,10 +75,9 @@ where
 use ::timely::progress::timestamp::Refines;
 use timely::Container;
 
-impl<G, Tr> Arranged<G, Tr>
+impl<Tr> Arranged<Tr::Time, Tr>
 where
-    G: Timestamp,
-    Tr: TraceReader<Time = G> + Clone,
+    Tr: TraceReader + Clone,
 {
     /// Brings an arranged collection into a nested scope.
     ///
@@ -89,7 +87,7 @@ where
     pub fn enter<TInner>(self, child: &Scope<TInner>)
         -> Arranged<TInner, TraceEnter<Tr, TInner>>
         where
-            TInner: Refines<G>+Lattice+Timestamp+Clone,
+            TInner: Refines<Tr::Time>+Lattice+Timestamp+Clone,
     {
         Arranged {
             stream: self.stream.enter(child).map(|bw| BatchEnter::make_from(bw)),
@@ -101,7 +99,7 @@ where
     ///
     /// This method only applies to *regions*, which are subscopes with the same timestamp
     /// as their containing scope. In this case, the trace type does not need to change.
-    pub fn enter_region(self, child: &Scope<G>) -> Self {
+    pub fn enter_region(self, child: &Scope<Tr::Time>) -> Self {
         Arranged {
             stream: self.stream.enter(child),
             trace: self.trace,
@@ -116,7 +114,7 @@ where
     pub fn enter_at<TInner, F, P>(self, child: &Scope<TInner>, logic: F, prior: P)
         -> Arranged<TInner, TraceEnterAt<Tr, TInner, F, P>>
         where
-            TInner: Refines<G>+Lattice+Timestamp+Clone+'static,
+            TInner: Refines<Tr::Time>+Lattice+Timestamp+Clone+'static,
             F: FnMut(Tr::Key<'_>, Tr::Val<'_>, Tr::TimeGat<'_>)->TInner+Clone+'static,
             P: FnMut(&TInner)->Tr::Time+Clone+'static,
         {
@@ -132,7 +130,7 @@ where
     ///
     /// This method is like `self.stream.flat_map`, except that it produces containers
     /// directly, rather than form a container of containers as `flat_map` would.
-    pub fn as_container<I, L>(self, mut logic: L) -> crate::Collection<G, I::Item>
+    pub fn as_container<I, L>(self, mut logic: L) -> crate::Collection<Tr::Time, I::Item>
     where
         I: IntoIterator<Item: Container>,
         L: FnMut(Tr::Batch) -> I+'static,
@@ -152,10 +150,10 @@ where
 
     /// Flattens the stream into a `VecCollection`.
     ///
-    /// The underlying `Stream<G, Vec<BatchWrapper<T::Batch>>>` is a much more efficient way to access the data,
+    /// The underlying `Stream<T, Vec<BatchWrapper<T::Batch>>>` is a much more efficient way to access the data,
     /// and this method should only be used when the data need to be transformed or exchanged, rather than
     /// supplied as arguments to an operator using the same key-value structure.
-    pub fn as_collection<D: Data, L>(self, mut logic: L) -> VecCollection<G, D, Tr::Diff>
+    pub fn as_collection<D: Data, L>(self, mut logic: L) -> VecCollection<Tr::Time, D, Tr::Diff>
         where
             L: FnMut(Tr::Key<'_>, Tr::Val<'_>) -> D+'static,
     {
@@ -164,14 +162,14 @@ where
 
     /// Flattens the stream into a `VecCollection`.
     ///
-    /// The underlying `Stream<G, Vec<BatchWrapper<T::Batch>>>` is a much more efficient way to access the data,
+    /// The underlying `Stream<T, Vec<BatchWrapper<T::Batch>>>` is a much more efficient way to access the data,
     /// and this method should only be used when the data need to be transformed or exchanged, rather than
     /// supplied as arguments to an operator using the same key-value structure.
     ///
     /// The method takes `K` and `V` as generic arguments, in order to constrain the reference types to support
     /// cloning into owned types. If this bound does not work, the `as_collection` method allows arbitrary logic
     /// on the reference types.
-    pub fn as_vecs<K, V>(self) -> VecCollection<G, (K, V), Tr::Diff>
+    pub fn as_vecs<K, V>(self) -> VecCollection<Tr::Time, (K, V), Tr::Diff>
     where
         K: crate::ExchangeData,
         V: crate::ExchangeData,
@@ -184,7 +182,7 @@ where
     ///
     /// The supplied logic may produce an iterator over output values, allowing either
     /// filtering or flat mapping as part of the extraction.
-    pub fn flat_map_ref<I, L>(self, logic: L) -> VecCollection<G, I::Item, Tr::Diff>
+    pub fn flat_map_ref<I, L>(self, logic: L) -> VecCollection<Tr::Time, I::Item, Tr::Diff>
         where
             I: IntoIterator<Item: Data>,
             L: FnMut(Tr::Key<'_>, Tr::Val<'_>) -> I+'static,
@@ -199,7 +197,7 @@ where
     ///
     /// This method exists for streams of batches without the corresponding arrangement.
     /// If you have the arrangement, its `flat_map_ref` method is equivalent to this.
-    pub fn flat_map_batches<I, L>(stream: Stream<G, Vec<Tr::Batch>>, mut logic: L) -> VecCollection<G, I::Item, Tr::Diff>
+    pub fn flat_map_batches<I, L>(stream: Stream<Tr::Time, Vec<Tr::Batch>>, mut logic: L) -> VecCollection<Tr::Time, I::Item, Tr::Diff>
     where
         I: IntoIterator<Item: Data>,
         L: FnMut(Tr::Key<'_>, Tr::Val<'_>) -> I+'static,
@@ -231,22 +229,21 @@ where
 
 use crate::difference::Multiply;
 // Direct join implementations.
-impl<G, T1> Arranged<G, T1>
+impl<T1> Arranged<T1::Time, T1>
 where
-    G: Timestamp + Lattice,
-    T1: TraceReader<Time = G> + Clone + 'static,
+    T1: TraceReader<Time: Lattice> + Clone + 'static,
 {
     /// A convenience method to join and produce `VecCollection` output.
     ///
     /// Avoid this method, as it is likely to evolve into one without the `VecCollection` opinion.
-    pub fn join_core<T2,I,L>(self, other: Arranged<G,T2>, mut result: L) -> VecCollection<G,I::Item,<T1::Diff as Multiply<T2::Diff>>::Output>
+    pub fn join_core<T2,I,L>(self, other: Arranged<T1::Time,T2>, mut result: L) -> VecCollection<T1::Time,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, Output: Semigroup+'static>,
         I: IntoIterator<Item: Data>,
         L: FnMut(T1::Key<'_>,T1::Val<'_>,T2::Val<'_>)->I+'static
     {
-        let mut result = move |k: T1::Key<'_>, v1: T1::Val<'_>, v2: T2::Val<'_>, t: &G, r1: &T1::Diff, r2: &T2::Diff| {
+        let mut result = move |k: T1::Key<'_>, v1: T1::Val<'_>, v2: T2::Val<'_>, t: &T1::Time, r1: &T1::Diff, r2: &T2::Diff| {
             let t = t.clone();
             let r = (r1.clone()).multiply(r2);
             result(k, v1, v2).into_iter().map(move |d| (d, t.clone(), r.clone()))
@@ -268,22 +265,20 @@ where
 
 // Direct reduce implementations.
 use crate::difference::Abelian;
-impl<G, T1> Arranged<G, T1>
+impl<T1> Arranged<T1::Time, T1>
 where
-    G: Timestamp + Lattice,
-    T1: TraceReader<Time = G> + Clone + 'static,
+    T1: TraceReader<Time: Lattice> + Clone + 'static,
 {
     /// A direct implementation of `ReduceCore::reduce_abelian`.
-    pub fn reduce_abelian<L, Bu, T2, P>(self, name: &str, mut logic: L, push: P) -> Arranged<G, TraceAgent<T2>>
+    pub fn reduce_abelian<L, Bu, T2, P>(self, name: &str, mut logic: L, push: P) -> Arranged<T1::Time, TraceAgent<T2>>
     where
-        T1: TraceReader,
         T2: for<'a> Trace<
             Key<'a>= T1::Key<'a>,
             ValOwn: Data,
             Time=T1::Time,
             Diff: Abelian,
         >+'static,
-        Bu: Builder<Time=G, Output = T2::Batch, Input: Default>,
+        Bu: Builder<Time=T1::Time, Output = T2::Batch, Input: Default>,
         L: FnMut(T1::Key<'_>, &[(T1::Val<'_>, T1::Diff)], &mut Vec<(T2::ValOwn, T2::Diff)>)+'static,
         P: FnMut(&mut Bu::Input, T1::Key<'_>, &mut Vec<(T2::ValOwn, T2::Time, T2::Diff)>) + 'static,
     {
@@ -297,20 +292,19 @@ where
     }
 
     /// A direct implementation of `ReduceCore::reduce_core`.
-    pub fn reduce_core<L, Bu, T2, P>(self, name: &str, logic: L, push: P) -> Arranged<G, TraceAgent<T2>>
+    pub fn reduce_core<L, Bu, T2, P>(self, name: &str, logic: L, push: P) -> Arranged<T1::Time, TraceAgent<T2>>
     where
-        T1: TraceReader,
         T2: for<'a> Trace<
             Key<'a>=T1::Key<'a>,
             ValOwn: Data,
             Time=T1::Time,
         >+'static,
-        Bu: Builder<Time=G, Output = T2::Batch, Input: Default>,
+        Bu: Builder<Time=T1::Time, Output = T2::Batch, Input: Default>,
         L: FnMut(T1::Key<'_>, &[(T1::Val<'_>, T1::Diff)], &mut Vec<(T2::ValOwn, T2::Diff)>, &mut Vec<(T2::ValOwn, T2::Diff)>)+'static,
         P: FnMut(&mut Bu::Input, T1::Key<'_>, &mut Vec<(T2::ValOwn, T2::Time, T2::Diff)>) + 'static,
     {
         use crate::operators::reduce::reduce_trace;
-        reduce_trace::<_,_,Bu,_,_,_>(self, name, logic, push)
+        reduce_trace::<_,Bu,_,_,_>(self, name, logic, push)
     }
 }
 
diff --git a/differential-dataflow/src/operators/arrange/upsert.rs b/differential-dataflow/src/operators/arrange/upsert.rs
index bedf8d02f..13d5f2cac 100644
--- a/differential-dataflow/src/operators/arrange/upsert.rs
+++ b/differential-dataflow/src/operators/arrange/upsert.rs
@@ -101,7 +101,7 @@
 use std::collections::{BinaryHeap, BTreeMap};
 
 use timely::order::{PartialOrder, TotalOrder};
-use timely::dataflow::{Scope, Stream};
+use timely::dataflow::Stream;
 use timely::dataflow::operators::generic::Operator;
 use timely::dataflow::channels::pact::Exchange;
 use timely::progress::Timestamp;
diff --git a/differential-dataflow/src/operators/join.rs b/differential-dataflow/src/operators/join.rs
index a4c2cedf7..f42362234 100644
--- a/differential-dataflow/src/operators/join.rs
+++ b/differential-dataflow/src/operators/join.rs
@@ -14,7 +14,6 @@ use timely::dataflow::operators::generic::{Operator, OutputBuilderSession, Sessi
 use timely::dataflow::channels::pact::Pipeline;
 use timely::dataflow::operators::Capability;
 use timely::scheduling::Scheduler;
-use timely::worker::AsWorker;
 
 use crate::lattice::Lattice;
 use crate::operators::arrange::Arranged;
diff --git a/differential-dataflow/src/operators/reduce.rs b/differential-dataflow/src/operators/reduce.rs
index 8f2e86db9..5d04fd019 100644
--- a/differential-dataflow/src/operators/reduce.rs
+++ b/differential-dataflow/src/operators/reduce.rs
@@ -33,11 +33,10 @@ use crate::trace::TraceReader;
 /// the value updates, as appropriate for the container. It is critical that it clear the container as
 /// the operator has no ability to do this otherwise, and failing to do so represents a leak from one
 /// key's computation to another, and will likely introduce non-determinism.
-pub fn reduce_trace<G, T1, Bu, T2, L, P>(trace: Arranged<G, T1>, name: &str, mut logic: L, mut push: P) -> Arranged<G, TraceAgent<T2>>
+pub fn reduce_trace<T1, Bu, T2, L, P>(trace: Arranged<T1::Time, T1>, name: &str, mut logic: L, mut push: P) -> Arranged<T1::Time, TraceAgent<T2>>
 where
-    G: Timestamp + crate::lattice::Lattice,
-    T1: TraceReader<Time = G> + Clone + 'static,
-    T2: for<'a> Trace<Key<'a>=T1::Key<'a>, ValOwn: Data, Time = G> + 'static,
+    T1: TraceReader<Time: crate::lattice::Lattice> + Clone + 'static,
+    T2: for<'a> Trace<Key<'a>=T1::Key<'a>, ValOwn: Data, Time = T1::Time> + 'static,
     Bu: Builder<Time=T2::Time, Output = T2::Batch, Input: Default>,
     L: FnMut(T1::Key<'_>, &[(T1::Val<'_>, T1::Diff)], &mut Vec<(T2::ValOwn,T2::Diff)>, &mut Vec<(T2::ValOwn, T2::Diff)>)+'static,
     P: FnMut(&mut Bu::Input, T1::Key<'_>, &mut Vec<(T2::ValOwn, T2::Time, T2::Diff)>) + 'static,
@@ -67,7 +66,7 @@ where
 
             *result_trace = Some(output_reader.clone());
 
-            let mut new_interesting_times = Vec::<G>::new();
+            let mut new_interesting_times = Vec::<T1::Time>::new();
 
             // Our implementation maintains a list of outstanding `(key, time)` synthetic interesting times,
             // sorted by (key, time), as well as capabilities for the lower envelope of the times.
@@ -75,18 +74,18 @@ where
             let mut pending_time = T1::TimeContainer::with_capacity(0);
             let mut next_pending_keys = T1::KeyContainer::with_capacity(0);
             let mut next_pending_time = T1::TimeContainer::with_capacity(0);
-            let mut capabilities = timely::dataflow::operators::CapabilitySet::<G>::default();
+            let mut capabilities = timely::dataflow::operators::CapabilitySet::<T1::Time>::default();
 
             // buffers and logic for computing per-key interesting times "efficiently".
-            let mut interesting_times = Vec::<G>::new();
+            let mut interesting_times = Vec::<T1::Time>::new();
 
             // Upper and lower frontiers for the pending input and output batches to process.
-            let mut upper_limit = Antichain::from_elem(<G as timely::progress::Timestamp>::minimum());
-            let mut lower_limit = Antichain::from_elem(<G as timely::progress::Timestamp>::minimum());
+            let mut upper_limit = Antichain::from_elem(<T1::Time as timely::progress::Timestamp>::minimum());
+            let mut lower_limit = Antichain::from_elem(<T1::Time as timely::progress::Timestamp>::minimum());
 
             // Output batches may need to be built piecemeal, and these temp storage help there.
-            let mut output_upper = Antichain::from_elem(<G as timely::progress::Timestamp>::minimum());
-            let mut output_lower = Antichain::from_elem(<G as timely::progress::Timestamp>::minimum());
+            let mut output_upper = Antichain::from_elem(<T1::Time as timely::progress::Timestamp>::minimum());
+            let mut output_lower = Antichain::from_elem(<T1::Time as timely::progress::Timestamp>::minimum());
 
             move |(input, frontier), output| {
 
@@ -138,7 +137,7 @@ where
                         // Prepare an output buffer and builder for each capability.
                         // TODO: It would be better if all updates went into one batch, but timely dataflow prevents
                         //       this as long as it requires that there is only one capability for each message.
-                        let mut buffers = Vec::<(G, Vec<(T2::ValOwn, G, T2::Diff)>)>::new();
+                        let mut buffers = Vec::<(T1::Time, Vec<(T2::ValOwn, T1::Time, T2::Diff)>)>::new();
                         let mut builders = Vec::new();
                         for cap in capabilities.iter() {
                             buffers.push((cap.time().clone(), Vec::new()));
@@ -253,7 +252,7 @@ where
 
                             if output_upper.borrow() != output_lower.borrow() {
 
-                                let description = Description::new(output_lower.clone(), output_upper.clone(), Antichain::from_elem(G::minimum()));
+                                let description = Description::new(output_lower.clone(), output_upper.clone(), Antichain::from_elem(T1::Time::minimum()));
                                 let batch = builder.done(description);
 
                                 // ship batch to the output, and commit to the output trace.
@@ -273,7 +272,7 @@ where
                         pending_time.clear(); std::mem::swap(&mut next_pending_time, &mut pending_time);
 
                         // Update `capabilities` to reflect pending times.
-                        let mut frontier = Antichain::<G>::new();
+                        let mut frontier = Antichain::<T1::Time>::new();
                         let mut owned_time = T1::Time::minimum();
                         for pos in 0 .. pending_time.len() {
                             T1::clone_time_onto(pending_time.index(pos), &mut owned_time);
diff --git a/differential-dataflow/tests/bfs.rs b/differential-dataflow/tests/bfs.rs
index 917fccc93..a887d95c5 100644
--- a/differential-dataflow/tests/bfs.rs
+++ b/differential-dataflow/tests/bfs.rs
@@ -4,7 +4,6 @@ use std::sync::{Arc, Mutex};
 
 use timely::Config;
 
-use timely::dataflow::*;
 use timely::dataflow::operators::Capture;
 use timely::dataflow::operators::capture::Extract;
 
diff --git a/differential-dataflow/tests/scc.rs b/differential-dataflow/tests/scc.rs
index 87712bf68..1d12585ce 100644
--- a/differential-dataflow/tests/scc.rs
+++ b/differential-dataflow/tests/scc.rs
@@ -7,7 +7,6 @@ use std::mem;
 
 use timely::Config;
 
-use timely::dataflow::*;
 use timely::dataflow::operators::Capture;
 use timely::dataflow::operators::capture::Extract;
 
diff --git a/dogsdogsdogs/examples/delta_query.rs b/dogsdogsdogs/examples/delta_query.rs
index 8c46a090b..02cf67c41 100644
--- a/dogsdogsdogs/examples/delta_query.rs
+++ b/dogsdogsdogs/examples/delta_query.rs
@@ -1,4 +1,3 @@
-use timely::dataflow::Scope;
 use timely::dataflow::operators::probe::Handle;
 use differential_dataflow::input::Input;
 use graph_map::GraphMMap;
diff --git a/dogsdogsdogs/examples/delta_query2.rs b/dogsdogsdogs/examples/delta_query2.rs
index 6b088895e..f29a95a1a 100644
--- a/dogsdogsdogs/examples/delta_query2.rs
+++ b/dogsdogsdogs/examples/delta_query2.rs
@@ -1,4 +1,3 @@
-use timely::dataflow::Scope;
 use timely::order::Product;
 use timely::dataflow::operators::probe::Handle;
 use timely::dataflow::operators::vec::UnorderedInput;
diff --git a/dogsdogsdogs/examples/delta_query_wcoj.rs b/dogsdogsdogs/examples/delta_query_wcoj.rs
index ac8ae3e6c..ab047c42e 100644
--- a/dogsdogsdogs/examples/delta_query_wcoj.rs
+++ b/dogsdogsdogs/examples/delta_query_wcoj.rs
@@ -1,4 +1,3 @@
-use timely::dataflow::Scope;
 use timely::dataflow::operators::probe::Handle;
 use differential_dataflow::input::Input;
 use graph_map::GraphMMap;
diff --git a/dogsdogsdogs/examples/ngo.rs b/dogsdogsdogs/examples/ngo.rs
index 13a906c51..9c1177a58 100644
--- a/dogsdogsdogs/examples/ngo.rs
+++ b/dogsdogsdogs/examples/ngo.rs
@@ -1,5 +1,4 @@
 use std::hash::Hash;
-use timely::dataflow::*;
 use timely::dataflow::operators::*;
 use timely::dataflow::operators::vec::count::Accumulate;
 
diff --git a/dogsdogsdogs/src/lib.rs b/dogsdogsdogs/src/lib.rs
index c34dc2fca..8550bcf79 100644
--- a/dogsdogsdogs/src/lib.rs
+++ b/dogsdogsdogs/src/lib.rs
@@ -1,6 +1,5 @@
 use std::hash::Hash;
 
-use timely::dataflow::Scope;
 use timely::progress::Timestamp;
 use timely::dataflow::operators::vec::Partition;
 use timely::dataflow::operators::Concatenate;
diff --git a/dogsdogsdogs/src/operators/half_join.rs b/dogsdogsdogs/src/operators/half_join.rs
index 4492ad6a8..f6b2cbb3a 100644
--- a/dogsdogsdogs/src/operators/half_join.rs
+++ b/dogsdogsdogs/src/operators/half_join.rs
@@ -37,7 +37,7 @@ use std::time::Instant;
 
 use timely::ContainerBuilder;
 use timely::container::CapacityContainerBuilder;
-use timely::dataflow::{Scope, Stream};
+use timely::dataflow::Stream;
 use timely::scheduling::Scheduler;
 use timely::dataflow::channels::pact::{Pipeline, Exchange};
 use timely::dataflow::operators::{Capability, Operator, generic::Session};
@@ -250,7 +250,6 @@ where
                             // Any remaining times should peel off elements from `proposals`.
                             let mut additions = vec![Vec::new(); antichain.len()];
                             for (data, initial, diff) in proposals.drain(..) {
-                                use timely::PartialOrder;
                                 let position = antichain.iter().position(|t| t.less_equal(&initial)).unwrap();
                                 additions[position].push((data, initial, diff));
                             }
diff --git a/dogsdogsdogs/src/operators/half_join2.rs b/dogsdogsdogs/src/operators/half_join2.rs
index c8ef7ae8e..74ba919d8 100644
--- a/dogsdogsdogs/src/operators/half_join2.rs
+++ b/dogsdogsdogs/src/operators/half_join2.rs
@@ -22,11 +22,10 @@ use std::ops::Mul;
 
 use timely::ContainerBuilder;
 use timely::container::CapacityContainerBuilder;
-use timely::dataflow::{Scope, Stream};
+use timely::dataflow::Stream;
 use timely::scheduling::Scheduler;
 use timely::dataflow::channels::pact::{Pipeline, Exchange};
 use timely::dataflow::operators::Operator;
-use timely::PartialOrder;
 use timely::progress::{Antichain, ChangeBatch, Timestamp};
 use timely::progress::frontier::MutableAntichain;
 
diff --git a/dogsdogsdogs/src/operators/lookup_map.rs b/dogsdogsdogs/src/operators/lookup_map.rs
index 394cd4442..8897b57fe 100644
--- a/dogsdogsdogs/src/operators/lookup_map.rs
+++ b/dogsdogsdogs/src/operators/lookup_map.rs
@@ -1,6 +1,5 @@
 use std::collections::HashMap;
 
-use timely::PartialOrder;
 use timely::dataflow::channels::pact::{Pipeline, Exchange};
 use timely::dataflow::operators::Operator;
 use timely::progress::{Antichain, Timestamp};
diff --git a/experiments/src/bin/deals-interactive.rs b/experiments/src/bin/deals-interactive.rs
index a0e3c90df..f3947fd5d 100644
--- a/experiments/src/bin/deals-interactive.rs
+++ b/experiments/src/bin/deals-interactive.rs
@@ -1,7 +1,6 @@
 use std::time::Instant;
 
 use rand::{Rng, SeedableRng, StdRng};
-use timely::dataflow::*;
 use timely::WorkerConfig;
 
 use differential_dataflow::input::Input;
diff --git a/experiments/src/bin/deals.rs b/experiments/src/bin/deals.rs
index 47d7892d9..597d06fe2 100644
--- a/experiments/src/bin/deals.rs
+++ b/experiments/src/bin/deals.rs
@@ -1,7 +1,5 @@
 use std::time::Instant;
 
-use timely::dataflow::*;
-
 use differential_dataflow::input::Input;
 use differential_dataflow::VecCollection;
 use differential_dataflow::operators::*;
diff --git a/experiments/src/bin/graphs-interactive-alt.rs b/experiments/src/bin/graphs-interactive-alt.rs
index ddcaf349a..dbdffec8f 100644
--- a/experiments/src/bin/graphs-interactive-alt.rs
+++ b/experiments/src/bin/graphs-interactive-alt.rs
@@ -2,7 +2,6 @@
 
 use rand::{Rng, SeedableRng, StdRng};
 
-use timely::dataflow::*;
 use timely::progress::Timestamp;
 use timely::dataflow::operators::probe::Handle;
 use timely::order::Product;
diff --git a/experiments/src/bin/graphs-interactive-neu-zwei.rs b/experiments/src/bin/graphs-interactive-neu-zwei.rs
index f2f1bc5be..9d24f8156 100644
--- a/experiments/src/bin/graphs-interactive-neu-zwei.rs
+++ b/experiments/src/bin/graphs-interactive-neu-zwei.rs
@@ -1,6 +1,5 @@
 use rand::{Rng, SeedableRng, StdRng};
 
-use timely::dataflow::*;
 use timely::progress::Timestamp;
 use timely::dataflow::operators::probe::Handle;
 
diff --git a/experiments/src/bin/graphs-interactive-neu.rs b/experiments/src/bin/graphs-interactive-neu.rs
index 935fe6735..dd8b92b6b 100644
--- a/experiments/src/bin/graphs-interactive-neu.rs
+++ b/experiments/src/bin/graphs-interactive-neu.rs
@@ -2,7 +2,6 @@
 
 use rand::{Rng, SeedableRng, StdRng};
 
-use timely::dataflow::*;
 use timely::progress::Timestamp;
 use timely::dataflow::operators::probe::Handle;
 use timely::order::Product;
diff --git a/experiments/src/bin/graphs-interactive.rs b/experiments/src/bin/graphs-interactive.rs
index 8c099dc0d..7551186a9 100644
--- a/experiments/src/bin/graphs-interactive.rs
+++ b/experiments/src/bin/graphs-interactive.rs
@@ -1,6 +1,5 @@
 use rand::{Rng, SeedableRng, StdRng};
 
-use timely::dataflow::*;
 use timely::progress::Timestamp;
 use timely::dataflow::operators::probe::Handle;
 use timely::order::Product;
diff --git a/experiments/src/bin/graphs-static.rs b/experiments/src/bin/graphs-static.rs
index cd3a0567f..45e98ade6 100644
--- a/experiments/src/bin/graphs-static.rs
+++ b/experiments/src/bin/graphs-static.rs
@@ -1,5 +1,3 @@
-use timely::dataflow::*;
-
 use timely::order::Product;
 use timely::dataflow::operators::ToStream;
 
diff --git a/experiments/src/bin/graphs.rs b/experiments/src/bin/graphs.rs
index b5846595d..7461d006a 100644
--- a/experiments/src/bin/graphs.rs
+++ b/experiments/src/bin/graphs.rs
@@ -1,7 +1,5 @@
 use rand::{Rng, SeedableRng, StdRng};
 
-use timely::dataflow::*;
-
 use differential_dataflow::input::Input;
 use differential_dataflow::VecCollection;
 use differential_dataflow::operators::*;
diff --git a/experiments/src/bin/graspan1.rs b/experiments/src/bin/graspan1.rs
index 82fbe3ba2..571b46f1b 100644
--- a/experiments/src/bin/graspan1.rs
+++ b/experiments/src/bin/graspan1.rs
@@ -1,7 +1,6 @@
 use std::io::{BufRead, BufReader};
 use std::fs::File;
 
-use timely::dataflow::Scope;
 use timely::order::Product;
 
 use differential_dataflow::difference::Present;
diff --git a/experiments/src/bin/graspan2.rs b/experiments/src/bin/graspan2.rs
index 64d44dbe0..87c8b8fb7 100644
--- a/experiments/src/bin/graspan2.rs
+++ b/experiments/src/bin/graspan2.rs
@@ -1,7 +1,6 @@
 use std::io::{BufRead, BufReader};
 use std::fs::File;
 
-use timely::dataflow::Scope;
 use timely::order::Product;
 
 use differential_dataflow::operators::iterate::Variable;

From 5372b80e7af754a86aabf776da18b84be5352905 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Thu, 9 Apr 2026 10:00:29 -0400
Subject: [PATCH 05/13] Remove timestamp generic from Arranged

---
 .../examples/columnar/columnar_support.rs     |  1 -
 differential-dataflow/examples/graspan.rs     |  2 +-
 .../src/algorithms/graphs/bfs.rs              |  2 +-
 .../src/algorithms/graphs/bijkstra.rs         |  4 +--
 .../src/algorithms/graphs/propagate.rs        |  2 +-
 differential-dataflow/src/collection.rs       | 18 +++++------
 .../src/operators/arrange/agent.rs            | 10 +++---
 .../src/operators/arrange/arrangement.rs      | 31 +++++++++----------
 .../src/operators/arrange/upsert.rs           |  2 +-
 differential-dataflow/src/operators/count.rs  |  2 +-
 differential-dataflow/src/operators/join.rs   |  2 +-
 differential-dataflow/src/operators/reduce.rs |  2 +-
 .../src/operators/threshold.rs                |  2 +-
 dogsdogsdogs/src/operators/count.rs           |  2 +-
 dogsdogsdogs/src/operators/half_join.rs       |  4 +--
 dogsdogsdogs/src/operators/half_join2.rs      |  4 +--
 dogsdogsdogs/src/operators/lookup_map.rs      |  2 +-
 dogsdogsdogs/src/operators/propose.rs         |  4 +--
 dogsdogsdogs/src/operators/validate.rs        |  2 +-
 experiments/src/bin/deals-interactive.rs      |  2 +-
 experiments/src/bin/deals.rs                  |  2 +-
 experiments/src/bin/graphs-interactive-alt.rs |  2 +-
 .../src/bin/graphs-interactive-neu-zwei.rs    |  2 +-
 experiments/src/bin/graphs-interactive-neu.rs |  2 +-
 experiments/src/bin/graphs-interactive.rs     |  2 +-
 tpchlike/src/lib.rs                           |  2 +-
 26 files changed, 55 insertions(+), 57 deletions(-)

diff --git a/differential-dataflow/examples/columnar/columnar_support.rs b/differential-dataflow/examples/columnar/columnar_support.rs
index 825bd2a97..7e997a003 100644
--- a/differential-dataflow/examples/columnar/columnar_support.rs
+++ b/differential-dataflow/examples/columnar/columnar_support.rs
@@ -1972,7 +1972,6 @@ where
 /// a `ValColBuilder`, which sorts and consolidates on flush.
 pub fn as_recorded_updates<U>(
     arranged: differential_dataflow::operators::arrange::Arranged<
-        U::Time,
         differential_dataflow::operators::arrange::TraceAgent<ValSpine<U::Key, U::Val, U::Time, U::Diff>>,
     >,
 ) -> differential_dataflow::Collection<U::Time, RecordedUpdates<U>>
diff --git a/differential-dataflow/examples/graspan.rs b/differential-dataflow/examples/graspan.rs
index 9de864eba..1df5c2965 100644
--- a/differential-dataflow/examples/graspan.rs
+++ b/differential-dataflow/examples/graspan.rs
@@ -68,7 +68,7 @@ use differential_dataflow::operators::arrange::{Arranged, TraceAgent};
 
 type TraceKeyHandle<K,T,R> = TraceAgent<KeySpine<K, T, R>>;
 type TraceValHandle<K,V,T,R> = TraceAgent<ValSpine<K, V, T, R>>;
-type Arrange<G,K,V,R> = Arranged<G, TraceValHandle<K, V, G, R>>;
+type Arrange<G,K,V,R> = Arranged<TraceValHandle<K, V, G, R>>;
 
 /// An evolving set of edges.
 ///
diff --git a/differential-dataflow/src/algorithms/graphs/bfs.rs b/differential-dataflow/src/algorithms/graphs/bfs.rs
index 79ff15e45..8d609d9c8 100644
--- a/differential-dataflow/src/algorithms/graphs/bfs.rs
+++ b/differential-dataflow/src/algorithms/graphs/bfs.rs
@@ -22,7 +22,7 @@ use crate::trace::TraceReader;
 use crate::operators::arrange::Arranged;
 
 /// Returns pairs (node, dist) indicating distance of each node from a root.
-pub fn bfs_arranged<G, N, Tr>(edges: Arranged<G, Tr>, roots: VecCollection<G, N>) -> VecCollection<G, (N, u32)>
+pub fn bfs_arranged<G, N, Tr>(edges: Arranged<Tr>, roots: VecCollection<G, N>) -> VecCollection<G, (N, u32)>
 where
     G: Timestamp + Lattice + Ord,
     N: ExchangeData+Hash,
diff --git a/differential-dataflow/src/algorithms/graphs/bijkstra.rs b/differential-dataflow/src/algorithms/graphs/bijkstra.rs
index 4ff6c32a2..fe6e30911 100644
--- a/differential-dataflow/src/algorithms/graphs/bijkstra.rs
+++ b/differential-dataflow/src/algorithms/graphs/bijkstra.rs
@@ -34,8 +34,8 @@ use crate::operators::arrange::Arranged;
 
 /// Bi-directional Dijkstra search using arranged forward and reverse edge collections.
 pub fn bidijkstra_arranged<G, N, Tr>(
-    forward: Arranged<G, Tr>,
-    reverse: Arranged<G, Tr>,
+    forward: Arranged<Tr>,
+    reverse: Arranged<Tr>,
     goals: VecCollection<G, (N,N)>
 ) -> VecCollection<G, ((N,N), u32)>
 where
diff --git a/differential-dataflow/src/algorithms/graphs/propagate.rs b/differential-dataflow/src/algorithms/graphs/propagate.rs
index e08d788ab..5c158ddce 100644
--- a/differential-dataflow/src/algorithms/graphs/propagate.rs
+++ b/differential-dataflow/src/algorithms/graphs/propagate.rs
@@ -51,7 +51,7 @@ use crate::operators::arrange::arrangement::Arranged;
 /// This variant takes a pre-arranged edge collection, to facilitate re-use, and allows
 /// a method `logic` to specify the rounds in which we introduce various labels. The output
 /// of `logic should be a number in the interval \[0,64\],
-pub fn propagate_core<G, N, L, Tr, F, R>(edges: Arranged<G,Tr>, nodes: VecCollection<G,(N,L),R>, logic: F) -> VecCollection<G,(N,L),R>
+pub fn propagate_core<G, N, L, Tr, F, R>(edges: Arranged<Tr>, nodes: VecCollection<G,(N,L),R>, logic: F) -> VecCollection<G,(N,L),R>
 where
     G: Timestamp + Lattice + Ord + Hash,
     N: ExchangeData+Hash,
diff --git a/differential-dataflow/src/collection.rs b/differential-dataflow/src/collection.rs
index d0e4fd5c4..816e7212b 100644
--- a/differential-dataflow/src/collection.rs
+++ b/differential-dataflow/src/collection.rs
@@ -784,7 +784,7 @@ pub mod vec {
         ///          .trace;
         /// });
         /// ```
-        pub fn reduce_abelian<L, Bu, T2>(self, name: &str, mut logic: L) -> Arranged<G, TraceAgent<T2>>
+        pub fn reduce_abelian<L, Bu, T2>(self, name: &str, mut logic: L) -> Arranged<TraceAgent<T2>>
         where
             T2: for<'a> Trace<Key<'a>= &'a K, ValOwn = V, Time=G, Diff: Abelian>+'static,
             Bu: Builder<Time=T2::Time, Input = Vec<((K, V), T2::Time, T2::Diff)>, Output = T2::Batch>,
@@ -802,7 +802,7 @@ pub mod vec {
         /// Unlike `reduce_arranged`, this method may be called with an empty `input`,
         /// and it may not be safe to index into the first element.
         /// At least one of the two collections will be non-empty.
-        pub fn reduce_core<L, Bu, T2>(self, name: &str, logic: L) -> Arranged<G, TraceAgent<T2>>
+        pub fn reduce_core<L, Bu, T2>(self, name: &str, logic: L) -> Arranged<TraceAgent<T2>>
         where
             V: Clone+'static,
             T2: for<'a> Trace<Key<'a>=&'a K, ValOwn = V, Time=G>+'static,
@@ -1032,7 +1032,7 @@ pub mod vec {
         V: crate::ExchangeData,
         R: crate::ExchangeData + Semigroup,
     {
-        fn arrange_named<Ba, Bu, Tr>(self, name: &str) -> Arranged<G, TraceAgent<Tr>>
+        fn arrange_named<Ba, Bu, Tr>(self, name: &str) -> Arranged<TraceAgent<Tr>>
         where
             Ba: crate::trace::Batcher<Input=Vec<((K, V), G, R)>, Time=G> + 'static,
             Bu: crate::trace::Builder<Time=G, Input=Ba::Output, Output = Tr::Batch>,
@@ -1047,7 +1047,7 @@ pub mod vec {
     where
         G: Timestamp + Lattice + Ord,
     {
-        fn arrange_named<Ba, Bu, Tr>(self, name: &str) -> Arranged<G, TraceAgent<Tr>>
+        fn arrange_named<Ba, Bu, Tr>(self, name: &str) -> Arranged<TraceAgent<Tr>>
         where
             Ba: crate::trace::Batcher<Input=Vec<((K,()),G,R)>, Time=G> + 'static,
             Bu: crate::trace::Builder<Time=G, Input=Ba::Output, Output = Tr::Batch>,
@@ -1068,12 +1068,12 @@ pub mod vec {
         /// This operator arranges a stream of values into a shared trace, whose contents it maintains.
         /// This trace is current for all times completed by the output stream, which can be used to
         /// safely identify the stable times and values in the trace.
-        pub fn arrange_by_key(self) -> Arranged<G, TraceAgent<ValSpine<K, V, G, R>>> {
+        pub fn arrange_by_key(self) -> Arranged<TraceAgent<ValSpine<K, V, G, R>>> {
             self.arrange_by_key_named("ArrangeByKey")
         }
 
         /// As `arrange_by_key` but with the ability to name the arrangement.
-        pub fn arrange_by_key_named(self, name: &str) -> Arranged<G, TraceAgent<ValSpine<K, V, G, R>>> {
+        pub fn arrange_by_key_named(self, name: &str) -> Arranged<TraceAgent<ValSpine<K, V, G, R>>> {
             self.arrange_named::<ValBatcher<_,_,_,_>,ValBuilder<_,_,_,_>,_>(name)
         }
     }
@@ -1087,12 +1087,12 @@ pub mod vec {
         /// This operator arranges a collection of records into a shared trace, whose contents it maintains.
         /// This trace is current for all times complete in the output stream, which can be used to safely
         /// identify the stable times and values in the trace.
-        pub fn arrange_by_self(self) -> Arranged<G, TraceAgent<KeySpine<K, G, R>>> {
+        pub fn arrange_by_self(self) -> Arranged<TraceAgent<KeySpine<K, G, R>>> {
             self.arrange_by_self_named("ArrangeBySelf")
         }
 
         /// As `arrange_by_self` but with the ability to name the arrangement.
-        pub fn arrange_by_self_named(self, name: &str) -> Arranged<G, TraceAgent<KeySpine<K, G, R>>> {
+        pub fn arrange_by_self_named(self, name: &str) -> Arranged<TraceAgent<KeySpine<K, G, R>>> {
             self.map(|k| (k, ()))
                 .arrange_named::<KeyBatcher<_,_,_>,KeyBuilder<_,_,_>,_>(name)
         }
@@ -1244,7 +1244,7 @@ pub mod vec {
         ///      .assert_eq(z);
         /// });
         /// ```
-        pub fn join_core<Tr2,I,L> (self, stream2: Arranged<G,Tr2>, result: L) -> Collection<G,I::Item,<R as Multiply<Tr2::Diff>>::Output>
+        pub fn join_core<Tr2,I,L> (self, stream2: Arranged<Tr2>, result: L) -> Collection<G,I::Item,<R as Multiply<Tr2::Diff>>::Output>
         where
             Tr2: for<'a> crate::trace::TraceReader<Key<'a>=&'a K, Time=G>+Clone+'static,
             R: Multiply<Tr2::Diff, Output: Semigroup+'static>,
diff --git a/differential-dataflow/src/operators/arrange/agent.rs b/differential-dataflow/src/operators/arrange/agent.rs
index 7da94dc84..1cc88bd96 100644
--- a/differential-dataflow/src/operators/arrange/agent.rs
+++ b/differential-dataflow/src/operators/arrange/agent.rs
@@ -216,13 +216,13 @@ impl<Tr: TraceReader+'static> TraceAgent<Tr> {
     ///
     /// }).unwrap();
     /// ```
-    pub fn import(&mut self, scope: &Scope<Tr::Time>) -> Arranged<Tr::Time, TraceAgent<Tr>>
+    pub fn import(&mut self, scope: &Scope<Tr::Time>) -> Arranged<TraceAgent<Tr>>
     {
         self.import_named(scope, "ArrangedSource")
     }
 
     /// Same as `import`, but allows to name the source.
-    pub fn import_named(&mut self, scope: &Scope<Tr::Time>, name: &str) -> Arranged<Tr::Time, TraceAgent<Tr>>
+    pub fn import_named(&mut self, scope: &Scope<Tr::Time>, name: &str) -> Arranged<TraceAgent<Tr>>
     {
         // Drop ShutdownButton and return only the arrangement.
         self.import_core(scope, name).0
@@ -275,7 +275,7 @@ impl<Tr: TraceReader+'static> TraceAgent<Tr> {
     ///
     /// }).unwrap();
     /// ```
-    pub fn import_core(&mut self, scope: &Scope<Tr::Time>, name: &str) -> (Arranged<Tr::Time, TraceAgent<Tr>>, ShutdownButton<CapabilitySet<Tr::Time>>)
+    pub fn import_core(&mut self, scope: &Scope<Tr::Time>, name: &str) -> (Arranged<TraceAgent<Tr>>, ShutdownButton<CapabilitySet<Tr::Time>>)
     {
         let trace = self.clone();
 
@@ -388,7 +388,7 @@ impl<Tr: TraceReader+'static> TraceAgent<Tr> {
     ///
     /// }).unwrap();
     /// ```
-    pub fn import_frontier(&mut self, scope: &Scope<Tr::Time>, name: &str) -> (Arranged<Tr::Time, TraceFrontier<TraceAgent<Tr>>>, ShutdownButton<CapabilitySet<Tr::Time>>)
+    pub fn import_frontier(&mut self, scope: &Scope<Tr::Time>, name: &str) -> (Arranged<TraceFrontier<TraceAgent<Tr>>>, ShutdownButton<CapabilitySet<Tr::Time>>)
     where
         Tr: TraceReader,
     {
@@ -405,7 +405,7 @@ impl<Tr: TraceReader+'static> TraceAgent<Tr> {
     ///
     /// Invoking this method with an `until` of `Antichain::new()` will perform no filtering, as the empty
     /// frontier indicates the end of times.
-    pub fn import_frontier_core(&mut self, scope: &Scope<Tr::Time>, name: &str, since: Antichain<Tr::Time>, until: Antichain<Tr::Time>) -> (Arranged<Tr::Time, TraceFrontier<TraceAgent<Tr>>>, ShutdownButton<CapabilitySet<Tr::Time>>)
+    pub fn import_frontier_core(&mut self, scope: &Scope<Tr::Time>, name: &str, since: Antichain<Tr::Time>, until: Antichain<Tr::Time>) -> (Arranged<TraceFrontier<TraceAgent<Tr>>>, ShutdownButton<CapabilitySet<Tr::Time>>)
     where
         Tr: TraceReader,
     {
diff --git a/differential-dataflow/src/operators/arrange/arrangement.rs b/differential-dataflow/src/operators/arrange/arrangement.rs
index d00515d38..e2667d299 100644
--- a/differential-dataflow/src/operators/arrange/arrangement.rs
+++ b/differential-dataflow/src/operators/arrange/arrangement.rs
@@ -43,9 +43,8 @@ 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, Tr>
+pub struct Arranged<Tr>
 where
-    G: Timestamp,
     Tr: TraceReader+Clone,
 {
     /// A stream containing arranged updates.
@@ -53,14 +52,14 @@ where
     /// This stream contains the same batches of updates the trace itself accepts, so there should
     /// be no additional overhead to receiving these records. The batches can be navigated just as
     /// the batches in the trace, by key and by value.
-    pub stream: Stream<G, Vec<Tr::Batch>>,
+    pub stream: Stream<Tr::Time, Vec<Tr::Batch>>,
     /// A shared trace, updated by the `Arrange` operator and readable by others.
     pub trace: Tr,
     // TODO : We might have an `Option<Collection<G, (K, V)>>` here, which `as_collection` sets and
     // returns when invoked, so as to not duplicate work with multiple calls to `as_collection`.
 }
 
-impl<Tr> Clone for Arranged<Tr::Time, Tr>
+impl<Tr> Clone for Arranged<Tr>
 where
     Tr: TraceReader + Clone,
 {
@@ -75,7 +74,7 @@ where
 use ::timely::progress::timestamp::Refines;
 use timely::Container;
 
-impl<Tr> Arranged<Tr::Time, Tr>
+impl<Tr> Arranged<Tr>
 where
     Tr: TraceReader + Clone,
 {
@@ -85,7 +84,7 @@ where
     /// have all been extended with an additional coordinate with the default value. The resulting collection does
     /// not vary with the new timestamp coordinate.
     pub fn enter<TInner>(self, child: &Scope<TInner>)
-        -> Arranged<TInner, TraceEnter<Tr, TInner>>
+        -> Arranged<TraceEnter<Tr, TInner>>
         where
             TInner: Refines<Tr::Time>+Lattice+Timestamp+Clone,
     {
@@ -112,7 +111,7 @@ where
     /// have all been extended with an additional coordinate with the default value. The resulting collection does
     /// not vary with the new timestamp coordinate.
     pub fn enter_at<TInner, F, P>(self, child: &Scope<TInner>, logic: F, prior: P)
-        -> Arranged<TInner, TraceEnterAt<Tr, TInner, F, P>>
+        -> Arranged<TraceEnterAt<Tr, TInner, F, P>>
         where
             TInner: Refines<Tr::Time>+Lattice+Timestamp+Clone+'static,
             F: FnMut(Tr::Key<'_>, Tr::Val<'_>, Tr::TimeGat<'_>)->TInner+Clone+'static,
@@ -229,14 +228,14 @@ where
 
 use crate::difference::Multiply;
 // Direct join implementations.
-impl<T1> Arranged<T1::Time, T1>
+impl<T1> Arranged<T1>
 where
     T1: TraceReader<Time: Lattice> + Clone + 'static,
 {
     /// A convenience method to join and produce `VecCollection` output.
     ///
     /// Avoid this method, as it is likely to evolve into one without the `VecCollection` opinion.
-    pub fn join_core<T2,I,L>(self, other: Arranged<T1::Time,T2>, mut result: L) -> VecCollection<T1::Time,I::Item,<T1::Diff as Multiply<T2::Diff>>::Output>
+    pub fn join_core<T2,I,L>(self, other: Arranged<T2>, mut result: L) -> VecCollection<T1::Time,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, Output: Semigroup+'static>,
@@ -265,12 +264,12 @@ where
 
 // Direct reduce implementations.
 use crate::difference::Abelian;
-impl<T1> Arranged<T1::Time, T1>
+impl<T1> Arranged<T1>
 where
     T1: TraceReader<Time: Lattice> + Clone + 'static,
 {
     /// A direct implementation of `ReduceCore::reduce_abelian`.
-    pub fn reduce_abelian<L, Bu, T2, P>(self, name: &str, mut logic: L, push: P) -> Arranged<T1::Time, TraceAgent<T2>>
+    pub fn reduce_abelian<L, Bu, T2, P>(self, name: &str, mut logic: L, push: P) -> Arranged<TraceAgent<T2>>
     where
         T2: for<'a> Trace<
             Key<'a>= T1::Key<'a>,
@@ -292,7 +291,7 @@ where
     }
 
     /// A direct implementation of `ReduceCore::reduce_core`.
-    pub fn reduce_core<L, Bu, T2, P>(self, name: &str, logic: L, push: P) -> Arranged<T1::Time, TraceAgent<T2>>
+    pub fn reduce_core<L, Bu, T2, P>(self, name: &str, logic: L, push: P) -> Arranged<TraceAgent<T2>>
     where
         T2: for<'a> Trace<
             Key<'a>=T1::Key<'a>,
@@ -309,7 +308,7 @@ where
 }
 
 
-impl<Tr> Arranged<Tr::Time, Tr>
+impl<Tr> Arranged<Tr>
 where
     Tr: TraceReader + Clone,
 {
@@ -333,7 +332,7 @@ where
     G: Timestamp + Lattice,
 {
     /// Arranges updates into a shared trace.
-    fn arrange<Ba, Bu, Tr>(self) -> Arranged<G, TraceAgent<Tr>>
+    fn arrange<Ba, Bu, Tr>(self) -> Arranged<TraceAgent<Tr>>
     where
         Ba: Batcher<Input=C, Time=G> + 'static,
         Bu: Builder<Time=G, Input=Ba::Output, Output = Tr::Batch>,
@@ -343,7 +342,7 @@ where
     }
 
     /// Arranges updates into a shared trace, with a supplied name.
-    fn arrange_named<Ba, Bu, Tr>(self, name: &str) -> Arranged<G, TraceAgent<Tr>>
+    fn arrange_named<Ba, Bu, Tr>(self, name: &str) -> Arranged<TraceAgent<Tr>>
     where
         Ba: Batcher<Input=C, Time=G> + 'static,
         Bu: Builder<Time=G, Input=Ba::Output, Output = Tr::Batch>,
@@ -356,7 +355,7 @@ where
 /// This operator arranges a stream of values into a shared trace, whose contents it maintains.
 /// It uses the supplied parallelization contract to distribute the data, which does not need to
 /// be consistently by key (though this is the most common).
-pub fn arrange_core<G, P, Ba, Bu, Tr>(stream: Stream<G, Ba::Input>, pact: P, name: &str) -> Arranged<G, TraceAgent<Tr>>
+pub fn arrange_core<G, P, Ba, Bu, Tr>(stream: Stream<G, Ba::Input>, pact: P, name: &str) -> Arranged<TraceAgent<Tr>>
 where
     G: Timestamp + Lattice,
     P: ParallelizationContract<G, Ba::Input>,
diff --git a/differential-dataflow/src/operators/arrange/upsert.rs b/differential-dataflow/src/operators/arrange/upsert.rs
index 13d5f2cac..1962c1fa1 100644
--- a/differential-dataflow/src/operators/arrange/upsert.rs
+++ b/differential-dataflow/src/operators/arrange/upsert.rs
@@ -132,7 +132,7 @@ use super::TraceAgent;
 pub fn arrange_from_upsert<G, Bu, Tr, K, V>(
     stream: Stream<G, Vec<(K, Option<V>, G)>>,
     name: &str,
-) -> Arranged<G, TraceAgent<Tr>>
+) -> Arranged<TraceAgent<Tr>>
 where
     G: Timestamp,
     K: ExchangeData+Hashable+std::hash::Hash,
diff --git a/differential-dataflow/src/operators/count.rs b/differential-dataflow/src/operators/count.rs
index 5c0e2988e..4510f52a5 100644
--- a/differential-dataflow/src/operators/count.rs
+++ b/differential-dataflow/src/operators/count.rs
@@ -52,7 +52,7 @@ where
     }
 }
 
-impl<G, K, T1> CountTotal<G, K, T1::Diff> for Arranged<G, T1>
+impl<G, K, T1> CountTotal<G, K, T1::Diff> for Arranged<T1>
 where
     G: Timestamp + TotalOrder + Lattice + Ord,
     T1: for<'a> TraceReader<
diff --git a/differential-dataflow/src/operators/join.rs b/differential-dataflow/src/operators/join.rs
index f42362234..2d83f7531 100644
--- a/differential-dataflow/src/operators/join.rs
+++ b/differential-dataflow/src/operators/join.rs
@@ -67,7 +67,7 @@ impl<CB: PushInto<D>, D> PushInto<D> for EffortBuilder<CB> {
 /// The "correctness" of this method depends heavily on the behavior of the supplied `result` function.
 ///
 /// [`AsCollection`]: crate::collection::AsCollection
-pub fn join_traces<G, T1, T2, L, CB>(arranged1: Arranged<G,T1>, arranged2: Arranged<G,T2>, mut result: L) -> Stream<G, CB::Container>
+pub fn join_traces<G, T1, T2, L, CB>(arranged1: Arranged<T1>, arranged2: Arranged<T2>, mut result: L) -> Stream<G, CB::Container>
 where
     G: Timestamp + Lattice,
     T1: TraceReader<Time = G>+Clone+'static,
diff --git a/differential-dataflow/src/operators/reduce.rs b/differential-dataflow/src/operators/reduce.rs
index 5d04fd019..8313a3ed5 100644
--- a/differential-dataflow/src/operators/reduce.rs
+++ b/differential-dataflow/src/operators/reduce.rs
@@ -33,7 +33,7 @@ use crate::trace::TraceReader;
 /// the value updates, as appropriate for the container. It is critical that it clear the container as
 /// the operator has no ability to do this otherwise, and failing to do so represents a leak from one
 /// key's computation to another, and will likely introduce non-determinism.
-pub fn reduce_trace<T1, Bu, T2, L, P>(trace: Arranged<T1::Time, T1>, name: &str, mut logic: L, mut push: P) -> Arranged<T1::Time, TraceAgent<T2>>
+pub fn reduce_trace<T1, Bu, T2, L, P>(trace: Arranged<T1>, name: &str, mut logic: L, mut push: P) -> Arranged<TraceAgent<T2>>
 where
     T1: TraceReader<Time: crate::lattice::Lattice> + Clone + 'static,
     T2: for<'a> Trace<Key<'a>=T1::Key<'a>, ValOwn: Data, Time = T1::Time> + 'static,
diff --git a/differential-dataflow/src/operators/threshold.rs b/differential-dataflow/src/operators/threshold.rs
index e8bcea2e5..1bcde86e7 100644
--- a/differential-dataflow/src/operators/threshold.rs
+++ b/differential-dataflow/src/operators/threshold.rs
@@ -98,7 +98,7 @@ where
     }
 }
 
-impl<G, K, T1> ThresholdTotal<G, K, T1::Diff> for Arranged<G, T1>
+impl<G, K, T1> ThresholdTotal<G, K, T1::Diff> for Arranged<T1>
 where
     G: Timestamp + TotalOrder + Lattice + Ord,
     T1: for<'a> TraceReader<
diff --git a/dogsdogsdogs/src/operators/count.rs b/dogsdogsdogs/src/operators/count.rs
index b6a3b587c..6f770ff08 100644
--- a/dogsdogsdogs/src/operators/count.rs
+++ b/dogsdogsdogs/src/operators/count.rs
@@ -13,7 +13,7 @@ use differential_dataflow::trace::TraceReader;
 /// the `count` and `index` fields are overwritten with their new values.
 pub fn count<G, Tr, K, R, F, P>(
     prefixes: VecCollection<G, (P, usize, usize), R>,
-    arrangement: Arranged<G, Tr>,
+    arrangement: Arranged<Tr>,
     key_selector: F,
     index: usize,
 ) -> VecCollection<G, (P, usize, usize), R>
diff --git a/dogsdogsdogs/src/operators/half_join.rs b/dogsdogsdogs/src/operators/half_join.rs
index f6b2cbb3a..3a2f03352 100644
--- a/dogsdogsdogs/src/operators/half_join.rs
+++ b/dogsdogsdogs/src/operators/half_join.rs
@@ -76,7 +76,7 @@ use differential_dataflow::trace::implementations::BatchContainer;
 /// times specified in the payloads.
 pub fn half_join<G, K, V, R, Tr, FF, CF, DOut, S>(
     stream: VecCollection<G, (K, V, G), R>,
-    arrangement: Arranged<G, Tr>,
+    arrangement: Arranged<Tr>,
     frontier_func: FF,
     comparison: CF,
     mut output_func: S,
@@ -143,7 +143,7 @@ type SessionFor<'a, 'b, G, CB> =
 /// the number of matched records being easiest to record with low overhead.
 pub fn half_join_internal_unsafe<G, K, V, R, Tr, FF, CF, Y, S, CB>(
     stream: VecCollection<G, (K, V, G), R>,
-    mut arrangement: Arranged<G, Tr>,
+    mut arrangement: Arranged<Tr>,
     frontier_func: FF,
     comparison: CF,
     yield_function: Y,
diff --git a/dogsdogsdogs/src/operators/half_join2.rs b/dogsdogsdogs/src/operators/half_join2.rs
index 74ba919d8..6f79c294e 100644
--- a/dogsdogsdogs/src/operators/half_join2.rs
+++ b/dogsdogsdogs/src/operators/half_join2.rs
@@ -63,7 +63,7 @@ use timely::dataflow::operators::CapabilitySet;
 /// times specified in the payloads.
 pub fn half_join<G, K, V, R, Tr, FF, CF, DOut, S>(
     stream: VecCollection<G, (K, V, G), R>,
-    arrangement: Arranged<G, Tr>,
+    arrangement: Arranged<Tr>,
     frontier_func: FF,
     comparison: CF,
     mut output_func: S,
@@ -121,7 +121,7 @@ where
 /// the number of matched records being easiest to record with low overhead.
 pub fn half_join_internal_unsafe<G, K, V, R, Tr, FF, CF, Y, S, CB>(
     stream: VecCollection<G, (K, V, G), R>,
-    mut arrangement: Arranged<G, Tr>,
+    mut arrangement: Arranged<Tr>,
     frontier_func: FF,
     comparison: CF,
     yield_function: Y,
diff --git a/dogsdogsdogs/src/operators/lookup_map.rs b/dogsdogsdogs/src/operators/lookup_map.rs
index 8897b57fe..c59a02838 100644
--- a/dogsdogsdogs/src/operators/lookup_map.rs
+++ b/dogsdogsdogs/src/operators/lookup_map.rs
@@ -17,7 +17,7 @@ use differential_dataflow::trace::implementations::BatchContainer;
 /// and values associated with the key in `arrangement`.
 pub fn lookup_map<G, D, K, R, Tr, F, DOut, ROut, S>(
     prefixes: VecCollection<G, D, R>,
-    mut arrangement: Arranged<G, Tr>,
+    mut arrangement: Arranged<Tr>,
     key_selector: F,
     mut output_func: S,
     supplied_key0: K,
diff --git a/dogsdogsdogs/src/operators/propose.rs b/dogsdogsdogs/src/operators/propose.rs
index 508c5aafd..1335c4d6c 100644
--- a/dogsdogsdogs/src/operators/propose.rs
+++ b/dogsdogsdogs/src/operators/propose.rs
@@ -15,7 +15,7 @@ use differential_dataflow::trace::TraceReader;
 /// of delta queries.
 pub fn propose<G, Tr, K, F, P, V>(
     prefixes: VecCollection<G, P, Tr::Diff>,
-    arrangement: Arranged<G, Tr>,
+    arrangement: Arranged<Tr>,
     key_selector: F,
 ) -> VecCollection<G, (P, V), Tr::Diff>
 where
@@ -49,7 +49,7 @@ where
 /// avoid the need to prepare an arrangement of distinct extensions.
 pub fn propose_distinct<G, Tr, K, F, P, V>(
     prefixes: VecCollection<G, P, Tr::Diff>,
-    arrangement: Arranged<G, Tr>,
+    arrangement: Arranged<Tr>,
     key_selector: F,
 ) -> VecCollection<G, (P, V), Tr::Diff>
 where
diff --git a/dogsdogsdogs/src/operators/validate.rs b/dogsdogsdogs/src/operators/validate.rs
index 7ac81692d..a7cc52fec 100644
--- a/dogsdogsdogs/src/operators/validate.rs
+++ b/dogsdogsdogs/src/operators/validate.rs
@@ -14,7 +14,7 @@ use differential_dataflow::trace::TraceReader;
 /// and values associated with the key in `arrangement`.
 pub fn validate<G, K, V, Tr, F, P>(
     extensions: VecCollection<G, (P, V), Tr::Diff>,
-    arrangement: Arranged<G, Tr>,
+    arrangement: Arranged<Tr>,
     key_selector: F,
 ) -> VecCollection<G, (P, V), Tr::Diff>
 where
diff --git a/experiments/src/bin/deals-interactive.rs b/experiments/src/bin/deals-interactive.rs
index f3947fd5d..a3c29b5e3 100644
--- a/experiments/src/bin/deals-interactive.rs
+++ b/experiments/src/bin/deals-interactive.rs
@@ -12,7 +12,7 @@ use differential_dataflow::trace::implementations::ValSpine;
 use differential_dataflow::operators::arrange::TraceAgent;
 use differential_dataflow::operators::arrange::Arranged;
 
-type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, G, R>>>;
+type Arrange<G, K, V, R> = Arranged<TraceAgent<ValSpine<K, V, G, R>>>;
 
 type Node = u32;
 
diff --git a/experiments/src/bin/deals.rs b/experiments/src/bin/deals.rs
index 597d06fe2..89c9699a0 100644
--- a/experiments/src/bin/deals.rs
+++ b/experiments/src/bin/deals.rs
@@ -12,7 +12,7 @@ use differential_dataflow::operators::iterate::Variable;
 use differential_dataflow::lattice::Lattice;
 use differential_dataflow::difference::Present;
 
-type EdgeArranged<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, G, R>>>;
+type EdgeArranged<G, K, V, R> = Arranged<TraceAgent<ValSpine<K, V, G, R>>>;
 
 type Node = u32;
 type Edge = (Node, Node);
diff --git a/experiments/src/bin/graphs-interactive-alt.rs b/experiments/src/bin/graphs-interactive-alt.rs
index dbdffec8f..ee5b2d07a 100644
--- a/experiments/src/bin/graphs-interactive-alt.rs
+++ b/experiments/src/bin/graphs-interactive-alt.rs
@@ -258,7 +258,7 @@ use differential_dataflow::trace::implementations::ValSpine;
 use differential_dataflow::operators::arrange::TraceAgent;
 use differential_dataflow::operators::arrange::Arranged;
 
-type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, G, R>>>;
+type Arrange<G, K, V, R> = Arranged<TraceAgent<ValSpine<K, V, G, R>>>;
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
 fn three_hop<G: Timestamp + Lattice + Ord>(
diff --git a/experiments/src/bin/graphs-interactive-neu-zwei.rs b/experiments/src/bin/graphs-interactive-neu-zwei.rs
index 9d24f8156..6e6d0ea4c 100644
--- a/experiments/src/bin/graphs-interactive-neu-zwei.rs
+++ b/experiments/src/bin/graphs-interactive-neu-zwei.rs
@@ -226,7 +226,7 @@ use differential_dataflow::trace::implementations::ValSpine;
 use differential_dataflow::operators::arrange::TraceAgent;
 use differential_dataflow::operators::arrange::Arranged;
 
-type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, G, R>>>;
+type Arrange<G, K, V, R> = Arranged<TraceAgent<ValSpine<K, V, G, R>>>;
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
 fn three_hop<G: Timestamp + Lattice + Ord>(
diff --git a/experiments/src/bin/graphs-interactive-neu.rs b/experiments/src/bin/graphs-interactive-neu.rs
index dd8b92b6b..8d1cdfd7e 100644
--- a/experiments/src/bin/graphs-interactive-neu.rs
+++ b/experiments/src/bin/graphs-interactive-neu.rs
@@ -291,7 +291,7 @@ use differential_dataflow::trace::implementations::ValSpine;
 use differential_dataflow::operators::arrange::TraceAgent;
 use differential_dataflow::operators::arrange::Arranged;
 
-type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, G, R>>>;
+type Arrange<G, K, V, R> = Arranged<TraceAgent<ValSpine<K, V, G, R>>>;
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
 fn three_hop<G: Timestamp + Lattice + Ord>(
diff --git a/experiments/src/bin/graphs-interactive.rs b/experiments/src/bin/graphs-interactive.rs
index 7551186a9..7976d1a4c 100644
--- a/experiments/src/bin/graphs-interactive.rs
+++ b/experiments/src/bin/graphs-interactive.rs
@@ -194,7 +194,7 @@ use differential_dataflow::trace::implementations::ValSpine;
 use differential_dataflow::operators::arrange::TraceAgent;
 use differential_dataflow::operators::arrange::Arranged;
 
-type Arrange<G, K, V, R> = Arranged<G, TraceAgent<ValSpine<K, V, G, R>>>;
+type Arrange<G, K, V, R> = Arranged<TraceAgent<ValSpine<K, V, G, R>>>;
 
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
diff --git a/tpchlike/src/lib.rs b/tpchlike/src/lib.rs
index 053efd9d0..2ed7f6095 100644
--- a/tpchlike/src/lib.rs
+++ b/tpchlike/src/lib.rs
@@ -117,7 +117,7 @@ impl<G: Scope> Collections<G> {
 use differential_dataflow::trace::implementations::ValSpine;
 use differential_dataflow::operators::arrange::{Arranged, TraceAgent};
 
-type ArrangedScope<G, K, T> = Arranged<G, ArrangedIndex<K, T>>;
+type ArrangedScope<G, K, T> = Arranged<ArrangedIndex<K, T>>;
 type ArrangedIndex<K, T> = TraceAgent<ValSpine<K, T, usize, isize>>;
 
 pub struct ArrangementsInScope<G: Scope<Timestamp=usize>> {

From 010cfaaaccdd6e651a632f29ea32025eda2f05f2 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Thu, 9 Apr 2026 10:44:56 -0400
Subject: [PATCH 06/13] Standardize T for timestamps, Tr for traces

---
 .../src/algorithms/graphs/bfs.rs              | 10 +--
 .../src/algorithms/graphs/bijkstra.rs         | 14 ++--
 .../src/algorithms/graphs/propagate.rs        | 14 ++--
 .../src/operators/arrange/arrangement.rs      | 80 +++++++++----------
 differential-dataflow/src/operators/count.rs  | 18 ++---
 differential-dataflow/src/operators/join.rs   | 14 ++--
 differential-dataflow/src/operators/reduce.rs | 54 ++++++-------
 .../src/operators/threshold.rs                | 18 ++---
 dogsdogsdogs/src/operators/count.rs           | 10 +--
 dogsdogsdogs/src/operators/half_join.rs       | 56 ++++++-------
 dogsdogsdogs/src/operators/half_join2.rs      | 44 +++++-----
 dogsdogsdogs/src/operators/lookup_map.rs      | 12 +--
 dogsdogsdogs/src/operators/propose.rs         | 20 ++---
 dogsdogsdogs/src/operators/validate.rs        | 10 +--
 14 files changed, 187 insertions(+), 187 deletions(-)

diff --git a/differential-dataflow/src/algorithms/graphs/bfs.rs b/differential-dataflow/src/algorithms/graphs/bfs.rs
index 8d609d9c8..ac32e6e39 100644
--- a/differential-dataflow/src/algorithms/graphs/bfs.rs
+++ b/differential-dataflow/src/algorithms/graphs/bfs.rs
@@ -9,9 +9,9 @@ use crate::operators::*;
 use crate::lattice::Lattice;
 
 /// Returns pairs (node, dist) indicating distance of each node from a root.
-pub fn bfs<G, N>(edges: VecCollection<G, (N,N)>, roots: VecCollection<G, N>) -> VecCollection<G, (N,u32)>
+pub fn bfs<T, N>(edges: VecCollection<T, (N,N)>, roots: VecCollection<T, N>) -> VecCollection<T, (N,u32)>
 where
-    G: Timestamp + Lattice + Ord,
+    T: Timestamp + Lattice + Ord,
     N: ExchangeData+Hash,
 {
     let edges = edges.arrange_by_key();
@@ -22,11 +22,11 @@ use crate::trace::TraceReader;
 use crate::operators::arrange::Arranged;
 
 /// Returns pairs (node, dist) indicating distance of each node from a root.
-pub fn bfs_arranged<G, N, Tr>(edges: Arranged<Tr>, roots: VecCollection<G, N>) -> VecCollection<G, (N, u32)>
+pub fn bfs_arranged<T, N, Tr>(edges: Arranged<Tr>, roots: VecCollection<T, N>) -> VecCollection<T, (N, u32)>
 where
-    G: Timestamp + Lattice + Ord,
+    T: Timestamp + Lattice + Ord,
     N: ExchangeData+Hash,
-    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Time=G, Diff=isize>+Clone+'static,
+    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Time=T, Diff=isize>+Clone+'static,
 {
     // initialize roots as reaching themselves at distance 0
     let nodes = roots.map(|x| (x, 0));
diff --git a/differential-dataflow/src/algorithms/graphs/bijkstra.rs b/differential-dataflow/src/algorithms/graphs/bijkstra.rs
index fe6e30911..002956595 100644
--- a/differential-dataflow/src/algorithms/graphs/bijkstra.rs
+++ b/differential-dataflow/src/algorithms/graphs/bijkstra.rs
@@ -19,9 +19,9 @@ use crate::operators::iterate::Variable;
 /// Goals that cannot reach from the source to the target are relatively expensive, as
 /// the entire graph must be explored to confirm this. A graph connectivity pre-filter
 /// could be good insurance here.
-pub fn bidijkstra<G, N>(edges: VecCollection<G, (N,N)>, goals: VecCollection<G, (N,N)>) -> VecCollection<G, ((N,N), u32)>
+pub fn bidijkstra<T, N>(edges: VecCollection<T, (N,N)>, goals: VecCollection<T, (N,N)>) -> VecCollection<T, ((N,N), u32)>
 where
-    G: Timestamp + Lattice + Ord,
+    T: Timestamp + Lattice + Ord,
     N: ExchangeData+Hash,
 {
     let forward = edges.clone().arrange_by_key();
@@ -33,15 +33,15 @@ use crate::trace::TraceReader;
 use crate::operators::arrange::Arranged;
 
 /// Bi-directional Dijkstra search using arranged forward and reverse edge collections.
-pub fn bidijkstra_arranged<G, N, Tr>(
+pub fn bidijkstra_arranged<T, N, Tr>(
     forward: Arranged<Tr>,
     reverse: Arranged<Tr>,
-    goals: VecCollection<G, (N,N)>
-) -> VecCollection<G, ((N,N), u32)>
+    goals: VecCollection<T, (N,N)>
+) -> VecCollection<T, ((N,N), u32)>
 where
-    G: Timestamp + Lattice + Ord,
+    T: Timestamp + Lattice + Ord,
     N: ExchangeData+Hash,
-    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Time=G, Diff=isize>+Clone+'static,
+    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Time=T, Diff=isize>+Clone+'static,
 {
     let outer = forward.stream.scope();
     outer.iterative::<u64,_,_>(|inner| {
diff --git a/differential-dataflow/src/algorithms/graphs/propagate.rs b/differential-dataflow/src/algorithms/graphs/propagate.rs
index 5c158ddce..b11e3bc0d 100644
--- a/differential-dataflow/src/algorithms/graphs/propagate.rs
+++ b/differential-dataflow/src/algorithms/graphs/propagate.rs
@@ -13,9 +13,9 @@ use crate::difference::{Abelian, Multiply};
 /// This algorithm naively propagates all labels at once, much like standard label propagation.
 /// To more carefully control the label propagation, consider `propagate_core` which supports a
 /// method to limit the introduction of labels.
-pub fn propagate<G, N, L, R>(edges: VecCollection<G, (N,N), R>, nodes: VecCollection<G,(N,L),R>) -> VecCollection<G,(N,L),R>
+pub fn propagate<T, N, L, R>(edges: VecCollection<T, (N,N), R>, nodes: VecCollection<T,(N,L),R>) -> VecCollection<T,(N,L),R>
 where
-    G: Timestamp + Lattice + Ord + Hash,
+    T: Timestamp + Lattice + Ord + Hash,
     N: ExchangeData+Hash,
     R: ExchangeData+Abelian,
     R: Multiply<R, Output=R>,
@@ -30,9 +30,9 @@ where
 /// This algorithm naively propagates all labels at once, much like standard label propagation.
 /// To more carefully control the label propagation, consider `propagate_core` which supports a
 /// method to limit the introduction of labels.
-pub fn propagate_at<G, N, L, F, R>(edges: VecCollection<G, (N,N), R>, nodes: VecCollection<G,(N,L),R>, logic: F) -> VecCollection<G,(N,L),R>
+pub fn propagate_at<T, N, L, F, R>(edges: VecCollection<T, (N,N), R>, nodes: VecCollection<T,(N,L),R>, logic: F) -> VecCollection<T,(N,L),R>
 where
-    G: Timestamp + Lattice + Ord + Hash,
+    T: Timestamp + Lattice + Ord + Hash,
     N: ExchangeData+Hash,
     R: ExchangeData+Abelian,
     R: Multiply<R, Output=R>,
@@ -51,15 +51,15 @@ use crate::operators::arrange::arrangement::Arranged;
 /// This variant takes a pre-arranged edge collection, to facilitate re-use, and allows
 /// a method `logic` to specify the rounds in which we introduce various labels. The output
 /// of `logic should be a number in the interval \[0,64\],
-pub fn propagate_core<G, N, L, Tr, F, R>(edges: Arranged<Tr>, nodes: VecCollection<G,(N,L),R>, logic: F) -> VecCollection<G,(N,L),R>
+pub fn propagate_core<T, N, L, Tr, F, R>(edges: Arranged<Tr>, nodes: VecCollection<T,(N,L),R>, logic: F) -> VecCollection<T,(N,L),R>
 where
-    G: Timestamp + Lattice + Ord + Hash,
+    T: Timestamp + Lattice + Ord + Hash,
     N: ExchangeData+Hash,
     R: ExchangeData+Abelian,
     R: Multiply<R, Output=R>,
     R: From<i8>,
     L: ExchangeData,
-    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Time=G, Diff=R>+Clone+'static,
+    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Time=T, Diff=R>+Clone+'static,
     F: Fn(&L)->u64+Clone+'static,
 {
     // Morally the code performs the following iterative computation. However, in the interest of a simplified
diff --git a/differential-dataflow/src/operators/arrange/arrangement.rs b/differential-dataflow/src/operators/arrange/arrangement.rs
index e2667d299..eeb47095e 100644
--- a/differential-dataflow/src/operators/arrange/arrangement.rs
+++ b/differential-dataflow/src/operators/arrange/arrangement.rs
@@ -228,21 +228,21 @@ where
 
 use crate::difference::Multiply;
 // Direct join implementations.
-impl<T1> Arranged<T1>
+impl<Tr1> Arranged<Tr1>
 where
-    T1: TraceReader<Time: Lattice> + Clone + 'static,
+    Tr1: TraceReader<Time: Lattice> + Clone + 'static,
 {
     /// A convenience method to join and produce `VecCollection` output.
     ///
     /// Avoid this method, as it is likely to evolve into one without the `VecCollection` opinion.
-    pub fn join_core<T2,I,L>(self, other: Arranged<T2>, mut result: L) -> VecCollection<T1::Time,I::Item,<T1::Diff as Multiply<T2::Diff>>::Output>
+    pub fn join_core<Tr2,I,L>(self, other: Arranged<Tr2>, mut result: L) -> VecCollection<Tr1::Time,I::Item,<Tr1::Diff as Multiply<Tr2::Diff>>::Output>
     where
-        T2: for<'a> TraceReader<Key<'a>=T1::Key<'a>,Time=T1::Time>+Clone+'static,
-        T1::Diff: Multiply<T2::Diff, Output: Semigroup+'static>,
+        Tr2: for<'a> TraceReader<Key<'a>=Tr1::Key<'a>,Time=Tr1::Time>+Clone+'static,
+        Tr1::Diff: Multiply<Tr2::Diff, Output: Semigroup+'static>,
         I: IntoIterator<Item: Data>,
-        L: FnMut(T1::Key<'_>,T1::Val<'_>,T2::Val<'_>)->I+'static
+        L: FnMut(Tr1::Key<'_>,Tr1::Val<'_>,Tr2::Val<'_>)->I+'static
     {
-        let mut result = move |k: T1::Key<'_>, v1: T1::Val<'_>, v2: T2::Val<'_>, t: &T1::Time, r1: &T1::Diff, r2: &T2::Diff| {
+        let mut result = move |k: Tr1::Key<'_>, v1: Tr1::Val<'_>, v2: Tr2::Val<'_>, t: &Tr1::Time, r1: &Tr1::Diff, r2: &Tr2::Diff| {
             let t = t.clone();
             let r = (r1.clone()).multiply(r2);
             result(k, v1, v2).into_iter().map(move |d| (d, t.clone(), r.clone()))
@@ -264,24 +264,24 @@ where
 
 // Direct reduce implementations.
 use crate::difference::Abelian;
-impl<T1> Arranged<T1>
+impl<Tr1> Arranged<Tr1>
 where
-    T1: TraceReader<Time: Lattice> + Clone + 'static,
+    Tr1: TraceReader<Time: Lattice> + Clone + 'static,
 {
     /// A direct implementation of `ReduceCore::reduce_abelian`.
-    pub fn reduce_abelian<L, Bu, T2, P>(self, name: &str, mut logic: L, push: P) -> Arranged<TraceAgent<T2>>
+    pub fn reduce_abelian<L, Bu, Tr2, P>(self, name: &str, mut logic: L, push: P) -> Arranged<TraceAgent<Tr2>>
     where
-        T2: for<'a> Trace<
-            Key<'a>= T1::Key<'a>,
+        Tr2: for<'a> Trace<
+            Key<'a>= Tr1::Key<'a>,
             ValOwn: Data,
-            Time=T1::Time,
+            Time=Tr1::Time,
             Diff: Abelian,
         >+'static,
-        Bu: Builder<Time=T1::Time, Output = T2::Batch, Input: Default>,
-        L: FnMut(T1::Key<'_>, &[(T1::Val<'_>, T1::Diff)], &mut Vec<(T2::ValOwn, T2::Diff)>)+'static,
-        P: FnMut(&mut Bu::Input, T1::Key<'_>, &mut Vec<(T2::ValOwn, T2::Time, T2::Diff)>) + 'static,
+        Bu: Builder<Time=Tr1::Time, Output = Tr2::Batch, Input: Default>,
+        L: FnMut(Tr1::Key<'_>, &[(Tr1::Val<'_>, Tr1::Diff)], &mut Vec<(Tr2::ValOwn, Tr2::Diff)>)+'static,
+        P: FnMut(&mut Bu::Input, Tr1::Key<'_>, &mut Vec<(Tr2::ValOwn, Tr2::Time, Tr2::Diff)>) + 'static,
     {
-        self.reduce_core::<_,Bu,T2,_>(name, move |key, input, output, change| {
+        self.reduce_core::<_,Bu,Tr2,_>(name, move |key, input, output, change| {
             if !input.is_empty() {
                 logic(key, input, change);
             }
@@ -291,16 +291,16 @@ where
     }
 
     /// A direct implementation of `ReduceCore::reduce_core`.
-    pub fn reduce_core<L, Bu, T2, P>(self, name: &str, logic: L, push: P) -> Arranged<TraceAgent<T2>>
+    pub fn reduce_core<L, Bu, Tr2, P>(self, name: &str, logic: L, push: P) -> Arranged<TraceAgent<Tr2>>
     where
-        T2: for<'a> Trace<
-            Key<'a>=T1::Key<'a>,
+        Tr2: for<'a> Trace<
+            Key<'a>=Tr1::Key<'a>,
             ValOwn: Data,
-            Time=T1::Time,
+            Time=Tr1::Time,
         >+'static,
-        Bu: Builder<Time=T1::Time, Output = T2::Batch, Input: Default>,
-        L: FnMut(T1::Key<'_>, &[(T1::Val<'_>, T1::Diff)], &mut Vec<(T2::ValOwn, T2::Diff)>, &mut Vec<(T2::ValOwn, T2::Diff)>)+'static,
-        P: FnMut(&mut Bu::Input, T1::Key<'_>, &mut Vec<(T2::ValOwn, T2::Time, T2::Diff)>) + 'static,
+        Bu: Builder<Time=Tr1::Time, Output = Tr2::Batch, Input: Default>,
+        L: FnMut(Tr1::Key<'_>, &[(Tr1::Val<'_>, Tr1::Diff)], &mut Vec<(Tr2::ValOwn, Tr2::Diff)>, &mut Vec<(Tr2::ValOwn, Tr2::Diff)>)+'static,
+        P: FnMut(&mut Bu::Input, Tr1::Key<'_>, &mut Vec<(Tr2::ValOwn, Tr2::Time, Tr2::Diff)>) + 'static,
     {
         use crate::operators::reduce::reduce_trace;
         reduce_trace::<_,Bu,_,_,_>(self, name, logic, push)
@@ -327,16 +327,16 @@ where
 }
 
 /// A type that can be arranged as if a collection of updates.
-pub trait Arrange<G, C> : Sized
+pub trait Arrange<T, C> : Sized
 where
-    G: Timestamp + Lattice,
+    T: Timestamp + Lattice,
 {
     /// Arranges updates into a shared trace.
     fn arrange<Ba, Bu, Tr>(self) -> Arranged<TraceAgent<Tr>>
     where
-        Ba: Batcher<Input=C, Time=G> + 'static,
-        Bu: Builder<Time=G, Input=Ba::Output, Output = Tr::Batch>,
-        Tr: Trace<Time=G> + 'static,
+        Ba: Batcher<Input=C, Time=T> + 'static,
+        Bu: Builder<Time=T, Input=Ba::Output, Output = Tr::Batch>,
+        Tr: Trace<Time=T> + 'static,
     {
         self.arrange_named::<Ba, Bu, Tr>("Arrange")
     }
@@ -344,9 +344,9 @@ where
     /// Arranges updates into a shared trace, with a supplied name.
     fn arrange_named<Ba, Bu, Tr>(self, name: &str) -> Arranged<TraceAgent<Tr>>
     where
-        Ba: Batcher<Input=C, Time=G> + 'static,
-        Bu: Builder<Time=G, Input=Ba::Output, Output = Tr::Batch>,
-        Tr: Trace<Time=G> + 'static,
+        Ba: Batcher<Input=C, Time=T> + 'static,
+        Bu: Builder<Time=T, Input=Ba::Output, Output = Tr::Batch>,
+        Tr: Trace<Time=T> + 'static,
     ;
 }
 
@@ -355,13 +355,13 @@ where
 /// This operator arranges a stream of values into a shared trace, whose contents it maintains.
 /// It uses the supplied parallelization contract to distribute the data, which does not need to
 /// be consistently by key (though this is the most common).
-pub fn arrange_core<G, P, Ba, Bu, Tr>(stream: Stream<G, Ba::Input>, pact: P, name: &str) -> Arranged<TraceAgent<Tr>>
+pub fn arrange_core<T, P, Ba, Bu, Tr>(stream: Stream<T, Ba::Input>, pact: P, name: &str) -> Arranged<TraceAgent<Tr>>
 where
-    G: Timestamp + Lattice,
-    P: ParallelizationContract<G, Ba::Input>,
-    Ba: Batcher<Time=G,Input: Container> + 'static,
-    Bu: Builder<Time=G, Input=Ba::Output, Output = Tr::Batch>,
-    Tr: Trace<Time=G>+'static,
+    T: Timestamp + Lattice,
+    P: ParallelizationContract<T, Ba::Input>,
+    Ba: Batcher<Time=T,Input: Container> + 'static,
+    Bu: Builder<Time=T, Input=Ba::Output, Output = Tr::Batch>,
+    Tr: Trace<Time=T>+'static,
 {
     // The `Arrange` operator is tasked with reacting to an advancing input
     // frontier by producing the sequence of batches whose lower and upper
@@ -393,7 +393,7 @@ where
         let mut batcher = Ba::new(logger.clone(), info.global_id);
 
         // Capabilities for the lower envelope of updates in `batcher`.
-        let mut capabilities = Antichain::<Capability<G>>::new();
+        let mut capabilities = Antichain::<Capability<T>>::new();
 
         let activator = Some(scope.activator_for(info.address.clone()));
         let mut empty_trace = Tr::new(info.clone(), logger.clone(), activator);
@@ -407,7 +407,7 @@ where
         *reader_ref = Some(reader_local);
 
         // Initialize to the minimal input frontier.
-        let mut prev_frontier = Antichain::from_elem(<G as Timestamp>::minimum());
+        let mut prev_frontier = Antichain::from_elem(<T as Timestamp>::minimum());
 
         move |(input, frontier), output| {
 
diff --git a/differential-dataflow/src/operators/count.rs b/differential-dataflow/src/operators/count.rs
index 4510f52a5..2f92ad1ef 100644
--- a/differential-dataflow/src/operators/count.rs
+++ b/differential-dataflow/src/operators/count.rs
@@ -52,18 +52,18 @@ where
     }
 }
 
-impl<G, K, T1> CountTotal<G, K, T1::Diff> for Arranged<T1>
+impl<G, K, Tr> CountTotal<G, K, Tr::Diff> for Arranged<Tr>
 where
     G: Timestamp + TotalOrder + Lattice + Ord,
-    T1: for<'a> TraceReader<
+    Tr: for<'a> TraceReader<
         Key<'a> = &'a K,
         Val<'a>=&'a (),
         Time = G,
-        Diff: ExchangeData+Semigroup<T1::DiffGat<'a>>
+        Diff: ExchangeData+Semigroup<Tr::DiffGat<'a>>
     >+Clone+'static,
     K: ExchangeData,
 {
-    fn count_total_core<R2: Semigroup + From<i8> + 'static>(self) -> VecCollection<G, (K, T1::Diff), R2> {
+    fn count_total_core<R2: Semigroup + From<i8> + 'static>(self) -> VecCollection<G, (K, Tr::Diff), R2> {
 
         let mut trace = self.trace.clone();
 
@@ -103,13 +103,13 @@ where
                     let (mut trace_cursor, trace_storage) = trace.cursor_through(lower_limit.borrow()).unwrap();
 
                     while let Some(key) = batch_cursor.get_key(&batch_storage) {
-                        let mut count: Option<T1::Diff> = None;
+                        let mut count: Option<Tr::Diff> = None;
 
                         trace_cursor.seek_key(&trace_storage, key);
                         if trace_cursor.get_key(&trace_storage) == Some(key) {
                             trace_cursor.map_times(&trace_storage, |_, diff| {
                                 count.as_mut().map(|c| c.plus_equals(&diff));
-                                if count.is_none() { count = Some(T1::owned_diff(diff)); }
+                                if count.is_none() { count = Some(Tr::owned_diff(diff)); }
                             });
                         }
 
@@ -117,14 +117,14 @@ where
 
                             if let Some(count) = count.as_ref() {
                                 if !count.is_zero() {
-                                    session.give(((key.clone(), count.clone()), T1::owned_time(time), R2::from(-1i8)));
+                                    session.give(((key.clone(), count.clone()), Tr::owned_time(time), R2::from(-1i8)));
                                 }
                             }
                             count.as_mut().map(|c| c.plus_equals(&diff));
-                            if count.is_none() { count = Some(T1::owned_diff(diff)); }
+                            if count.is_none() { count = Some(Tr::owned_diff(diff)); }
                             if let Some(count) = count.as_ref() {
                                 if !count.is_zero() {
-                                    session.give(((key.clone(), count.clone()), T1::owned_time(time), R2::from(1i8)));
+                                    session.give(((key.clone(), count.clone()), Tr::owned_time(time), R2::from(1i8)));
                                 }
                             }
                         });
diff --git a/differential-dataflow/src/operators/join.rs b/differential-dataflow/src/operators/join.rs
index 2d83f7531..1a1bbd405 100644
--- a/differential-dataflow/src/operators/join.rs
+++ b/differential-dataflow/src/operators/join.rs
@@ -67,12 +67,12 @@ impl<CB: PushInto<D>, D> PushInto<D> for EffortBuilder<CB> {
 /// The "correctness" of this method depends heavily on the behavior of the supplied `result` function.
 ///
 /// [`AsCollection`]: crate::collection::AsCollection
-pub fn join_traces<G, T1, T2, L, CB>(arranged1: Arranged<T1>, arranged2: Arranged<T2>, mut result: L) -> Stream<G, CB::Container>
+pub fn join_traces<T, Tr1, Tr2, L, CB>(arranged1: Arranged<Tr1>, arranged2: Arranged<Tr2>, mut result: L) -> Stream<T, CB::Container>
 where
-    G: Timestamp + Lattice,
-    T1: TraceReader<Time = G>+Clone+'static,
-    T2: for<'a> TraceReader<Key<'a>=T1::Key<'a>, Time = G>+Clone+'static,
-    L: FnMut(T1::Key<'_>,T1::Val<'_>,T2::Val<'_>,&G,&T1::Diff,&T2::Diff,&mut JoinSession<G, CB, Capability<G>>)+'static,
+    T: Timestamp + Lattice,
+    Tr1: TraceReader<Time = T>+Clone+'static,
+    Tr2: for<'a> TraceReader<Key<'a>=Tr1::Key<'a>, Time = T>+Clone+'static,
+    L: FnMut(Tr1::Key<'_>,Tr1::Val<'_>,Tr2::Val<'_>,&T,&Tr1::Diff,&Tr2::Diff,&mut JoinSession<T, CB, Capability<T>>)+'static,
     CB: ContainerBuilder,
 {
     // Rename traces for symmetry from here on out.
@@ -98,8 +98,8 @@ where
         // the physical compaction frontier of their corresponding trace.
         // Should we ever *drop* a trace, these are 1. much harder to maintain correctly, but 2. no longer used.
         use timely::progress::frontier::Antichain;
-        let mut acknowledged1 = Antichain::from_elem(<G>::minimum());
-        let mut acknowledged2 = Antichain::from_elem(<G>::minimum());
+        let mut acknowledged1 = Antichain::from_elem(<T>::minimum());
+        let mut acknowledged2 = Antichain::from_elem(<T>::minimum());
 
         // deferred work of batches from each input.
         let mut todo1 = std::collections::VecDeque::new();
diff --git a/differential-dataflow/src/operators/reduce.rs b/differential-dataflow/src/operators/reduce.rs
index 8313a3ed5..ec83cfade 100644
--- a/differential-dataflow/src/operators/reduce.rs
+++ b/differential-dataflow/src/operators/reduce.rs
@@ -33,13 +33,13 @@ use crate::trace::TraceReader;
 /// the value updates, as appropriate for the container. It is critical that it clear the container as
 /// the operator has no ability to do this otherwise, and failing to do so represents a leak from one
 /// key's computation to another, and will likely introduce non-determinism.
-pub fn reduce_trace<T1, Bu, T2, L, P>(trace: Arranged<T1>, name: &str, mut logic: L, mut push: P) -> Arranged<TraceAgent<T2>>
+pub fn reduce_trace<Tr1, Bu, Tr2, L, P>(trace: Arranged<Tr1>, name: &str, mut logic: L, mut push: P) -> Arranged<TraceAgent<Tr2>>
 where
-    T1: TraceReader<Time: crate::lattice::Lattice> + Clone + 'static,
-    T2: for<'a> Trace<Key<'a>=T1::Key<'a>, ValOwn: Data, Time = T1::Time> + 'static,
-    Bu: Builder<Time=T2::Time, Output = T2::Batch, Input: Default>,
-    L: FnMut(T1::Key<'_>, &[(T1::Val<'_>, T1::Diff)], &mut Vec<(T2::ValOwn,T2::Diff)>, &mut Vec<(T2::ValOwn, T2::Diff)>)+'static,
-    P: FnMut(&mut Bu::Input, T1::Key<'_>, &mut Vec<(T2::ValOwn, T2::Time, T2::Diff)>) + 'static,
+    Tr1: TraceReader<Time: crate::lattice::Lattice> + Clone + 'static,
+    Tr2: for<'a> Trace<Key<'a>=Tr1::Key<'a>, ValOwn: Data, Time = Tr1::Time> + 'static,
+    Bu: Builder<Time=Tr2::Time, Output = Tr2::Batch, Input: Default>,
+    L: FnMut(Tr1::Key<'_>, &[(Tr1::Val<'_>, Tr1::Diff)], &mut Vec<(Tr2::ValOwn,Tr2::Diff)>, &mut Vec<(Tr2::ValOwn, Tr2::Diff)>)+'static,
+    P: FnMut(&mut Bu::Input, Tr1::Key<'_>, &mut Vec<(Tr2::ValOwn, Tr2::Time, Tr2::Diff)>) + 'static,
 {
     let mut result_trace = None;
 
@@ -54,7 +54,7 @@ where
             let logger = scope.logger_for::<crate::logging::DifferentialEventBuilder>("differential/arrange").map(Into::into);
 
             let activator = Some(scope.activator_for(operator_info.address.clone()));
-            let mut empty = T2::new(operator_info.clone(), logger.clone(), activator);
+            let mut empty = Tr2::new(operator_info.clone(), logger.clone(), activator);
             // If there is default exert logic set, install it.
             if let Some(exert_logic) = scope.config().get::<ExertionLogic>("differential/default_exert_logic").cloned() {
                 empty.set_exert_logic(exert_logic);
@@ -66,26 +66,26 @@ where
 
             *result_trace = Some(output_reader.clone());
 
-            let mut new_interesting_times = Vec::<T1::Time>::new();
+            let mut new_interesting_times = Vec::<Tr1::Time>::new();
 
             // Our implementation maintains a list of outstanding `(key, time)` synthetic interesting times,
             // sorted by (key, time), as well as capabilities for the lower envelope of the times.
-            let mut pending_keys = T1::KeyContainer::with_capacity(0);
-            let mut pending_time = T1::TimeContainer::with_capacity(0);
-            let mut next_pending_keys = T1::KeyContainer::with_capacity(0);
-            let mut next_pending_time = T1::TimeContainer::with_capacity(0);
-            let mut capabilities = timely::dataflow::operators::CapabilitySet::<T1::Time>::default();
+            let mut pending_keys = Tr1::KeyContainer::with_capacity(0);
+            let mut pending_time = Tr1::TimeContainer::with_capacity(0);
+            let mut next_pending_keys = Tr1::KeyContainer::with_capacity(0);
+            let mut next_pending_time = Tr1::TimeContainer::with_capacity(0);
+            let mut capabilities = timely::dataflow::operators::CapabilitySet::<Tr1::Time>::default();
 
             // buffers and logic for computing per-key interesting times "efficiently".
-            let mut interesting_times = Vec::<T1::Time>::new();
+            let mut interesting_times = Vec::<Tr1::Time>::new();
 
             // Upper and lower frontiers for the pending input and output batches to process.
-            let mut upper_limit = Antichain::from_elem(<T1::Time as timely::progress::Timestamp>::minimum());
-            let mut lower_limit = Antichain::from_elem(<T1::Time as timely::progress::Timestamp>::minimum());
+            let mut upper_limit = Antichain::from_elem(<Tr1::Time as timely::progress::Timestamp>::minimum());
+            let mut lower_limit = Antichain::from_elem(<Tr1::Time as timely::progress::Timestamp>::minimum());
 
             // Output batches may need to be built piecemeal, and these temp storage help there.
-            let mut output_upper = Antichain::from_elem(<T1::Time as timely::progress::Timestamp>::minimum());
-            let mut output_lower = Antichain::from_elem(<T1::Time as timely::progress::Timestamp>::minimum());
+            let mut output_upper = Antichain::from_elem(<Tr1::Time as timely::progress::Timestamp>::minimum());
+            let mut output_lower = Antichain::from_elem(<Tr1::Time as timely::progress::Timestamp>::minimum());
 
             move |(input, frontier), output| {
 
@@ -130,14 +130,14 @@ where
                     if capabilities.iter().any(|c| !upper_limit.less_equal(c.time())) {
 
                         // cursors for navigating input and output traces.
-                        let (mut source_cursor, ref source_storage): (T1::Cursor, _) = source_trace.cursor_through(lower_limit.borrow()).expect("failed to acquire source cursor");
-                        let (mut output_cursor, ref output_storage): (T2::Cursor, _) = output_reader.cursor_through(lower_limit.borrow()).expect("failed to acquire output cursor");
+                        let (mut source_cursor, ref source_storage): (Tr1::Cursor, _) = source_trace.cursor_through(lower_limit.borrow()).expect("failed to acquire source cursor");
+                        let (mut output_cursor, ref output_storage): (Tr2::Cursor, _) = output_reader.cursor_through(lower_limit.borrow()).expect("failed to acquire output cursor");
                         let (mut batch_cursor, ref batch_storage) = (CursorList::new(batch_cursors, &batch_storage), batch_storage);
 
                         // Prepare an output buffer and builder for each capability.
                         // TODO: It would be better if all updates went into one batch, but timely dataflow prevents
                         //       this as long as it requires that there is only one capability for each message.
-                        let mut buffers = Vec::<(T1::Time, Vec<(T2::ValOwn, T1::Time, T2::Diff)>)>::new();
+                        let mut buffers = Vec::<(Tr1::Time, Vec<(Tr2::ValOwn, Tr1::Time, Tr2::Diff)>)>::new();
                         let mut builders = Vec::new();
                         for cap in capabilities.iter() {
                             buffers.push((cap.time().clone(), Vec::new()));
@@ -171,7 +171,7 @@ where
                             let prior_pos = pending_pos;
                             interesting_times.clear();
                             while pending_keys.get(pending_pos) == Some(key) {
-                                let owned_time = T1::owned_time(pending_time.index(pending_pos));
+                                let owned_time = Tr1::owned_time(pending_time.index(pending_pos));
                                 if !upper_limit.less_equal(&owned_time) { interesting_times.push(owned_time); }
                                 pending_pos += 1;
                             }
@@ -201,7 +201,7 @@ where
                                 // Merge novel pending times with any prior pending times we did not process.
                                 // TODO: This could be a merge, not a sort_dedup, because both lists should be sorted.
                                 for pos in prior_pos .. pending_pos {
-                                    let owned_time = T1::owned_time(pending_time.index(pos));
+                                    let owned_time = Tr1::owned_time(pending_time.index(pos));
                                     if upper_limit.less_equal(&owned_time) { new_interesting_times.push(owned_time); }
                                 }
                                 sort_dedup(&mut new_interesting_times);
@@ -252,7 +252,7 @@ where
 
                             if output_upper.borrow() != output_lower.borrow() {
 
-                                let description = Description::new(output_lower.clone(), output_upper.clone(), Antichain::from_elem(T1::Time::minimum()));
+                                let description = Description::new(output_lower.clone(), output_upper.clone(), Antichain::from_elem(Tr1::Time::minimum()));
                                 let batch = builder.done(description);
 
                                 // ship batch to the output, and commit to the output trace.
@@ -272,10 +272,10 @@ where
                         pending_time.clear(); std::mem::swap(&mut next_pending_time, &mut pending_time);
 
                         // Update `capabilities` to reflect pending times.
-                        let mut frontier = Antichain::<T1::Time>::new();
-                        let mut owned_time = T1::Time::minimum();
+                        let mut frontier = Antichain::<Tr1::Time>::new();
+                        let mut owned_time = Tr1::Time::minimum();
                         for pos in 0 .. pending_time.len() {
-                            T1::clone_time_onto(pending_time.index(pos), &mut owned_time);
+                            Tr1::clone_time_onto(pending_time.index(pos), &mut owned_time);
                             frontier.insert_ref(&owned_time);
                         }
                         capabilities.downgrade(frontier);
diff --git a/differential-dataflow/src/operators/threshold.rs b/differential-dataflow/src/operators/threshold.rs
index 1bcde86e7..3ffba3e86 100644
--- a/differential-dataflow/src/operators/threshold.rs
+++ b/differential-dataflow/src/operators/threshold.rs
@@ -98,21 +98,21 @@ where
     }
 }
 
-impl<G, K, T1> ThresholdTotal<G, K, T1::Diff> for Arranged<T1>
+impl<G, K, Tr> ThresholdTotal<G, K, Tr::Diff> for Arranged<Tr>
 where
     G: Timestamp + TotalOrder + Lattice + Ord,
-    T1: for<'a> TraceReader<
+    Tr: for<'a> TraceReader<
         Key<'a>=&'a K,
         Val<'a>=&'a (),
         Time = G,
-        Diff : ExchangeData + Semigroup<T1::DiffGat<'a>>,
+        Diff : ExchangeData + Semigroup<Tr::DiffGat<'a>>,
     >+Clone+'static,
     K: ExchangeData,
 {
     fn threshold_semigroup<R2, F>(self, mut thresh: F) -> VecCollection<G, K, R2>
     where
         R2: Semigroup+'static,
-        F: for<'a> FnMut(T1::Key<'a>,&T1::Diff,Option<&T1::Diff>)->Option<R2>+'static,
+        F: for<'a> FnMut(Tr::Key<'a>,&Tr::Diff,Option<&Tr::Diff>)->Option<R2>+'static,
     {
 
         let mut trace = self.trace.clone();
@@ -153,14 +153,14 @@ where
                     let (mut trace_cursor, trace_storage) = trace.cursor_through(lower_limit.borrow()).unwrap();
 
                     while let Some(key) = batch_cursor.get_key(&batch_storage) {
-                        let mut count: Option<T1::Diff> = None;
+                        let mut count: Option<Tr::Diff> = None;
 
                         // Compute the multiplicity of this key before the current batch.
                         trace_cursor.seek_key(&trace_storage, key);
                         if trace_cursor.get_key(&trace_storage) == Some(key) {
                             trace_cursor.map_times(&trace_storage, |_, diff| {
                                 count.as_mut().map(|c| c.plus_equals(&diff));
-                                if count.is_none() { count = Some(T1::owned_diff(diff)); }
+                                if count.is_none() { count = Some(Tr::owned_diff(diff)); }
                             });
                         }
 
@@ -175,7 +175,7 @@ where
                                     temp.plus_equals(&diff);
                                     thresh(key, &temp, Some(old))
                                 },
-                                None => { thresh(key, &T1::owned_diff(diff), None) },
+                                None => { thresh(key, &Tr::owned_diff(diff), None) },
                             };
 
                             // Either add or assign `diff` to `count`.
@@ -183,12 +183,12 @@ where
                                 count.plus_equals(&diff);
                             }
                             else {
-                                count = Some(T1::owned_diff(diff));
+                                count = Some(Tr::owned_diff(diff));
                             }
 
                             if let Some(difference) = difference {
                                 if !difference.is_zero() {
-                                    session.give((key.clone(), T1::owned_time(time), difference));
+                                    session.give((key.clone(), Tr::owned_time(time), difference));
                                 }
                             }
                         });
diff --git a/dogsdogsdogs/src/operators/count.rs b/dogsdogsdogs/src/operators/count.rs
index 6f770ff08..5a1047ff0 100644
--- a/dogsdogsdogs/src/operators/count.rs
+++ b/dogsdogsdogs/src/operators/count.rs
@@ -11,15 +11,15 @@ use differential_dataflow::trace::TraceReader;
 /// For each triple, it extracts a key using `key_selector`, and finds the
 /// associated count in `arrangement`. If the found count is less than `count`,
 /// the `count` and `index` fields are overwritten with their new values.
-pub fn count<G, Tr, K, R, F, P>(
-    prefixes: VecCollection<G, (P, usize, usize), R>,
+pub fn count<T, Tr, K, R, F, P>(
+    prefixes: VecCollection<T, (P, usize, usize), R>,
     arrangement: Arranged<Tr>,
     key_selector: F,
     index: usize,
-) -> VecCollection<G, (P, usize, usize), R>
+) -> VecCollection<T, (P, usize, usize), R>
 where
-    G: Timestamp + std::hash::Hash,
-    Tr: TraceReader<Time = G, Diff=isize>+Clone+'static,
+    T: Timestamp + std::hash::Hash,
+    Tr: TraceReader<Time = T, Diff=isize>+Clone+'static,
     Tr::KeyContainer: differential_dataflow::trace::implementations::BatchContainer<Owned=K>,
     for<'a> Tr::Diff : Semigroup<Tr::DiffGat<'a>>,
     K: Hashable + Ord + Default + 'static,
diff --git a/dogsdogsdogs/src/operators/half_join.rs b/dogsdogsdogs/src/operators/half_join.rs
index 3a2f03352..aa0783708 100644
--- a/dogsdogsdogs/src/operators/half_join.rs
+++ b/dogsdogsdogs/src/operators/half_join.rs
@@ -74,28 +74,28 @@ use differential_dataflow::trace::implementations::BatchContainer;
 /// Notice that the time is hoisted up into data. The expectation is that
 /// once out of the "delta flow region", the updates will be `delay`d to the
 /// times specified in the payloads.
-pub fn half_join<G, K, V, R, Tr, FF, CF, DOut, S>(
-    stream: VecCollection<G, (K, V, G), R>,
+pub fn half_join<T, K, V, R, Tr, FF, CF, DOut, S>(
+    stream: VecCollection<T, (K, V, T), R>,
     arrangement: Arranged<Tr>,
     frontier_func: FF,
     comparison: CF,
     mut output_func: S,
-) -> VecCollection<G, (DOut, G), <R as Mul<Tr::Diff>>::Output>
+) -> VecCollection<T, (DOut, T), <R as Mul<Tr::Diff>>::Output>
 where
-    G: Timestamp + Lattice,
+    T: Timestamp + Lattice,
     K: Hashable + ExchangeData,
     V: ExchangeData,
     R: ExchangeData + Monoid,
-    Tr: TraceReader<Time = G>+Clone+'static,
-    G: std::hash::Hash,
+    Tr: TraceReader<Time = T>+Clone+'static,
+    T: std::hash::Hash,
     Tr::KeyContainer: BatchContainer<Owned=K>,
     R: Mul<Tr::Diff, Output: Semigroup>,
-    FF: Fn(&G, &mut Antichain<G>) + 'static,
-    CF: Fn(Tr::TimeGat<'_>, &G) -> bool + 'static,
+    FF: Fn(&T, &mut Antichain<T>) + 'static,
+    CF: Fn(Tr::TimeGat<'_>, &T) -> bool + 'static,
     DOut: Clone+'static,
     S: FnMut(&K, &V, Tr::Val<'_>)->DOut+'static,
 {
-    let output_func = move |session: &mut SessionFor<G, _>, k: &K, v1: &V, v2: Tr::Val<'_>, initial: &G, diff1: &R, output: &mut Vec<(G, Tr::Diff)>| {
+    let output_func = move |session: &mut SessionFor<T, _>, k: &K, v1: &V, v2: Tr::Val<'_>, initial: &T, diff1: &R, output: &mut Vec<(T, Tr::Diff)>| {
         for (time, diff2) in output.drain(..) {
             let diff = diff1.clone() * diff2.clone();
             let dout = (output_func(k, v1, v2), time.clone());
@@ -106,14 +106,14 @@ where
         .as_collection()
 }
 
-/// A session with lifetime `'a` in a scope `G` with a container builder `CB`.
+/// A session with lifetime `'a` in a scope `T` with a container builder `CB`.
 ///
 /// This is a shorthand primarily for the reson of readability.
-type SessionFor<'a, 'b, G, CB> =
+type SessionFor<'a, 'b, T, CB> =
     Session<'a, 'b,
-        G,
+        T,
         CB,
-        Capability<G>,
+        Capability<T>,
     >;
 
 /// An unsafe variant of `half_join` where the `output_func` closure takes
@@ -141,26 +141,26 @@ type SessionFor<'a, 'b, G, CB> =
 /// yield control, as a function of the elapsed time and the number of matched
 /// records. Note this is not the number of *output* records, owing mainly to
 /// the number of matched records being easiest to record with low overhead.
-pub fn half_join_internal_unsafe<G, K, V, R, Tr, FF, CF, Y, S, CB>(
-    stream: VecCollection<G, (K, V, G), R>,
+pub fn half_join_internal_unsafe<T, K, V, R, Tr, FF, CF, Y, S, CB>(
+    stream: VecCollection<T, (K, V, T), R>,
     mut arrangement: Arranged<Tr>,
     frontier_func: FF,
     comparison: CF,
     yield_function: Y,
     mut output_func: S,
-) -> Stream<G, CB::Container>
+) -> Stream<T, CB::Container>
 where
-    G: Timestamp + Lattice,
+    T: Timestamp + Lattice,
     K: Hashable + ExchangeData,
     V: ExchangeData,
     R: ExchangeData + Monoid,
-    Tr: TraceReader<Time = G>+Clone+'static,
-    G: std::hash::Hash,
+    Tr: TraceReader<Time = T>+Clone+'static,
+    T: std::hash::Hash,
     Tr::KeyContainer: BatchContainer<Owned=K>,
-    FF: Fn(&G, &mut Antichain<G>) + 'static,
+    FF: Fn(&T, &mut Antichain<T>) + 'static,
     CF: Fn(Tr::TimeGat<'_>, &Tr::Time) -> bool + 'static,
     Y: Fn(std::time::Instant, usize) -> bool + 'static,
-    S: FnMut(&mut SessionFor<G, CB>, &K, &V, Tr::Val<'_>, &G, &R, &mut Vec<(G, Tr::Diff)>) + 'static,
+    S: FnMut(&mut SessionFor<T, CB>, &K, &V, Tr::Val<'_>, &T, &R, &mut Vec<(T, Tr::Diff)>) + 'static,
     CB: ContainerBuilder,
 {
     // No need to block physical merging for this operator.
@@ -170,7 +170,7 @@ where
 
     let mut stash = HashMap::new();
 
-    let exchange = Exchange::new(move |update: &((K, V, G),G,R)| (update.0).0.hashed().into());
+    let exchange = Exchange::new(move |update: &((K, V, T),T,R)| (update.0).0.hashed().into());
 
     // Stash for (time, diff) accumulation.
     let mut output_buffer = Vec::new();
@@ -218,7 +218,7 @@ where
 
                         // Update yielded: We can only go from false to {false, true} as
                         // we're checking that `!yielded` holds before entering this block.
-                        yielded = process_proposals::<G, _, _, _, _, _, _, _, _>(
+                        yielded = process_proposals::<T, _, _, _, _, _, _, _, _>(
                             &comparison,
                             &yield_function,
                             &mut output_func,
@@ -302,7 +302,7 @@ where
 /// Leaves a zero diff in place for all proposals that were processed.
 ///
 /// Returns `true` if the operator should yield.
-fn process_proposals<G, Tr, CF, Y, S, CB, K, V, R>(
+fn process_proposals<T, Tr, CF, Y, S, CB, K, V, R>(
     comparison: &CF,
     yield_function: &Y,
     output_func: &mut S,
@@ -311,16 +311,16 @@ fn process_proposals<G, Tr, CF, Y, S, CB, K, V, R>(
     work: &mut usize,
     trace: &mut Tr,
     proposals: &mut Vec<((K, V, Tr::Time), Tr::Time, R)>,
-    mut session: SessionFor<G, CB>,
+    mut session: SessionFor<T, CB>,
     frontier: AntichainRef<Tr::Time>
 ) -> bool
 where
-    G: Timestamp + Lattice,
-    Tr: TraceReader<Time = G>,
+    T: Timestamp + Lattice,
+    Tr: TraceReader<Time = T>,
     Tr::KeyContainer: BatchContainer<Owned=K>,
     CF: Fn(Tr::TimeGat<'_>, &Tr::Time) -> bool + 'static,
     Y: Fn(Instant, usize) -> bool + 'static,
-    S: FnMut(&mut SessionFor<G, CB>, &K, &V, Tr::Val<'_>, &G, &R, &mut Vec<(G, Tr::Diff)>) + 'static,
+    S: FnMut(&mut SessionFor<T, CB>, &K, &V, Tr::Val<'_>, &T, &R, &mut Vec<(T, Tr::Diff)>) + 'static,
     CB: ContainerBuilder,
     K: Ord,
     V: Ord,
diff --git a/dogsdogsdogs/src/operators/half_join2.rs b/dogsdogsdogs/src/operators/half_join2.rs
index 6f79c294e..9e04602c4 100644
--- a/dogsdogsdogs/src/operators/half_join2.rs
+++ b/dogsdogsdogs/src/operators/half_join2.rs
@@ -61,28 +61,28 @@ use timely::dataflow::operators::CapabilitySet;
 /// Notice that the time is hoisted up into data. The expectation is that
 /// once out of the "delta flow region", the updates will be `delay`d to the
 /// times specified in the payloads.
-pub fn half_join<G, K, V, R, Tr, FF, CF, DOut, S>(
-    stream: VecCollection<G, (K, V, G), R>,
+pub fn half_join<T, K, V, R, Tr, FF, CF, DOut, S>(
+    stream: VecCollection<T, (K, V, T), R>,
     arrangement: Arranged<Tr>,
     frontier_func: FF,
     comparison: CF,
     mut output_func: S,
-) -> VecCollection<G, (DOut, G), <R as Mul<Tr::Diff>>::Output>
+) -> VecCollection<T, (DOut, T), <R as Mul<Tr::Diff>>::Output>
 where
-    G: Timestamp + Lattice,
+    T: Timestamp + Lattice,
     K: Hashable + ExchangeData,
     V: ExchangeData,
     R: ExchangeData + Monoid,
-    Tr: TraceReader<Time = G>+Clone+'static,
-    G: std::hash::Hash,
+    Tr: TraceReader<Time = T>+Clone+'static,
+    T: std::hash::Hash,
     Tr::KeyContainer: BatchContainer<Owned=K>,
     R: Mul<Tr::Diff, Output: Semigroup>,
-    FF: Fn(&G, &mut Antichain<G>) + 'static,
-    CF: Fn(Tr::TimeGat<'_>, &G) -> bool + 'static,
+    FF: Fn(&T, &mut Antichain<T>) + 'static,
+    CF: Fn(Tr::TimeGat<'_>, &T) -> bool + 'static,
     DOut: Clone+'static,
     S: FnMut(&K, &V, Tr::Val<'_>)->DOut+'static,
 {
-    let output_func = move |builder: &mut CapacityContainerBuilder<Vec<_>>, k: &K, v1: &V, v2: Tr::Val<'_>, initial: &G, diff1: &R, output: &mut Vec<(G, Tr::Diff)>| {
+    let output_func = move |builder: &mut CapacityContainerBuilder<Vec<_>>, k: &K, v1: &V, v2: Tr::Val<'_>, initial: &T, diff1: &R, output: &mut Vec<(T, Tr::Diff)>| {
         for (time, diff2) in output.drain(..) {
             let diff = diff1.clone() * diff2.clone();
             let dout = (output_func(k, v1, v2), time.clone());
@@ -119,26 +119,26 @@ where
 /// yield control, as a function of the elapsed time and the number of matched
 /// records. Note this is not the number of *output* records, owing mainly to
 /// the number of matched records being easiest to record with low overhead.
-pub fn half_join_internal_unsafe<G, K, V, R, Tr, FF, CF, Y, S, CB>(
-    stream: VecCollection<G, (K, V, G), R>,
+pub fn half_join_internal_unsafe<T, K, V, R, Tr, FF, CF, Y, S, CB>(
+    stream: VecCollection<T, (K, V, T), R>,
     mut arrangement: Arranged<Tr>,
     frontier_func: FF,
     comparison: CF,
     yield_function: Y,
     mut output_func: S,
-) -> Stream<G, CB::Container>
+) -> Stream<T, CB::Container>
 where
-    G: Timestamp + Lattice,
+    T: Timestamp + Lattice,
     K: Hashable + ExchangeData,
     V: ExchangeData,
     R: ExchangeData + Monoid,
-    Tr: TraceReader<Time = G>+Clone+'static,
-    G: std::hash::Hash,
+    Tr: TraceReader<Time = T>+Clone+'static,
+    T: std::hash::Hash,
     Tr::KeyContainer: BatchContainer<Owned=K>,
-    FF: Fn(&G, &mut Antichain<G>) + 'static,
+    FF: Fn(&T, &mut Antichain<T>) + 'static,
     CF: Fn(Tr::TimeGat<'_>, &Tr::Time) -> bool + 'static,
     Y: Fn(std::time::Instant, usize) -> bool + 'static,
-    S: FnMut(&mut CB, &K, &V, Tr::Val<'_>, &G, &R, &mut Vec<(G, Tr::Diff)>) + 'static,
+    S: FnMut(&mut CB, &K, &V, Tr::Val<'_>, &T, &R, &mut Vec<(T, Tr::Diff)>) + 'static,
     CB: ContainerBuilder,
 {
     // No need to block physical merging for this operator.
@@ -146,7 +146,7 @@ where
     let mut arrangement_trace = Some(arrangement.trace);
     let arrangement_stream = arrangement.stream;
 
-    let exchange = Exchange::new(move |update: &((K, V, G),G,R)| (update.0).0.hashed().into());
+    let exchange = Exchange::new(move |update: &((K, V, T),T,R)| (update.0).0.hashed().into());
 
     // Stash for (time, diff) accumulation.
     let mut output_buffer = Vec::new();
@@ -154,7 +154,7 @@ where
     // Unified blobs: each blob holds data in (T, D, R) order, with a stuck_count
     // tracking how many elements at the back are not yet eligible for processing.
     // The ready prefix is sorted by (D, T, R) for cursor traversal.
-    let mut blobs: Vec<Blob<(K, V, G), G, R>> = Vec::new();
+    let mut blobs: Vec<Blob<(K, V, T), T, R>> = Vec::new();
 
     let scope = stream.scope();
     stream.inner.binary_frontier(arrangement_stream, exchange, Pipeline, "HalfJoin", move |_,info| {
@@ -165,7 +165,7 @@ where
         move |(input1, frontier1), (input2, frontier2), output| {
 
             // Drain all input into a single buffer.
-            let mut arriving: Vec<(G, (K, V, G), R)> = Vec::new();
+            let mut arriving: Vec<(T, (K, V, T), R)> = Vec::new();
             let mut caps = CapabilitySet::new();
             input1.for_each(|capability, data| {
                 caps.insert(capability.retain(0));
@@ -191,7 +191,7 @@ where
                 if let Some(min_time) = frontier.iter().min() {
                     time_con.push_own(min_time);
                 }
-                let eligible = |initial: &G| -> bool {
+                let eligible = |initial: &T| -> bool {
                     !(0..time_con.len()).any(|i| comparison(time_con.index(i), initial))
                 };
 
@@ -267,7 +267,7 @@ where
 
                     let (mut cursor, storage) = trace.cursor();
                     let mut key_con = Tr::KeyContainer::with_capacity(1);
-                    let mut removals: ChangeBatch<G> = ChangeBatch::new();
+                    let mut removals: ChangeBatch<T> = ChangeBatch::new();
 
                     // Process ready elements from the front.
                     while blob.data.len() > blob.stuck_count {
diff --git a/dogsdogsdogs/src/operators/lookup_map.rs b/dogsdogsdogs/src/operators/lookup_map.rs
index c59a02838..e1ed17c72 100644
--- a/dogsdogsdogs/src/operators/lookup_map.rs
+++ b/dogsdogsdogs/src/operators/lookup_map.rs
@@ -15,19 +15,19 @@ use differential_dataflow::trace::implementations::BatchContainer;
 /// This method takes a stream of prefixes and for each determines a
 /// key with `key_selector` and then proposes all pair af the prefix
 /// and values associated with the key in `arrangement`.
-pub fn lookup_map<G, D, K, R, Tr, F, DOut, ROut, S>(
-    prefixes: VecCollection<G, D, R>,
+pub fn lookup_map<T, D, K, R, Tr, F, DOut, ROut, S>(
+    prefixes: VecCollection<T, D, R>,
     mut arrangement: Arranged<Tr>,
     key_selector: F,
     mut output_func: S,
     supplied_key0: K,
     supplied_key1: K,
     supplied_key2: K,
-) -> VecCollection<G, DOut, ROut>
+) -> VecCollection<T, DOut, ROut>
 where
-    G: Timestamp + std::hash::Hash,
+    T: Timestamp + std::hash::Hash,
     Tr: for<'a> TraceReader<
-        Time = G,
+        Time = T,
         Diff : Semigroup<Tr::DiffGat<'a>>+Monoid+ExchangeData,
     >+Clone+'static,
     Tr::KeyContainer: BatchContainer<Owned=K>,
@@ -49,7 +49,7 @@ where
     let mut logic2 = key_selector.clone();
 
     let mut key: K = supplied_key0;
-    let exchange = Exchange::new(move |update: &(D,G,R)| {
+    let exchange = Exchange::new(move |update: &(D,T,R)| {
         logic1(&update.0, &mut key);
         key.hashed().into()
     });
diff --git a/dogsdogsdogs/src/operators/propose.rs b/dogsdogsdogs/src/operators/propose.rs
index 1335c4d6c..9897e5697 100644
--- a/dogsdogsdogs/src/operators/propose.rs
+++ b/dogsdogsdogs/src/operators/propose.rs
@@ -13,16 +13,16 @@ use differential_dataflow::trace::TraceReader;
 /// create a join if the `prefixes` collection is also arranged and responds to changes that
 /// `arrangement` undergoes. More complicated patterns are also appropriate, as in the case
 /// of delta queries.
-pub fn propose<G, Tr, K, F, P, V>(
-    prefixes: VecCollection<G, P, Tr::Diff>,
+pub fn propose<T, Tr, K, F, P, V>(
+    prefixes: VecCollection<T, P, Tr::Diff>,
     arrangement: Arranged<Tr>,
     key_selector: F,
-) -> VecCollection<G, (P, V), Tr::Diff>
+) -> VecCollection<T, (P, V), Tr::Diff>
 where
-    G: Timestamp + std::hash::Hash,
+    T: Timestamp + std::hash::Hash,
     Tr: for<'a> TraceReader<
         ValOwn = V,
-        Time = G,
+        Time = T,
         Diff: Monoid+Multiply<Output = Tr::Diff>+ExchangeData+Semigroup<Tr::DiffGat<'a>>,
     >+Clone+'static,
     Tr::KeyContainer: differential_dataflow::trace::implementations::BatchContainer<Owned=K>,
@@ -47,16 +47,16 @@ where
 /// Unlike `propose`, this method does not scale the multiplicity of matched
 /// prefixes by the number of matches in `arrangement`. This can be useful to
 /// avoid the need to prepare an arrangement of distinct extensions.
-pub fn propose_distinct<G, Tr, K, F, P, V>(
-    prefixes: VecCollection<G, P, Tr::Diff>,
+pub fn propose_distinct<T, Tr, K, F, P, V>(
+    prefixes: VecCollection<T, P, Tr::Diff>,
     arrangement: Arranged<Tr>,
     key_selector: F,
-) -> VecCollection<G, (P, V), Tr::Diff>
+) -> VecCollection<T, (P, V), Tr::Diff>
 where
-    G: Timestamp + std::hash::Hash,
+    T: Timestamp + std::hash::Hash,
     Tr: for<'a> TraceReader<
         ValOwn = V,
-        Time = G,
+        Time = T,
         Diff : Semigroup<Tr::DiffGat<'a>>+Monoid+Multiply<Output = Tr::Diff>+ExchangeData,
     >+Clone+'static,
     Tr::KeyContainer: differential_dataflow::trace::implementations::BatchContainer<Owned=K>,
diff --git a/dogsdogsdogs/src/operators/validate.rs b/dogsdogsdogs/src/operators/validate.rs
index a7cc52fec..aab844390 100644
--- a/dogsdogsdogs/src/operators/validate.rs
+++ b/dogsdogsdogs/src/operators/validate.rs
@@ -12,15 +12,15 @@ use differential_dataflow::trace::TraceReader;
 /// This method takes a stream of prefixes and for each determines a
 /// key with `key_selector` and then proposes all pair af the prefix
 /// and values associated with the key in `arrangement`.
-pub fn validate<G, K, V, Tr, F, P>(
-    extensions: VecCollection<G, (P, V), Tr::Diff>,
+pub fn validate<T, K, V, Tr, F, P>(
+    extensions: VecCollection<T, (P, V), Tr::Diff>,
     arrangement: Arranged<Tr>,
     key_selector: F,
-) -> VecCollection<G, (P, V), Tr::Diff>
+) -> VecCollection<T, (P, V), Tr::Diff>
 where
-    G: Timestamp + std::hash::Hash,
+    T: Timestamp + std::hash::Hash,
     Tr: for<'a> TraceReader<
-        Time = G,
+        Time = T,
         Diff : Semigroup<Tr::DiffGat<'a>>+Monoid+Multiply<Output = Tr::Diff>+ExchangeData,
     >+Clone+'static,
     Tr::KeyContainer: differential_dataflow::trace::implementations::BatchContainer<Owned=(K,V)>,

From 13905bed26b6ff97ac319ae3480f7eded0794711 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Thu, 9 Apr 2026 10:49:41 -0400
Subject: [PATCH 07/13] Correct local timely reference

---
 Cargo.toml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index f1a2b61a1..895c0407e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,8 +25,8 @@ rust-version = "1.86"
 differential-dataflow = { path = "differential-dataflow", default-features = false, version = "0.22.0" }
 #timely = { version = "0.28", default-features = false }
 columnar = { version = "0.12", default-features = false }
-#timely = { git = "https://github.com/TimelyDataflow/timely-dataflow" }
-timely = { path = "../timely-dataflow/timely/", default-features = false }
+timely = { git = "https://github.com/TimelyDataflow/timely-dataflow" }
+#timely = { path = "../timely-dataflow/timely/", default-features = false }
 
 [workspace.lints.clippy]
 type_complexity = "allow"

From aeb6c14c75d7d1ffd7af6e667a62871a8d81dafe Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Thu, 9 Apr 2026 11:42:13 -0400
Subject: [PATCH 08/13] Convert G generics to T

---
 differential-dataflow/examples/bfs.rs         |   4 +-
 differential-dataflow/examples/dynamic.rs     |   4 +-
 differential-dataflow/examples/graspan.rs     |  28 +--
 differential-dataflow/examples/interpreted.rs |   4 +-
 .../examples/iterate_container.rs             |   2 +-
 differential-dataflow/examples/monoid-bfs.rs  |   4 +-
 differential-dataflow/examples/pagerank.rs    |   4 +-
 .../examples/stackoverflow.rs                 |   4 +-
 .../src/algorithms/graphs/scc.rs              |  10 +-
 .../src/algorithms/graphs/sequential.rs       |  14 +-
 .../src/algorithms/identifiers.rs             |  10 +-
 .../src/algorithms/prefix_sum.rs              |  24 +--
 differential-dataflow/src/capture.rs          |   8 +-
 differential-dataflow/src/collection.rs       | 201 +++++++++---------
 .../src/operators/arrange/upsert.rs           |  22 +-
 differential-dataflow/src/operators/count.rs  |  24 +--
 .../src/operators/iterate.rs                  |  46 ++--
 .../src/operators/threshold.rs                |  28 +--
 differential-dataflow/tests/bfs.rs            |   4 +-
 differential-dataflow/tests/scc.rs            |  12 +-
 dogsdogsdogs/src/calculus.rs                  |  20 +-
 dogsdogsdogs/src/lib.rs                       |  42 ++--
 experiments/src/bin/graphs-interactive-alt.rs |  22 +-
 .../src/bin/graphs-interactive-neu-zwei.rs    |  22 +-
 experiments/src/bin/graphs-interactive-neu.rs |  18 +-
 experiments/src/bin/graphs-interactive.rs     |  18 +-
 mdbook/src/chapter_2/chapter_2_1.md           |   4 +-
 mdbook/src/chapter_2/chapter_2_2.md           |   2 +-
 mdbook/src/chapter_2/chapter_2_3.md           |   2 +-
 mdbook/src/chapter_2/chapter_2_4.md           |   4 +-
 mdbook/src/chapter_2/chapter_2_5.md           |   2 +-
 mdbook/src/chapter_2/chapter_2_6.md           |   2 +-
 mdbook/src/chapter_2/chapter_2_7.md           |   6 +-
 33 files changed, 310 insertions(+), 311 deletions(-)

diff --git a/differential-dataflow/examples/bfs.rs b/differential-dataflow/examples/bfs.rs
index cdbfd7842..db97f3938 100644
--- a/differential-dataflow/examples/bfs.rs
+++ b/differential-dataflow/examples/bfs.rs
@@ -90,9 +90,9 @@ fn main() {
 }
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn bfs<G>(edges: VecCollection<G, Edge>, roots: VecCollection<G, Node>) -> VecCollection<G, (Node, u32)>
+fn bfs<T>(edges: VecCollection<T, Edge>, roots: VecCollection<T, Node>) -> VecCollection<T, (Node, u32)>
 where
-    G: timely::progress::Timestamp + Lattice + Ord,
+    T: timely::progress::Timestamp + Lattice + Ord,
 {
     // initialize roots as reaching themselves at distance 0
     let nodes = roots.map(|x| (x, 0));
diff --git a/differential-dataflow/examples/dynamic.rs b/differential-dataflow/examples/dynamic.rs
index a4c121f98..c0206fbde 100644
--- a/differential-dataflow/examples/dynamic.rs
+++ b/differential-dataflow/examples/dynamic.rs
@@ -90,9 +90,9 @@ fn main() {
 }
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn bfs<G>(edges: VecCollection<G, Edge>, roots: VecCollection<G, Node>) -> VecCollection<G, (Node, u32)>
+fn bfs<T>(edges: VecCollection<T, Edge>, roots: VecCollection<T, Node>) -> VecCollection<T, (Node, u32)>
 where
-    G: timely::progress::Timestamp + Lattice + Ord,
+    T: timely::progress::Timestamp + Lattice + Ord,
 {
     use timely::order::Product;
     use iterate::Variable;
diff --git a/differential-dataflow/examples/graspan.rs b/differential-dataflow/examples/graspan.rs
index 1df5c2965..f6f89cfb7 100644
--- a/differential-dataflow/examples/graspan.rs
+++ b/differential-dataflow/examples/graspan.rs
@@ -68,7 +68,7 @@ use differential_dataflow::operators::arrange::{Arranged, TraceAgent};
 
 type TraceKeyHandle<K,T,R> = TraceAgent<KeySpine<K, T, R>>;
 type TraceValHandle<K,V,T,R> = TraceAgent<ValSpine<K, V, T, R>>;
-type Arrange<G,K,V,R> = Arranged<TraceValHandle<K, V, G, R>>;
+type Arrange<T,K,V,R> = Arranged<TraceValHandle<K, V, T, R>>;
 
 /// An evolving set of edges.
 ///
@@ -78,17 +78,17 @@ type Arrange<G,K,V,R> = Arranged<TraceValHandle<K, V, G, R>>;
 ///
 /// 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: Timestamp + Lattice> {
-    variable: VecVariable<G, Edge, Diff>,
-    collection: VecCollection<G, Edge, Diff>,
-    current: VecCollection<G, Edge, Diff>,
-    forward: Option<Arrange<G, Node, Node, Diff>>,
-    reverse: Option<Arrange<G, Node, Node, Diff>>,
+pub struct EdgeVariable<T: Timestamp + Lattice> {
+    variable: VecVariable<T, Edge, Diff>,
+    collection: VecCollection<T, Edge, Diff>,
+    current: VecCollection<T, Edge, Diff>,
+    forward: Option<Arrange<T, Node, Node, Diff>>,
+    reverse: Option<Arrange<T, Node, Node, Diff>>,
 }
 
-impl<G: Timestamp + Lattice> EdgeVariable<G> {
+impl<T: Timestamp + Lattice> EdgeVariable<T> {
     /// Creates a new variable initialized with `source`.
-    pub fn from(source: VecCollection<G, Edge>, step: <G as Timestamp>::Summary) -> Self {
+    pub fn from(source: VecCollection<T, Edge>, step: <T as Timestamp>::Summary) -> Self {
         let (variable, collection) = VecVariable::new(&mut source.scope(), step);
         EdgeVariable {
             variable,
@@ -99,7 +99,7 @@ impl<G: Timestamp + Lattice> EdgeVariable<G> {
         }
     }
     /// Concatenates `production` into the definition of the variable.
-    pub fn add_production(&mut self, production: VecCollection<G, Edge, Diff>) {
+    pub fn add_production(&mut self, production: VecCollection<T, Edge, Diff>) {
         self.current = self.current.clone().concat(production);
     }
     /// Finalizes the variable, connecting its recursive definition.
@@ -112,14 +112,14 @@ impl<G: Timestamp + Lattice> EdgeVariable<G> {
         self.variable.set(distinct);
     }
     /// The collection arranged in the forward direction.
-    pub fn forward(&mut self) -> &Arrange<G, Node, Node, Diff> {
+    pub fn forward(&mut self) -> &Arrange<T, Node, Node, Diff> {
         if self.forward.is_none() {
             self.forward = Some(self.collection.clone().arrange_by_key());
         }
         self.forward.as_ref().unwrap()
     }
     /// The collection arranged in the reverse direction.
-    pub fn reverse(&mut self) -> &Arrange<G, Node, Node, Diff> {
+    pub fn reverse(&mut self) -> &Arrange<T, Node, Node, Diff> {
         if self.reverse.is_none() {
             self.reverse = Some(self.collection.clone().map(|(x,y)| (y,x)).arrange_by_key());
         }
@@ -150,9 +150,9 @@ impl Query {
     }
 
     /// Creates a dataflow implementing the query, and returns input and trace handles.
-    pub fn render_in<G>(&self, scope: &mut Scope<G>) -> BTreeMap<String, RelationHandles<G>>
+    pub fn render_in<T>(&self, scope: &mut Scope<T>) -> BTreeMap<String, RelationHandles<T>>
     where
-        G: Timestamp + Lattice + ::timely::order::TotalOrder,
+        T: Timestamp + Lattice + ::timely::order::TotalOrder,
     {
         // Create new input (handle, stream) pairs
         let mut input_map = BTreeMap::new();
diff --git a/differential-dataflow/examples/interpreted.rs b/differential-dataflow/examples/interpreted.rs
index 68ebaafee..31a622108 100644
--- a/differential-dataflow/examples/interpreted.rs
+++ b/differential-dataflow/examples/interpreted.rs
@@ -36,9 +36,9 @@ fn main() {
     }).unwrap();
 }
 
-fn interpret<G>(edges: VecCollection<G, Edge>, relations: &[(usize, usize)]) -> VecCollection<G, Vec<Node>>
+fn interpret<T>(edges: VecCollection<T, Edge>, relations: &[(usize, usize)]) -> VecCollection<T, Vec<Node>>
 where
-    G: timely::progress::Timestamp + Lattice + Hash + Ord,
+    T: timely::progress::Timestamp + Lattice + Hash + Ord,
 {
 
     // arrange the edge relation three ways.
diff --git a/differential-dataflow/examples/iterate_container.rs b/differential-dataflow/examples/iterate_container.rs
index 78a516a8a..030094f6e 100644
--- a/differential-dataflow/examples/iterate_container.rs
+++ b/differential-dataflow/examples/iterate_container.rs
@@ -33,7 +33,7 @@ impl<C: ResultsIn<TS>, TS> ResultsIn<TS> for ContainerWrapper<C> {
     #[inline(always)] fn results_in(self, step: &TS) -> Self { ContainerWrapper(self.0.results_in(step)) }
 }
 
-fn wrap<G: timely::progress::Timestamp, C: timely::Container>(stream: Stream<G, C>) -> Stream<G, ContainerWrapper<C>> {
+fn wrap<T: timely::progress::Timestamp, C: timely::Container>(stream: Stream<T, C>) -> Stream<T, ContainerWrapper<C>> {
     let mut builder = OperatorBuilder::new("Wrap".to_string(), stream.scope());
     let (mut output, stream_out) = builder.new_output();
     let mut input = builder.new_input(stream, Pipeline);
diff --git a/differential-dataflow/examples/monoid-bfs.rs b/differential-dataflow/examples/monoid-bfs.rs
index 9c5267fb2..f658cce0f 100644
--- a/differential-dataflow/examples/monoid-bfs.rs
+++ b/differential-dataflow/examples/monoid-bfs.rs
@@ -121,9 +121,9 @@ fn main() {
 }
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn bfs<G>(edges: VecCollection<G, Edge, MinSum>, roots: VecCollection<G, Node, MinSum>) -> VecCollection<G, Node, MinSum>
+fn bfs<T>(edges: VecCollection<T, Edge, MinSum>, roots: VecCollection<T, Node, MinSum>) -> VecCollection<T, Node, MinSum>
 where
-    G: timely::progress::Timestamp + Lattice + Ord,
+    T: timely::progress::Timestamp + Lattice + Ord,
 {
     // repeatedly update minimal distances each node can be reached from each root
     let outer = roots.scope();
diff --git a/differential-dataflow/examples/pagerank.rs b/differential-dataflow/examples/pagerank.rs
index 2764dab23..b649316ad 100644
--- a/differential-dataflow/examples/pagerank.rs
+++ b/differential-dataflow/examples/pagerank.rs
@@ -77,9 +77,9 @@ fn main() {
 
 // Returns a weighted collection in which the weight of each node is proportional
 // to its PageRank in the input graph `edges`.
-fn pagerank<G>(iters: Iter, edges: VecCollection<G, Edge, Diff>) -> VecCollection<G, Node, Diff>
+fn pagerank<T>(iters: Iter, edges: VecCollection<T, Edge, Diff>) -> VecCollection<T, Node, Diff>
 where
-    G: timely::progress::Timestamp + Lattice,
+    T: timely::progress::Timestamp + Lattice,
 {
     // initialize many surfers at each node.
     let nodes =
diff --git a/differential-dataflow/examples/stackoverflow.rs b/differential-dataflow/examples/stackoverflow.rs
index 0e3c51ce0..5d25b19b1 100644
--- a/differential-dataflow/examples/stackoverflow.rs
+++ b/differential-dataflow/examples/stackoverflow.rs
@@ -104,9 +104,9 @@ fn main() {
 }
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn bfs<G>(edges: VecCollection<G, Edge>, roots: VecCollection<G, Node>) -> VecCollection<G, (Node, u32)>
+fn bfs<T>(edges: VecCollection<T, Edge>, roots: VecCollection<T, Node>) -> VecCollection<T, (Node, u32)>
 where
-    G: timely::progress::Timestamp + Lattice + Ord,
+    T: timely::progress::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/scc.rs b/differential-dataflow/src/algorithms/graphs/scc.rs
index 8efaa85c8..f158cdc08 100644
--- a/differential-dataflow/src/algorithms/graphs/scc.rs
+++ b/differential-dataflow/src/algorithms/graphs/scc.rs
@@ -12,9 +12,9 @@ use crate::difference::{Abelian, Multiply};
 use super::propagate::propagate;
 
 /// Returns the subset of edges in the same strongly connected component.
-pub fn strongly_connected<G, N, R>(graph: VecCollection<G, (N,N), R>) -> VecCollection<G, (N,N), R>
+pub fn strongly_connected<T, N, R>(graph: VecCollection<T, (N,N), R>) -> VecCollection<T, (N,N), R>
 where
-    G: Timestamp + Lattice + Ord + Hash,
+    T: Timestamp + Lattice + Ord + Hash,
     N: ExchangeData + Hash,
     R: ExchangeData + Abelian,
     R: Multiply<R, Output=R>,
@@ -36,10 +36,10 @@ where
     })
 }
 
-fn trim_edges<G, N, R>(cycle: VecCollection<G, (N,N), R>, edges: VecCollection<G, (N,N), R>)
-    -> VecCollection<G, (N,N), R>
+fn trim_edges<T, N, R>(cycle: VecCollection<T, (N,N), R>, edges: VecCollection<T, (N,N), R>)
+    -> VecCollection<T, (N,N), R>
 where
-    G: Timestamp + Lattice + Ord + Hash,
+    T: Timestamp + Lattice + Ord + Hash,
     N: ExchangeData + Hash,
     R: ExchangeData + Abelian,
     R: Multiply<R, Output=R>,
diff --git a/differential-dataflow/src/algorithms/graphs/sequential.rs b/differential-dataflow/src/algorithms/graphs/sequential.rs
index 930e04930..8ba203fa4 100644
--- a/differential-dataflow/src/algorithms/graphs/sequential.rs
+++ b/differential-dataflow/src/algorithms/graphs/sequential.rs
@@ -9,9 +9,9 @@ use crate::lattice::Lattice;
 use crate::operators::*;
 use crate::hashable::Hashable;
 
-fn _color<G, N>(edges: VecCollection<G, (N,N)>) -> VecCollection<G,(N,Option<u32>)>
+fn _color<T, N>(edges: VecCollection<T, (N,N)>) -> VecCollection<T,(N,Option<u32>)>
 where
-    G: Timestamp + Lattice + Ord + Hash,
+    T: Timestamp + Lattice + Ord + Hash,
     N: ExchangeData+Hash,
 {
     // need some bogus initial values.
@@ -40,12 +40,12 @@ where
 /// a node "fires" once all of its neighbors with lower identifier have
 /// fired, and we apply `logic` to the new state of lower neighbors and
 /// the old state (input) of higher neighbors.
-pub fn sequence<G, N, V, F>(
-    state: VecCollection<G, (N,V)>,
-    edges: VecCollection<G, (N,N)>,
-    logic: F) -> VecCollection<G, (N,Option<V>)>
+pub fn sequence<T, N, V, F>(
+    state: VecCollection<T, (N,V)>,
+    edges: VecCollection<T, (N,N)>,
+    logic: F) -> VecCollection<T, (N,Option<V>)>
 where
-    G: Timestamp + Lattice + Hash + Ord,
+    T: 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 d3dd28fd3..8c0678a53 100644
--- a/differential-dataflow/src/algorithms/identifiers.rs
+++ b/differential-dataflow/src/algorithms/identifiers.rs
@@ -8,7 +8,7 @@ use crate::operators::*;
 use crate::difference::Abelian;
 
 /// Assign unique identifiers to elements of a collection.
-pub trait Identifiers<G: Timestamp, D: ExchangeData, R: ExchangeData+Abelian> {
+pub trait Identifiers<T: Timestamp, D: ExchangeData, R: ExchangeData+Abelian> {
     /// Assign unique identifiers to elements of a collection.
     ///
     /// # Example
@@ -27,16 +27,16 @@ pub trait Identifiers<G: Timestamp, D: ExchangeData, R: ExchangeData+Abelian> {
     ///          .assert_empty();
     /// });
     /// ```
-    fn identifiers(self) -> VecCollection<G, (D, u64), R>;
+    fn identifiers(self) -> VecCollection<T, (D, u64), R>;
 }
 
-impl<G, D, R> Identifiers<G, D, R> for VecCollection<G, D, R>
+impl<T, D, R> Identifiers<T, D, R> for VecCollection<T, D, R>
 where
-    G: Timestamp + Lattice,
+    T: Timestamp + Lattice,
     D: ExchangeData + ::std::hash::Hash,
     R: ExchangeData + Abelian,
 {
-    fn identifiers(self) -> VecCollection<G, (D, u64), R> {
+    fn identifiers(self) -> VecCollection<T, (D, u64), R> {
 
         // The design here is that we iteratively develop a collection
         // of pairs (round, record), where each pair is a proposal that
diff --git a/differential-dataflow/src/algorithms/prefix_sum.rs b/differential-dataflow/src/algorithms/prefix_sum.rs
index 39c8d56c3..f7401d892 100644
--- a/differential-dataflow/src/algorithms/prefix_sum.rs
+++ b/differential-dataflow/src/algorithms/prefix_sum.rs
@@ -7,7 +7,7 @@ use crate::lattice::Lattice;
 use crate::operators::*;
 
 /// Extension trait for the prefix_sum method.
-pub trait PrefixSum<G: Timestamp, K, D> {
+pub trait PrefixSum<T: Timestamp, K, D> {
     /// Computes the prefix sum for each element in the collection.
     ///
     /// The prefix sum is data-parallel, in the sense that the sums are computed independently for
@@ -16,12 +16,12 @@ pub trait PrefixSum<G: Timestamp, K, D> {
     fn prefix_sum<F>(self, zero: D, combine: F) -> Self where F: Fn(&K,&D,&D)->D + 'static;
 
     /// Determine the prefix sum at each element of `location`.
-    fn prefix_sum_at<F>(self, locations: VecCollection<G, (usize, K)>, zero: D, combine: F) -> Self where F: Fn(&K,&D,&D)->D + 'static;
+    fn prefix_sum_at<F>(self, locations: VecCollection<T, (usize, K)>, zero: D, combine: F) -> Self where F: Fn(&K,&D,&D)->D + 'static;
 }
 
-impl<G, K, D> PrefixSum<G, K, D> for VecCollection<G, ((usize, K), D)>
+impl<T, K, D> PrefixSum<T, K, D> for VecCollection<T, ((usize, K), D)>
 where
-    G: Timestamp + Lattice,
+    T: Timestamp + Lattice,
     K: ExchangeData + ::std::hash::Hash,
     D: ExchangeData + ::std::hash::Hash,
 {
@@ -29,7 +29,7 @@ where
         self.clone().prefix_sum_at(self.map(|(x,_)| x), zero, combine)
     }
 
-    fn prefix_sum_at<F>(self, locations: VecCollection<G, (usize, K)>, zero: D, combine: F) -> Self where F: Fn(&K,&D,&D)->D + 'static {
+    fn prefix_sum_at<F>(self, locations: VecCollection<T, (usize, K)>, zero: D, combine: F) -> Self where F: Fn(&K,&D,&D)->D + 'static {
 
         let combine1 = ::std::rc::Rc::new(combine);
         let combine2 = combine1.clone();
@@ -40,9 +40,9 @@ where
 }
 
 /// Accumulate data in `collection` into all powers-of-two intervals containing them.
-pub fn aggregate<G, K, D, F>(collection: VecCollection<G, ((usize, K), D)>, combine: F) -> VecCollection<G, ((usize, usize, K), D)>
+pub fn aggregate<T, K, D, F>(collection: VecCollection<T, ((usize, K), D)>, combine: F) -> VecCollection<T, ((usize, usize, K), D)>
 where
-    G: Timestamp + Lattice,
+    T: Timestamp + Lattice,
     K: ExchangeData + ::std::hash::Hash,
     D: ExchangeData + ::std::hash::Hash,
     F: Fn(&K,&D,&D)->D + 'static,
@@ -73,13 +73,13 @@ where
 }
 
 /// Produces the accumulated values at each of the `usize` locations in `queries`.
-pub fn broadcast<G, K, D, F>(
-    ranges: VecCollection<G, ((usize, usize, K), D)>,
-    queries: VecCollection<G, (usize, K)>,
+pub fn broadcast<T, K, D, F>(
+    ranges: VecCollection<T, ((usize, usize, K), D)>,
+    queries: VecCollection<T, (usize, K)>,
     zero: D,
-    combine: F) -> VecCollection<G, ((usize, K), D)>
+    combine: F) -> VecCollection<T, ((usize, K), D)>
 where
-    G: Timestamp + Lattice + Ord + ::std::fmt::Debug,
+    T: 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/capture.rs b/differential-dataflow/src/capture.rs
index f36501448..65069bd74 100644
--- a/differential-dataflow/src/capture.rs
+++ b/differential-dataflow/src/capture.rs
@@ -741,9 +741,9 @@ pub mod sink {
 //     use crate::lattice::Lattice;
 
 //     /// Creates a Kafka source from supplied configuration information.
-//     pub fn create_source<G, D, T, R>(scope: G, addr: &str, topic: &str, group: &str) -> (Box<dyn std::any::Any>, Stream<G, Vec<(D, T, R)>>)
+//     pub fn create_source<T, D, T, R>(scope: T, addr: &str, topic: &str, group: &str) -> (Box<dyn std::any::Any>, Stream<T, Vec<(D, T, R)>>)
 //     where
-//         G: Scope<Timestamp = T>,
+//         T: Scope<Timestamp = T>,
 //         D: ExchangeData + Hash + for<'a> serde::Deserialize<'a>,
 //         T: ExchangeData + Hash + for<'a> serde::Deserialize<'a> + Timestamp + Lattice,
 //         R: ExchangeData + Hash + for<'a> serde::Deserialize<'a>,
@@ -756,9 +756,9 @@ pub mod sink {
 //         })
 //     }
 
-//     pub fn create_sink<G, D, T, R>(stream: &Stream<G, Vec<(D, T, R)>>, addr: &str, topic: &str) -> Box<dyn std::any::Any>
+//     pub fn create_sink<T, D, T, R>(stream: &Stream<T, Vec<(D, T, R)>>, addr: &str, topic: &str) -> Box<dyn std::any::Any>
 //     where
-//         G: Scope<Timestamp = T>,
+//         T: Scope<Timestamp = T>,
 //         D: ExchangeData + Hash + Serialize + for<'a> Deserialize<'a>,
 //         T: ExchangeData + Hash + Serialize + for<'a> Deserialize<'a> + Timestamp + Lattice,
 //         R: ExchangeData + Hash + Serialize + for<'a> Deserialize<'a>,
diff --git a/differential-dataflow/src/collection.rs b/differential-dataflow/src/collection.rs
index 816e7212b..4af2a69f2 100644
--- a/differential-dataflow/src/collection.rs
+++ b/differential-dataflow/src/collection.rs
@@ -21,7 +21,7 @@ use crate::difference::Abelian;
 /// in order to expose some of this functionality (e.g. negation, timestamp manipulation). Other actions
 /// on the containers, and streams of containers, are left to the container implementor to describe.
 #[derive(Clone)]
-pub struct Collection<G: Timestamp, C: 'static> {
+pub struct Collection<T: Timestamp, C: 'static> {
     /// The underlying timely dataflow stream.
     ///
     /// This field is exposed to support direct timely dataflow manipulation when required, but it is
@@ -30,10 +30,10 @@ pub struct Collection<G: Timestamp, C: 'static> {
     /// The timestamp in the data is required to always be at least the timestamp _of_ the data, in
     /// the timely-dataflow sense. If this invariant is not upheld, differential operators may behave
     /// unexpectedly.
-    pub inner: Stream<G, C>,
+    pub inner: Stream<T, C>,
 }
 
-impl<G: Timestamp, C> Collection<G, C> {
+impl<T: Timestamp, C> Collection<T, C> {
     /// Creates a new Collection from a timely dataflow stream.
     ///
     /// This method seems to be rarely used, with the `as_collection` method on streams being a more
@@ -43,9 +43,9 @@ impl<G: Timestamp, C> Collection<G, C> {
     ///
     /// This stream should satisfy the timestamp invariant as documented on [Collection]; this
     /// method does not check it.
-    pub fn new(stream: Stream<G, C>) -> Self { Self { inner: stream } }
+    pub fn new(stream: Stream<T, C>) -> Self { Self { inner: stream } }
 }
-impl<G: Timestamp, C: Container> Collection<G, C> {
+impl<T: Timestamp, C: Container> Collection<T, C> {
     /// Creates a new collection accumulating the contents of the two collections.
     ///
     /// Despite the name, differential dataflow collections are unordered. This method is so named because the
@@ -108,7 +108,7 @@ impl<G: Timestamp, C: Container> Collection<G, C> {
     ///
     /// This method is a specialization of `enter` to the case where the nested scope is a region.
     /// It removes the need for an operator that adjusts the timestamp.
-    pub fn enter_region(self, child: &Scope<G>) -> Self {
+    pub fn enter_region(self, child: &Scope<T>) -> Self {
         self.inner
             .enter(child)
             .as_collection()
@@ -133,7 +133,7 @@ impl<G: Timestamp, C: Container> Collection<G, C> {
     /// ```
     pub fn inspect_container<F>(self, func: F) -> Self
     where
-        F: FnMut(Result<(&G, &C), &[G]>)+'static,
+        F: FnMut(Result<(&T, &C), &[T]>)+'static,
     {
         self.inner
             .inspect_container(func)
@@ -143,7 +143,7 @@ impl<G: Timestamp, C: Container> Collection<G, C> {
     ///
     /// This probe is used to determine when the state of the Collection has stabilized and can
     /// be read out.
-    pub fn probe(self) -> (probe::Handle<G>, Self) {
+    pub fn probe(self) -> (probe::Handle<T>, Self) {
         let (handle, stream) = self.inner.probe();
         (handle, stream.as_collection())
     }
@@ -153,11 +153,11 @@ impl<G: Timestamp, C: Container> Collection<G, C> {
     /// In addition, a probe is also often use to limit the number of rounds of input in flight at any moment; a
     /// computation can wait until the probe has caught up to the input before introducing more rounds of data, to
     /// avoid swamping the system.
-    pub fn probe_with(self, handle: &probe::Handle<G>) -> Self {
+    pub fn probe_with(self, handle: &probe::Handle<T>) -> Self {
         Self::new(self.inner.probe_with(handle))
     }
     /// The scope containing the underlying timely dataflow stream.
-    pub fn scope(&self) -> Scope<G> {
+    pub fn scope(&self) -> Scope<T> {
         self.inner.scope()
     }
 
@@ -215,10 +215,10 @@ impl<G: Timestamp, C: Container> Collection<G, C> {
     ///     data.assert_eq(result);
     /// });
     /// ```
-    pub fn enter<T>(self, child: &Scope<T>) -> Collection<T, <C as containers::Enter<G, T>>::InnerContainer>
+    pub fn enter<TInner>(self, child: &Scope<TInner>) -> Collection<TInner, <C as containers::Enter<T, TInner>>::InnerContainer>
     where
-        C: containers::Enter<G, T, InnerContainer: Container>,
-        T: Refines<G> + Timestamp,
+        C: containers::Enter<T, TInner, InnerContainer: Container>,
+        TInner: Refines<T> + Timestamp,
     {
         use timely::dataflow::channels::pact::Pipeline;
         self.inner
@@ -249,9 +249,9 @@ impl<G: Timestamp, C: Container> Collection<G, C> {
     ///     data.results_in(summary1);
     /// });
     /// ```
-    pub fn results_in(self, step: <G as Timestamp>::Summary) -> Self
+    pub fn results_in(self, step: <T as Timestamp>::Summary) -> Self
     where
-        C: containers::ResultsIn<<G as Timestamp>::Summary>,
+        C: containers::ResultsIn<<T as Timestamp>::Summary>,
     {
         use timely::dataflow::channels::pact::Pipeline;
         self.inner
@@ -343,18 +343,18 @@ pub mod vec {
     /// propagate changes through your functional computation and report the corresponding changes to the
     /// output collections.
     ///
-    /// Each vec collection has three generic parameters. The parameter `G` is for the scope in which the
+    /// Each vec collection has three generic parameters. The parameter `T` is for the scope in which the
     /// collection exists; as you write more complicated programs you may wish to introduce nested scopes
     /// (e.g. for iteration) and this parameter tracks the scope (for timely dataflow's benefit). The `D`
     /// parameter is the type of data in your collection, for example `String`, or `(u32, Vec<Option<()>>)`.
     /// The `R` parameter represents the types of changes that the data undergo, and is most commonly (and
     /// defaults to) `isize`, representing changes to the occurrence count of each record.
     ///
-    /// This type definition instantiates the [`Collection`] type with a `Vec<(D, G, R)>`.
-    pub type Collection<G, D, R = isize> = super::Collection<G, Vec<(D, G, R)>>;
+    /// This type definition instantiates the [`Collection`] type with a `Vec<(D, T, R)>`.
+    pub type Collection<T, D, R = isize> = super::Collection<T, Vec<(D, T, R)>>;
 
 
-    impl<G: Timestamp, D: Clone+'static, R: Clone+'static> Collection<G, D, R> {
+    impl<T: Timestamp, D: Clone+'static, R: Clone+'static> Collection<T, D, R> {
         /// Creates a new collection by applying the supplied function to each input element.
         ///
         /// # Examples
@@ -369,7 +369,7 @@ pub mod vec {
         ///          .assert_empty();
         /// });
         /// ```
-        pub fn map<D2, L>(self, mut logic: L) -> Collection<G, D2, R>
+        pub fn map<D2, L>(self, mut logic: L) -> Collection<T, D2, R>
         where
             D2: Clone+'static,
             L: FnMut(D) -> D2 + 'static,
@@ -396,7 +396,7 @@ pub mod vec {
         ///          .assert_empty();
         /// });
         /// ```
-        pub fn map_in_place<L>(self, mut logic: L) -> Collection<G, D, R>
+        pub fn map_in_place<L>(self, mut logic: L) -> Collection<T, D, R>
         where
             L: FnMut(&mut D) + 'static,
         {
@@ -420,9 +420,9 @@ pub mod vec {
         ///          .flat_map(|x| 0 .. x);
         /// });
         /// ```
-        pub fn flat_map<I, L>(self, mut logic: L) -> Collection<G, I::Item, R>
+        pub fn flat_map<I, L>(self, mut logic: L) -> Collection<T, I::Item, R>
         where
-            G: Clone,
+            T: Clone,
             I: IntoIterator<Item: Clone+'static>,
             L: FnMut(D) -> I + 'static,
         {
@@ -444,7 +444,7 @@ pub mod vec {
         ///          .assert_empty();
         /// });
         /// ```
-        pub fn filter<L>(self, mut logic: L) -> Collection<G, D, R>
+        pub fn filter<L>(self, mut logic: L) -> Collection<T, D, R>
         where
             L: FnMut(&D) -> bool + 'static,
         {
@@ -472,7 +472,7 @@ pub mod vec {
         ///     x1.assert_eq(x2);
         /// });
         /// ```
-        pub fn explode<D2, R2, I, L>(self, mut logic: L) -> Collection<G, D2, <R2 as Multiply<R>>::Output>
+        pub fn explode<D2, R2, I, L>(self, mut logic: L) -> Collection<T, D2, <R2 as Multiply<R>>::Output>
         where
             D2: Clone+'static,
             R2: Semigroup+Multiply<R, Output: Semigroup+'static>,
@@ -506,12 +506,12 @@ pub mod vec {
         ///           );
         /// });
         /// ```
-        pub fn join_function<D2, R2, I, L>(self, mut logic: L) -> Collection<G, D2, <R2 as Multiply<R>>::Output>
+        pub fn join_function<D2, R2, I, L>(self, mut logic: L) -> Collection<T, D2, <R2 as Multiply<R>>::Output>
         where
-            G: Lattice,
+            T: Lattice,
             D2: Clone+'static,
             R2: Semigroup+Multiply<R, Output: Semigroup+'static>,
-            I: IntoIterator<Item=(D2,G,R2)>,
+            I: IntoIterator<Item=(D2,T,R2)>,
             L: FnMut(D)->I+'static,
         {
             self.inner
@@ -543,11 +543,10 @@ pub mod vec {
         ///     data.assert_eq(result);
         /// });
         /// ```
-        pub fn enter_at<T, F>(self, child: &Iterative<G, T>, mut initial: F) -> Collection<Product<G, T>, D, R>
+        pub fn enter_at<TInner, F>(self, child: &Iterative<T, TInner>, mut initial: F) -> Collection<Product<T, TInner>, D, R>
         where
-            T: Timestamp+Hash,
-            F: FnMut(&D) -> T + Clone + 'static,
-            G: Hash,
+            TInner: Timestamp+Hash,
+            F: FnMut(&D) -> TInner + Clone + 'static,
         {
             self.inner
                 .enter(child)
@@ -565,10 +564,10 @@ pub mod vec {
         /// ordered, they should have the same order or compare equal once `func` is applied to them (this
         /// 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>
+        pub fn delay<F>(self, func: F) -> Collection<T, D, R>
         where
-            G: Hash,
-            F: FnMut(&G) -> G + Clone + 'static,
+            T: Hash,
+            F: FnMut(&T) -> T + Clone + 'static,
         {
             let mut func1 = func.clone();
             let mut func2 = func.clone();
@@ -602,9 +601,9 @@ pub mod vec {
         ///          .inspect(|x| println!("error: {:?}", x));
         /// });
         /// ```
-        pub fn inspect<F>(self, func: F) -> Collection<G, D, R>
+        pub fn inspect<F>(self, func: F) -> Collection<T, D, R>
         where
-            F: FnMut(&(D, G, R))+'static,
+            F: FnMut(&(D, T, R))+'static,
         {
             self.inner
                 .inspect(func)
@@ -628,9 +627,9 @@ pub mod vec {
         ///          .inspect_batch(|t,xs| println!("errors @ {:?}: {:?}", t, xs));
         /// });
         /// ```
-        pub fn inspect_batch<F>(self, mut func: F) -> Collection<G, D, R>
+        pub fn inspect_batch<F>(self, mut func: F) -> Collection<T, D, R>
         where
-            F: FnMut(&G, &[(D, G, R)])+'static,
+            F: FnMut(&T, &[(D, T, R)])+'static,
         {
             self.inner
                 .inspect_batch(move |time, data| func(time, data))
@@ -660,7 +659,7 @@ pub mod vec {
         where
             D: crate::ExchangeData+Hashable,
             R: crate::ExchangeData+Hashable + Semigroup,
-            G: Lattice+Ord,
+            T: Lattice+Ord,
         {
             self.consolidate()
                 .inspect(|x| panic!("Assertion failed: non-empty collection: {:?}", x));
@@ -668,7 +667,7 @@ pub mod vec {
     }
 
     /// Methods requiring an Abelian difference, to support negation.
-    impl<G: Timestamp + Clone + 'static, D: Clone+'static, R: Abelian+'static> Collection<G, D, R> {
+    impl<T: Timestamp + Clone + 'static, D: Clone+'static, R: Abelian+'static> Collection<T, 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
@@ -696,7 +695,7 @@ pub mod vec {
         where
             D: crate::ExchangeData+Hashable,
             R: crate::ExchangeData+Hashable,
-            G: Lattice+Ord,
+            T: Lattice+Ord,
         {
             self.negate()
                 .concat(other)
@@ -707,9 +706,9 @@ pub mod vec {
     use crate::trace::{Trace, Builder};
     use crate::operators::arrange::{Arranged, TraceAgent};
 
-    impl <G, K, V, R> Collection<G, (K, V), R>
+    impl <T, K, V, R> Collection<T, (K, V), R>
     where
-        G: Timestamp + Lattice + Ord,
+        T: Timestamp + Lattice + Ord,
         K: crate::ExchangeData+Hashable,
         V: crate::ExchangeData,
         R: crate::ExchangeData+Semigroup,
@@ -741,13 +740,13 @@ pub mod vec {
         ///          });
         /// });
         /// ```
-        pub fn reduce<L, V2: crate::Data, R2: Ord+Abelian+'static>(self, logic: L) -> Collection<G, (K, V2), R2>
+        pub fn reduce<L, V2: crate::Data, R2: Ord+Abelian+'static>(self, logic: L) -> Collection<T, (K, V2), R2>
         where L: FnMut(&K, &[(&V, R)], &mut Vec<(V2, R2)>)+'static {
             self.reduce_named("Reduce", logic)
         }
 
         /// As `reduce` with the ability to name the operator.
-        pub fn reduce_named<L, V2: crate::Data, R2: Ord+Abelian+'static>(self, name: &str, logic: L) -> Collection<G, (K, V2), R2>
+        pub fn reduce_named<L, V2: crate::Data, R2: Ord+Abelian+'static>(self, name: &str, logic: L) -> Collection<T, (K, V2), R2>
         where L: FnMut(&K, &[(&V, R)], &mut Vec<(V2, R2)>)+'static {
             use crate::trace::implementations::{ValBuilder, ValSpine};
 
@@ -786,7 +785,7 @@ pub mod vec {
         /// ```
         pub fn reduce_abelian<L, Bu, T2>(self, name: &str, mut logic: L) -> Arranged<TraceAgent<T2>>
         where
-            T2: for<'a> Trace<Key<'a>= &'a K, ValOwn = V, Time=G, Diff: Abelian>+'static,
+            T2: for<'a> Trace<Key<'a>= &'a K, ValOwn = V, Time=T, Diff: Abelian>+'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)>)+'static,
         {
@@ -805,7 +804,7 @@ pub mod vec {
         pub fn reduce_core<L, Bu, T2>(self, name: &str, logic: L) -> Arranged<TraceAgent<T2>>
         where
             V: Clone+'static,
-            T2: for<'a> Trace<Key<'a>=&'a K, ValOwn = V, Time=G>+'static,
+            T2: for<'a> Trace<Key<'a>=&'a K, ValOwn = V, Time=T>+'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,
         {
@@ -818,9 +817,9 @@ pub mod vec {
         }
     }
 
-    impl<G, K, R1> Collection<G, K, R1>
+    impl<T, K, R1> Collection<T, K, R1>
     where
-        G: Timestamp + Lattice + Ord,
+        T: Timestamp + Lattice + Ord,
         K: crate::ExchangeData+Hashable,
         R1: crate::ExchangeData+Semigroup
     {
@@ -839,7 +838,7 @@ pub mod vec {
         ///          .distinct();
         /// });
         /// ```
-        pub fn distinct(self) -> Collection<G, K, isize> {
+        pub fn distinct(self) -> Collection<T, K, isize> {
             self.distinct_core()
         }
 
@@ -848,7 +847,7 @@ pub mod vec {
         /// This method allows `distinct` to produce collections whose difference
         /// type is something other than an `isize` integer, for example perhaps an
         /// `i32`.
-        pub fn distinct_core<R2: Ord+Abelian+'static+From<i8>>(self) -> Collection<G, K, R2> {
+        pub fn distinct_core<R2: Ord+Abelian+'static+From<i8>>(self) -> Collection<T, K, R2> {
             self.threshold_named("Distinct", |_,_| R2::from(1i8))
         }
 
@@ -870,16 +869,16 @@ pub mod vec {
         ///          .threshold(|_,c| c % 2);
         /// });
         /// ```
-        pub fn threshold<R2: Ord+Abelian+'static, F: FnMut(&K, &R1)->R2+'static>(self, thresh: F) -> Collection<G, K, R2> {
+        pub fn threshold<R2: Ord+Abelian+'static, F: FnMut(&K, &R1)->R2+'static>(self, thresh: F) -> Collection<T, K, R2> {
             self.threshold_named("Threshold", thresh)
         }
 
         /// A `threshold` with the ability to name the operator.
-        pub fn threshold_named<R2: Ord+Abelian+'static, F: FnMut(&K,&R1)->R2+'static>(self, name: &str, mut thresh: F) -> Collection<G, K, R2> {
+        pub fn threshold_named<R2: Ord+Abelian+'static, F: FnMut(&K,&R1)->R2+'static>(self, name: &str, mut thresh: F) -> Collection<T, K, R2> {
             use crate::trace::implementations::{KeyBuilder, KeySpine};
 
             self.arrange_by_self_named(&format!("Arrange: {}", name))
-                .reduce_abelian::<_,KeyBuilder<K,G,R2>,KeySpine<K,G,R2>,_>(
+                .reduce_abelian::<_,KeyBuilder<K,T,R2>,KeySpine<K,T,R2>,_>(
                     name,
                     move |k,s,t| t.push(((), thresh(k, &s[0].1))),
                     |vec, key, upds| { vec.clear(); vec.extend(upds.drain(..).map(|(v,t,r)| ((key.clone(), v),t,r))); },
@@ -889,9 +888,9 @@ pub mod vec {
 
     }
 
-    impl<G, K, R> Collection<G, K, R>
+    impl<T, K, R> Collection<T, K, R>
     where
-        G: Timestamp + Lattice + Ord,
+        T: Timestamp + Lattice + Ord,
         K: crate::ExchangeData+Hashable,
         R: crate::ExchangeData+Semigroup
     {
@@ -910,17 +909,17 @@ pub mod vec {
         ///          .count();
         /// });
         /// ```
-        pub fn count(self) -> Collection<G, (K, R), isize> { self.count_core() }
+        pub fn count(self) -> Collection<T, (K, R), isize> { self.count_core() }
 
         /// Count for general integer differences.
         ///
         /// This method allows `count` to produce collections whose difference
         /// type is something other than an `isize` integer, for example perhaps an
         /// `i32`.
-        pub fn count_core<R2: Ord + Abelian + From<i8> + 'static>(self) -> Collection<G, (K, R), R2> {
+        pub fn count_core<R2: Ord + Abelian + From<i8> + 'static>(self) -> Collection<T, (K, R), R2> {
             use crate::trace::implementations::{ValBuilder, ValSpine};
             self.arrange_by_self_named("Arrange: Count")
-                .reduce_abelian::<_,ValBuilder<K,R,G,R2>,ValSpine<K,R,G,R2>,_>(
+                .reduce_abelian::<_,ValBuilder<K,R,T,R2>,ValSpine<K,R,T,R2>,_>(
                     "Count",
                     |_k,s,t| t.push((s[0].1.clone(), R2::from(1i8))),
                     |vec, key, upds| { vec.clear(); vec.extend(upds.drain(..).map(|(v,t,r)| ((key.clone(), v),t,r))); },
@@ -930,9 +929,9 @@ pub mod vec {
     }
 
     /// Methods which require data be arrangeable.
-    impl<G, D, R> Collection<G, D, R>
+    impl<T, D, R> Collection<T, D, R>
     where
-        G: Timestamp + Clone + 'static + Lattice,
+        T: Timestamp + Clone + 'static + Lattice,
         D: crate::ExchangeData+Hashable,
         R: crate::ExchangeData+Semigroup,
     {
@@ -966,8 +965,8 @@ pub mod vec {
         /// and provide the function `reify` to produce owned keys and values..
         pub fn consolidate_named<Ba, Bu, Tr, F>(self, name: &str, reify: F) -> Self
         where
-            Ba: crate::trace::Batcher<Input=Vec<((D,()),G,R)>, Time=G> + 'static,
-            Tr: for<'a> crate::trace::Trace<Time=G,Diff=R>+'static,
+            Ba: crate::trace::Batcher<Input=Vec<((D,()),T,R)>, Time=T> + 'static,
+            Tr: for<'a> crate::trace::Trace<Time=T,Diff=R>+'static,
             Bu: crate::trace::Builder<Time=Tr::Time, Input=Ba::Output, Output=Tr::Batch>,
             F: Fn(Tr::Key<'_>, Tr::Val<'_>) -> D + 'static,
         {
@@ -1025,82 +1024,82 @@ pub mod vec {
     use crate::trace::implementations::{KeySpine, KeyBatcher, KeyBuilder};
     use crate::operators::arrange::Arrange;
 
-    impl<G, K, V, R> Arrange<G, Vec<((K, V), G, R)>> for Collection<G, (K, V), R>
+    impl<T, K, V, R> Arrange<T, Vec<((K, V), T, R)>> for Collection<T, (K, V), R>
     where
-        G: Timestamp + Lattice,
+        T: Timestamp + Lattice,
         K: crate::ExchangeData + Hashable,
         V: crate::ExchangeData,
         R: crate::ExchangeData + Semigroup,
     {
         fn arrange_named<Ba, Bu, Tr>(self, name: &str) -> Arranged<TraceAgent<Tr>>
         where
-            Ba: crate::trace::Batcher<Input=Vec<((K, V), G, R)>, Time=G> + 'static,
-            Bu: crate::trace::Builder<Time=G, Input=Ba::Output, Output = Tr::Batch>,
-            Tr: crate::trace::Trace<Time=G> + 'static,
+            Ba: crate::trace::Batcher<Input=Vec<((K, V), T, R)>, Time=T> + 'static,
+            Bu: crate::trace::Builder<Time=T, Input=Ba::Output, Output = Tr::Batch>,
+            Tr: crate::trace::Trace<Time=T> + 'static,
         {
-            let exchange = timely::dataflow::channels::pact::Exchange::new(move |update: &((K,V),G,R)| (update.0).0.hashed().into());
+            let exchange = timely::dataflow::channels::pact::Exchange::new(move |update: &((K,V),T,R)| (update.0).0.hashed().into());
             crate::operators::arrange::arrangement::arrange_core::<_, _, Ba, Bu, _>(self.inner, exchange, name)
         }
     }
 
-    impl<G, K: crate::ExchangeData+Hashable, R: crate::ExchangeData+Semigroup> Arrange<G, Vec<((K, ()), G, R)>> for Collection<G, K, R>
+    impl<T, K: crate::ExchangeData+Hashable, R: crate::ExchangeData+Semigroup> Arrange<T, Vec<((K, ()), T, R)>> for Collection<T, K, R>
     where
-        G: Timestamp + Lattice + Ord,
+        T: Timestamp + Lattice + Ord,
     {
         fn arrange_named<Ba, Bu, Tr>(self, name: &str) -> Arranged<TraceAgent<Tr>>
         where
-            Ba: crate::trace::Batcher<Input=Vec<((K,()),G,R)>, Time=G> + 'static,
-            Bu: crate::trace::Builder<Time=G, Input=Ba::Output, Output = Tr::Batch>,
-            Tr: crate::trace::Trace<Time=G> + 'static,
+            Ba: crate::trace::Batcher<Input=Vec<((K,()),T,R)>, Time=T> + 'static,
+            Bu: crate::trace::Builder<Time=T, Input=Ba::Output, Output = Tr::Batch>,
+            Tr: crate::trace::Trace<Time=T> + 'static,
         {
-            let exchange = timely::dataflow::channels::pact::Exchange::new(move |update: &((K,()),G,R)| (update.0).0.hashed().into());
+            let exchange = timely::dataflow::channels::pact::Exchange::new(move |update: &((K,()),T,R)| (update.0).0.hashed().into());
             crate::operators::arrange::arrangement::arrange_core::<_,_,Ba,Bu,_>(self.map(|k| (k, ())).inner, exchange, name)
         }
     }
 
 
-    impl<G, K: crate::ExchangeData+Hashable, V: crate::ExchangeData, R: crate::ExchangeData+Semigroup> Collection<G, (K,V), R>
+    impl<T, K: crate::ExchangeData+Hashable, V: crate::ExchangeData, R: crate::ExchangeData+Semigroup> Collection<T, (K,V), R>
     where
-        G: Timestamp + Lattice + Ord,
+        T: 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.
         /// This trace is current for all times completed by the output stream, which can be used to
         /// safely identify the stable times and values in the trace.
-        pub fn arrange_by_key(self) -> Arranged<TraceAgent<ValSpine<K, V, G, R>>> {
+        pub fn arrange_by_key(self) -> Arranged<TraceAgent<ValSpine<K, V, T, R>>> {
             self.arrange_by_key_named("ArrangeByKey")
         }
 
         /// As `arrange_by_key` but with the ability to name the arrangement.
-        pub fn arrange_by_key_named(self, name: &str) -> Arranged<TraceAgent<ValSpine<K, V, G, R>>> {
+        pub fn arrange_by_key_named(self, name: &str) -> Arranged<TraceAgent<ValSpine<K, V, T, R>>> {
             self.arrange_named::<ValBatcher<_,_,_,_>,ValBuilder<_,_,_,_>,_>(name)
         }
     }
 
-    impl<G, K: crate::ExchangeData+Hashable, R: crate::ExchangeData+Semigroup> Collection<G, K, R>
+    impl<T, K: crate::ExchangeData+Hashable, R: crate::ExchangeData+Semigroup> Collection<T, K, R>
     where
-        G: Timestamp + Lattice + Ord,
+        T: Timestamp + Lattice + Ord,
     {
         /// Arranges a collection of `Key` records by `Key`.
         ///
         /// This operator arranges a collection of records into a shared trace, whose contents it maintains.
         /// This trace is current for all times complete in the output stream, which can be used to safely
         /// identify the stable times and values in the trace.
-        pub fn arrange_by_self(self) -> Arranged<TraceAgent<KeySpine<K, G, R>>> {
+        pub fn arrange_by_self(self) -> Arranged<TraceAgent<KeySpine<K, T, R>>> {
             self.arrange_by_self_named("ArrangeBySelf")
         }
 
         /// As `arrange_by_self` but with the ability to name the arrangement.
-        pub fn arrange_by_self_named(self, name: &str) -> Arranged<TraceAgent<KeySpine<K, G, R>>> {
+        pub fn arrange_by_self_named(self, name: &str) -> Arranged<TraceAgent<KeySpine<K, T, R>>> {
             self.map(|k| (k, ()))
                 .arrange_named::<KeyBatcher<_,_,_>,KeyBuilder<_,_,_>,_>(name)
         }
     }
 
-    impl<G, K, V, R> Collection<G, (K, V), R>
+    impl<T, K, V, R> Collection<T, (K, V), R>
     where
-        G: Timestamp + Lattice + Ord,
+        T: Timestamp + Lattice + Ord,
         K: crate::ExchangeData+Hashable,
         V: crate::ExchangeData,
         R: crate::ExchangeData+Semigroup,
@@ -1124,7 +1123,7 @@ pub mod vec {
         ///      .assert_eq(z);
         /// });
         /// ```
-        pub fn join<V2, R2>(self, other: Collection<G, (K,V2), R2>) -> Collection<G, (K,(V,V2)), <R as Multiply<R2>>::Output>
+        pub fn join<V2, R2>(self, other: Collection<T, (K,V2), R2>) -> Collection<T, (K,(V,V2)), <R as Multiply<R2>>::Output>
         where
             K:  crate::ExchangeData,
             V2: crate::ExchangeData,
@@ -1151,7 +1150,7 @@ pub mod vec {
         ///      .assert_eq(z);
         /// });
         /// ```
-        pub fn join_map<V2: crate::ExchangeData, R2: crate::ExchangeData+Semigroup, D: crate::Data, L>(self, other: Collection<G, (K, V2), R2>, mut logic: L) -> Collection<G, D, <R as Multiply<R2>>::Output>
+        pub fn join_map<V2: crate::ExchangeData, R2: crate::ExchangeData+Semigroup, D: crate::Data, L>(self, other: Collection<T, (K, V2), R2>, mut logic: L) -> Collection<T, D, <R as Multiply<R2>>::Output>
         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();
@@ -1179,7 +1178,7 @@ pub mod vec {
         ///      .assert_eq(z);
         /// });
         /// ```
-        pub fn semijoin<R2: crate::ExchangeData+Semigroup>(self, other: Collection<G, K, R2>) -> Collection<G, (K, V), <R as Multiply<R2>>::Output>
+        pub fn semijoin<R2: crate::ExchangeData+Semigroup>(self, other: Collection<T, K, R2>) -> Collection<T, (K, V), <R as Multiply<R2>>::Output>
         where R: Multiply<R2, Output: Semigroup+'static> {
             let arranged1 = self.arrange_by_key();
             let arranged2 = other.arrange_by_self();
@@ -1211,7 +1210,7 @@ pub mod vec {
         ///      .assert_eq(z);
         /// });
         /// ```
-        pub fn antijoin<R2: crate::ExchangeData+Semigroup>(self, other: Collection<G, K, R2>) -> Collection<G, (K, V), R>
+        pub fn antijoin<R2: crate::ExchangeData+Semigroup>(self, other: Collection<T, K, R2>) -> Collection<T, (K, V), R>
         where R: Multiply<R2, Output=R>, R: Abelian+'static {
             self.clone().concat(self.semijoin(other).negate())
         }
@@ -1222,7 +1221,7 @@ pub mod vec {
         /// which produces something implementing `IntoIterator`, where the output collection will have an entry for
         /// every value returned by the iterator.
         ///
-        /// This trait is implemented for arrangements (`Arranged<G, T>`) rather than collections. The `Join` trait
+        /// This trait is implemented for arrangements (`Arranged<T, T>`) rather than collections. The `Join` trait
         /// contains the implementations for collections.
         ///
         /// # Examples
@@ -1244,9 +1243,9 @@ pub mod vec {
         ///      .assert_eq(z);
         /// });
         /// ```
-        pub fn join_core<Tr2,I,L> (self, stream2: Arranged<Tr2>, result: L) -> Collection<G,I::Item,<R as Multiply<Tr2::Diff>>::Output>
+        pub fn join_core<Tr2,I,L> (self, stream2: Arranged<Tr2>, result: L) -> Collection<T,I::Item,<R as Multiply<Tr2::Diff>>::Output>
         where
-            Tr2: for<'a> crate::trace::TraceReader<Key<'a>=&'a K, Time=G>+Clone+'static,
+            Tr2: for<'a> crate::trace::TraceReader<Key<'a>=&'a K, Time=T>+Clone+'static,
             R: Multiply<Tr2::Diff, Output: Semigroup+'static>,
             I: IntoIterator<Item: crate::Data>,
             L: FnMut(&K,&V,Tr2::Val<'_>)->I+'static,
@@ -1258,18 +1257,18 @@ pub mod vec {
 }
 
 /// Conversion to a differential dataflow Collection.
-pub trait AsCollection<G: Timestamp, C> {
+pub trait AsCollection<T: Timestamp, C> {
     /// Converts the type to a differential dataflow collection.
-    fn as_collection(self) -> Collection<G, C>;
+    fn as_collection(self) -> Collection<T, C>;
 }
 
-impl<G: Timestamp, C> AsCollection<G, C> for Stream<G, C> {
+impl<T: Timestamp, C> AsCollection<T, C> for Stream<T, C> {
     /// Converts the type to a differential dataflow collection.
     ///
     /// By calling this method, you guarantee that the timestamp invariant (as documented on
     /// [Collection]) is upheld. This method will not check it.
-    fn as_collection(self) -> Collection<G, C> {
-        Collection::<G,C>::new(self)
+    fn as_collection(self) -> Collection<T, C> {
+        Collection::<T,C>::new(self)
     }
 }
 
@@ -1294,11 +1293,11 @@ impl<G: Timestamp, C> AsCollection<G, C> for Stream<G, C> {
 ///         .assert_eq(data);
 /// });
 /// ```
-pub fn concatenate<G, C, I>(scope: &mut Scope<G>, iterator: I) -> Collection<G, C>
+pub fn concatenate<T, C, I>(scope: &mut Scope<T>, iterator: I) -> Collection<T, C>
 where
-    G: Timestamp,
+    T: Timestamp,
     C: Container,
-    I: IntoIterator<Item=Collection<G, C>>,
+    I: IntoIterator<Item=Collection<T, C>>,
 {
     scope
         .concatenate(iterator.into_iter().map(|x| x.inner))
diff --git a/differential-dataflow/src/operators/arrange/upsert.rs b/differential-dataflow/src/operators/arrange/upsert.rs
index 1962c1fa1..16463022e 100644
--- a/differential-dataflow/src/operators/arrange/upsert.rs
+++ b/differential-dataflow/src/operators/arrange/upsert.rs
@@ -129,22 +129,22 @@ use super::TraceAgent;
 /// This method is only implemented for totally ordered times, as we do not yet
 /// understand what a "sequence" of upserts would mean for partially ordered
 /// timestamps.
-pub fn arrange_from_upsert<G, Bu, Tr, K, V>(
-    stream: Stream<G, Vec<(K, Option<V>, G)>>,
+pub fn arrange_from_upsert<T, Bu, Tr, K, V>(
+    stream: Stream<T, Vec<(K, Option<V>, T)>>,
     name: &str,
 ) -> Arranged<TraceAgent<Tr>>
 where
-    G: Timestamp,
+    T: Timestamp,
     K: ExchangeData+Hashable+std::hash::Hash,
     V: ExchangeData,
     Tr: for<'a> Trace<
         Key<'a> = &'a K,
         Val<'a> = &'a V,
-        Time = G,
+        Time = T,
         Diff=isize,
     >+'static,
-    G: TotalOrder+ExchangeData,
-    Bu: Builder<Time=G, Input = Vec<((K, V), Tr::Time, Tr::Diff)>, Output = Tr::Batch>,
+    T: TotalOrder+ExchangeData,
+    Bu: Builder<Time=T, Input = Vec<((K, V), Tr::Time, Tr::Diff)>, Output = Tr::Batch>,
 {
     let mut reader: Option<TraceAgent<Tr>> = None;
 
@@ -153,7 +153,7 @@ where
 
         let reader = &mut reader;
 
-        let exchange = Exchange::new(move |update: &(K,Option<V>,G)| (update.0).hashed().into());
+        let exchange = Exchange::new(move |update: &(K,Option<V>,T)| (update.0).hashed().into());
 
         let scope = stream.scope();
         stream.unary_frontier(exchange, name, move |_capability, info| {
@@ -162,7 +162,7 @@ where
             let logger = scope.logger_for::<crate::logging::DifferentialEventBuilder>("differential/arrange").map(Into::into);
 
             // Tracks the lower envelope of times in `priority_queue`.
-            let mut capabilities = Antichain::<Capability<G>>::new();
+            let mut capabilities = Antichain::<Capability<T>>::new();
             // Form the trace we will both use internally and publish.
             let activator = Some(scope.activator_for(info.address.clone()));
             let mut empty_trace = Tr::new(info.clone(), logger.clone(), activator);
@@ -176,10 +176,10 @@ where
             *reader = Some(reader_local.clone());
 
             // Tracks the input frontier, used to populate the lower bound of new batches.
-            let mut prev_frontier = Antichain::from_elem(<G as Timestamp>::minimum());
+            let mut prev_frontier = Antichain::from_elem(<T as Timestamp>::minimum());
 
             // For stashing input upserts, ordered increasing by time (`BinaryHeap` is a max-heap).
-            let mut priority_queue = BinaryHeap::<std::cmp::Reverse<(G, K, Option<V>)>>::new();
+            let mut priority_queue = BinaryHeap::<std::cmp::Reverse<(T, K, Option<V>)>>::new();
             let mut updates = Vec::new();
 
             move |(input, frontier), output| {
@@ -282,7 +282,7 @@ where
                                     updates.sort();
                                     builder.push(&mut updates);
                                 }
-                                let description = Description::new(prev_frontier.clone(), upper.clone(), Antichain::from_elem(G::minimum()));
+                                let description = Description::new(prev_frontier.clone(), upper.clone(), Antichain::from_elem(T::minimum()));
                                 let batch = builder.done(description);
                                 prev_frontier.clone_from(&upper);
 
diff --git a/differential-dataflow/src/operators/count.rs b/differential-dataflow/src/operators/count.rs
index 2f92ad1ef..95b2f8825 100644
--- a/differential-dataflow/src/operators/count.rs
+++ b/differential-dataflow/src/operators/count.rs
@@ -14,7 +14,7 @@ use crate::operators::arrange::Arranged;
 use crate::trace::{BatchReader, Cursor, TraceReader};
 
 /// Extension trait for the `count` differential dataflow method.
-pub trait CountTotal<G: Timestamp + TotalOrder + Lattice + Ord, K: ExchangeData, R: Semigroup> : Sized {
+pub trait CountTotal<T: Timestamp + TotalOrder + Lattice + Ord, K: ExchangeData, R: Semigroup> : Sized {
     /// Counts the number of occurrences of each element.
     ///
     /// # Examples
@@ -30,7 +30,7 @@ pub trait CountTotal<G: Timestamp + TotalOrder + Lattice + Ord, K: ExchangeData,
     ///          .count_total();
     /// });
     /// ```
-    fn count_total(self) -> VecCollection<G, (K, R), isize> {
+    fn count_total(self) -> VecCollection<T, (K, R), isize> {
         self.count_total_core()
     }
 
@@ -39,39 +39,39 @@ pub trait CountTotal<G: Timestamp + TotalOrder + Lattice + Ord, K: ExchangeData,
     /// This method allows `count_total` to produce collections whose difference
     /// type is something other than an `isize` integer, for example perhaps an
     /// `i32`.
-    fn count_total_core<R2: Semigroup + From<i8> + 'static>(self) -> VecCollection<G, (K, R), R2>;
+    fn count_total_core<R2: Semigroup + From<i8> + 'static>(self) -> VecCollection<T, (K, R), R2>;
 }
 
-impl<G, K: ExchangeData+Hashable, R: ExchangeData+Semigroup> CountTotal<G, K, R> for VecCollection<G, K, R>
+impl<T, K: ExchangeData+Hashable, R: ExchangeData+Semigroup> CountTotal<T, K, R> for VecCollection<T, K, R>
 where
-    G: Timestamp + TotalOrder + Lattice + Ord,
+    T: Timestamp + TotalOrder + Lattice + Ord,
 {
-    fn count_total_core<R2: Semigroup + From<i8> + 'static>(self) -> VecCollection<G, (K, R), R2> {
+    fn count_total_core<R2: Semigroup + From<i8> + 'static>(self) -> VecCollection<T, (K, R), R2> {
         self.arrange_by_self_named("Arrange: CountTotal")
             .count_total_core()
     }
 }
 
-impl<G, K, Tr> CountTotal<G, K, Tr::Diff> for Arranged<Tr>
+impl<T, K, Tr> CountTotal<T, K, Tr::Diff> for Arranged<Tr>
 where
-    G: Timestamp + TotalOrder + Lattice + Ord,
+    T: Timestamp + TotalOrder + Lattice + Ord,
     Tr: for<'a> TraceReader<
         Key<'a> = &'a K,
         Val<'a>=&'a (),
-        Time = G,
+        Time = T,
         Diff: ExchangeData+Semigroup<Tr::DiffGat<'a>>
     >+Clone+'static,
     K: ExchangeData,
 {
-    fn count_total_core<R2: Semigroup + From<i8> + 'static>(self) -> VecCollection<G, (K, Tr::Diff), R2> {
+    fn count_total_core<R2: Semigroup + From<i8> + 'static>(self) -> VecCollection<T, (K, Tr::Diff), R2> {
 
         let mut trace = self.trace.clone();
 
         self.stream.unary_frontier(Pipeline, "CountTotal", move |_,_| {
 
             // tracks the lower and upper limit of received batches.
-            let mut lower_limit = timely::progress::frontier::Antichain::from_elem(<G as timely::progress::Timestamp>::minimum());
-            let mut upper_limit = timely::progress::frontier::Antichain::from_elem(<G as timely::progress::Timestamp>::minimum());
+            let mut lower_limit = timely::progress::frontier::Antichain::from_elem(<T as timely::progress::Timestamp>::minimum());
+            let mut upper_limit = timely::progress::frontier::Antichain::from_elem(<T as timely::progress::Timestamp>::minimum());
 
             move |(input, _frontier), output| {
 
diff --git a/differential-dataflow/src/operators/iterate.rs b/differential-dataflow/src/operators/iterate.rs
index ec130448f..4efd8223f 100644
--- a/differential-dataflow/src/operators/iterate.rs
+++ b/differential-dataflow/src/operators/iterate.rs
@@ -46,7 +46,7 @@ use crate::difference::{Semigroup, Abelian};
 use crate::lattice::Lattice;
 
 /// An extension trait for the `iterate` method.
-pub trait Iterate<G: Timestamp + Lattice, D: Data, R: Semigroup> {
+pub trait Iterate<T: Timestamp + Lattice, D: Data, R: Semigroup> {
     /// Iteratively apply `logic` to the source collection until convergence.
     ///
     /// Importantly, this method does not automatically consolidate results.
@@ -73,15 +73,15 @@ pub trait Iterate<G: Timestamp + Lattice, D: Data, R: Semigroup> {
     ///          });
     /// });
     /// ```
-    fn iterate<F>(self, logic: F) -> VecCollection<G, D, R>
+    fn iterate<F>(self, logic: F) -> VecCollection<T, D, R>
     where
-        for<'a> F: FnOnce(Iterative<G, u64>, VecCollection<Product<G, u64>, D, R>)->VecCollection<Product<G, u64>, D, R>;
+        for<'a> F: FnOnce(Iterative<T, u64>, VecCollection<Product<T, u64>, D, R>)->VecCollection<Product<T, u64>, D, R>;
 }
 
-impl<G: Timestamp + Lattice, D: Ord+Data+Debug, R: Abelian+'static> Iterate<G, D, R> for VecCollection<G, D, R> {
-    fn iterate<F>(self, logic: F) -> VecCollection<G, D, R>
+impl<T: Timestamp + Lattice, D: Ord+Data+Debug, R: Abelian+'static> Iterate<T, D, R> for VecCollection<T, D, R> {
+    fn iterate<F>(self, logic: F) -> VecCollection<T, D, R>
     where
-        for<'a> F: FnOnce(Iterative<G, u64>, VecCollection<Product<G, u64>, D, R>)->VecCollection<Product<G, u64>, D, R>,
+        for<'a> F: FnOnce(Iterative<T, u64>, VecCollection<Product<T, u64>, D, R>)->VecCollection<Product<T, u64>, D, R>,
     {
         let outer = self.inner.scope();
         outer.scoped("Iterate", |subgraph| {
@@ -99,10 +99,10 @@ impl<G: Timestamp + Lattice, D: Ord+Data+Debug, R: Abelian+'static> Iterate<G, D
     }
 }
 
-impl<G: Timestamp + Lattice, D: Ord+Data+Debug, R: Semigroup+'static> Iterate<G, D, R> for Scope<G> {
-    fn iterate<F>(self, logic: F) -> VecCollection<G, D, R>
+impl<T: Timestamp + Lattice, D: Ord+Data+Debug, R: Semigroup+'static> Iterate<T, D, R> for Scope<T> {
+    fn iterate<F>(self, logic: F) -> VecCollection<T, D, R>
     where
-        for<'a> F: FnOnce(Iterative<G, u64>, VecCollection<Product<G, u64>, D, R>)->VecCollection<Product<G, u64>, D, R>,
+        for<'a> F: FnOnce(Iterative<T, u64>, VecCollection<Product<T, u64>, D, R>)->VecCollection<Product<T, u64>, D, R>,
     {
         let outer = self.clone();
         self.scoped("Iterate", |subgraph| {
@@ -190,23 +190,23 @@ impl<G: Timestamp + Lattice, D: Ord+Data+Debug, R: Semigroup+'static> Iterate<G,
 /// By iteratively developing a variable of the *edits* to the input, we can produce and circulate
 /// a smaller volume of updates. This can be especially impactful when the initial collection is
 /// large, and the edits to perform are relatively smaller.
-pub struct Variable<G, C>
+pub struct Variable<T, C>
 where
-    G: Timestamp + Lattice,
+    T: Timestamp + Lattice,
     C: Container,
 {
-    feedback: Handle<G, C>,
-    source: Option<Collection<G, C>>,
-    step: <G as Timestamp>::Summary,
+    feedback: Handle<T, C>,
+    source: Option<Collection<T, C>>,
+    step: <T as Timestamp>::Summary,
 }
 
 /// A `Variable` specialized to a vector container of update triples (data, time, diff).
-pub type VecVariable<G, D, R> = Variable<G, Vec<(D, G, R)>>;
+pub type VecVariable<T, D, R> = Variable<T, Vec<(D, T, R)>>;
 
-impl<G, C: Container> Variable<G, C>
+impl<T, C: Container> Variable<T, C>
 where
-    G: Timestamp + Lattice,
-    C: crate::collection::containers::ResultsIn<<G as Timestamp>::Summary>,
+    T: Timestamp + Lattice,
+    C: crate::collection::containers::ResultsIn<<T as Timestamp>::Summary>,
 {
     /// Creates a new initially empty `Variable` and its associated `Collection`.
     ///
@@ -219,9 +219,9 @@ where
     /// will produce its fixed point in the outer scope.
     ///
     /// In a non-iterative scope the mechanics are the same, but the interpretation varies.
-    pub fn new(scope: &mut Scope<G>, step: <G as Timestamp>::Summary) -> (Self, Collection<G, C>) {
+    pub fn new(scope: &mut Scope<T>, step: <T as Timestamp>::Summary) -> (Self, Collection<T, C>) {
         let (feedback, updates) = scope.feedback(step.clone());
-        let collection = Collection::<G, C>::new(updates);
+        let collection = Collection::<T, C>::new(updates);
         (Self { feedback, source: None, step }, collection)
     }
 
@@ -250,9 +250,9 @@ where
     /// adding the source, doing the logic, then subtracting the source, it is appropriate to do.
     /// For example, if the logic modifies a few records it is possible to produce this update
     /// directly without using the backstop implementation this method provides.
-    pub fn new_from(source: Collection<G, C>, step: <G as Timestamp>::Summary) -> (Self, Collection<G, C>) where C: Clone + crate::collection::containers::Negate {
+    pub fn new_from(source: Collection<T, C>, step: <T as Timestamp>::Summary) -> (Self, Collection<T, C>) where C: Clone + crate::collection::containers::Negate {
         let (feedback, updates) = source.inner.scope().feedback(step.clone());
-        let collection = Collection::<G, C>::new(updates).concat(source.clone());
+        let collection = Collection::<T, C>::new(updates).concat(source.clone());
         (Variable { feedback, source: Some(source.negate()), step }, collection)
     }
 
@@ -260,7 +260,7 @@ where
     ///
     /// This method binds the `Variable` to be equal to the supplied collection,
     /// which may be recursively defined in terms of the variable itself.
-    pub fn set(mut self, mut result: Collection<G, C>) {
+    pub fn set(mut self, mut result: Collection<T, C>) {
         if let Some(source) = self.source.take() {
             result = result.concat(source);
         }
diff --git a/differential-dataflow/src/operators/threshold.rs b/differential-dataflow/src/operators/threshold.rs
index 3ffba3e86..f5c3d0037 100644
--- a/differential-dataflow/src/operators/threshold.rs
+++ b/differential-dataflow/src/operators/threshold.rs
@@ -17,9 +17,9 @@ use crate::operators::arrange::Arranged;
 use crate::trace::{BatchReader, Cursor, TraceReader};
 
 /// Extension trait for the `distinct` differential dataflow method.
-pub trait ThresholdTotal<G: Timestamp + TotalOrder + Lattice + Ord, K: ExchangeData, R: ExchangeData+Semigroup> : Sized {
+pub trait ThresholdTotal<T: Timestamp + TotalOrder + Lattice + Ord, K: ExchangeData, R: ExchangeData+Semigroup> : Sized {
     /// Reduces the collection to one occurrence of each distinct element.
-    fn threshold_semigroup<R2, F>(self, thresh: F) -> VecCollection<G, K, R2>
+    fn threshold_semigroup<R2, F>(self, thresh: F) -> VecCollection<T, K, R2>
     where
         R2: Semigroup+'static,
         F: FnMut(&K,&R,Option<&R>)->Option<R2>+'static,
@@ -39,7 +39,7 @@ pub trait ThresholdTotal<G: Timestamp + TotalOrder + Lattice + Ord, K: ExchangeD
     ///          .threshold_total(|_,c| c % 2);
     /// });
     /// ```
-    fn threshold_total<R2: Abelian+'static, F: FnMut(&K,&R)->R2+'static>(self, mut thresh: F) -> VecCollection<G, K, R2> {
+    fn threshold_total<R2: Abelian+'static, F: FnMut(&K,&R)->R2+'static>(self, mut thresh: F) -> VecCollection<T, K, R2> {
         self.threshold_semigroup(move |key, new, old| {
             let mut new = thresh(key, new);
             if let Some(old) = old {
@@ -69,7 +69,7 @@ pub trait ThresholdTotal<G: Timestamp + TotalOrder + Lattice + Ord, K: ExchangeD
     ///          .distinct_total();
     /// });
     /// ```
-    fn distinct_total(self) -> VecCollection<G, K, isize> {
+    fn distinct_total(self) -> VecCollection<T, K, isize> {
         self.distinct_total_core()
     }
 
@@ -78,17 +78,17 @@ pub trait ThresholdTotal<G: Timestamp + TotalOrder + Lattice + Ord, K: ExchangeD
     /// This method allows `distinct` to produce collections whose difference
     /// type is something other than an `isize` integer, for example perhaps an
     /// `i32`.
-    fn distinct_total_core<R2: Abelian+From<i8>+'static>(self) -> VecCollection<G, K, R2> {
+    fn distinct_total_core<R2: Abelian+From<i8>+'static>(self) -> VecCollection<T, K, R2> {
         self.threshold_total(|_,_| R2::from(1i8))
     }
 
 }
 
-impl<G, K: ExchangeData+Hashable, R: ExchangeData+Semigroup> ThresholdTotal<G, K, R> for VecCollection<G, K, R>
+impl<T, K: ExchangeData+Hashable, R: ExchangeData+Semigroup> ThresholdTotal<T, K, R> for VecCollection<T, K, R>
 where
-    G: Timestamp + TotalOrder + Lattice + Ord,
+    T: Timestamp + TotalOrder + Lattice + Ord,
 {
-    fn threshold_semigroup<R2, F>(self, thresh: F) -> VecCollection<G, K, R2>
+    fn threshold_semigroup<R2, F>(self, thresh: F) -> VecCollection<T, K, R2>
     where
         R2: Semigroup+'static,
         F: FnMut(&K,&R,Option<&R>)->Option<R2>+'static,
@@ -98,18 +98,18 @@ where
     }
 }
 
-impl<G, K, Tr> ThresholdTotal<G, K, Tr::Diff> for Arranged<Tr>
+impl<T, K, Tr> ThresholdTotal<T, K, Tr::Diff> for Arranged<Tr>
 where
-    G: Timestamp + TotalOrder + Lattice + Ord,
+    T: Timestamp + TotalOrder + Lattice + Ord,
     Tr: for<'a> TraceReader<
         Key<'a>=&'a K,
         Val<'a>=&'a (),
-        Time = G,
+        Time = T,
         Diff : ExchangeData + Semigroup<Tr::DiffGat<'a>>,
     >+Clone+'static,
     K: ExchangeData,
 {
-    fn threshold_semigroup<R2, F>(self, mut thresh: F) -> VecCollection<G, K, R2>
+    fn threshold_semigroup<R2, F>(self, mut thresh: F) -> VecCollection<T, K, R2>
     where
         R2: Semigroup+'static,
         F: for<'a> FnMut(Tr::Key<'a>,&Tr::Diff,Option<&Tr::Diff>)->Option<R2>+'static,
@@ -120,8 +120,8 @@ where
         self.stream.unary_frontier(Pipeline, "ThresholdTotal", move |_,_| {
 
             // tracks the lower and upper limit of received batches.
-            let mut lower_limit = timely::progress::frontier::Antichain::from_elem(<G as timely::progress::Timestamp>::minimum());
-            let mut upper_limit = timely::progress::frontier::Antichain::from_elem(<G as timely::progress::Timestamp>::minimum());
+            let mut lower_limit = timely::progress::frontier::Antichain::from_elem(<T as timely::progress::Timestamp>::minimum());
+            let mut upper_limit = timely::progress::frontier::Antichain::from_elem(<T as timely::progress::Timestamp>::minimum());
 
             move |(input, _frontier), output| {
 
diff --git a/differential-dataflow/tests/bfs.rs b/differential-dataflow/tests/bfs.rs
index a887d95c5..d3a3bccb8 100644
--- a/differential-dataflow/tests/bfs.rs
+++ b/differential-dataflow/tests/bfs.rs
@@ -201,9 +201,9 @@ fn bfs_differential(
 }
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn bfs<G>(edges: VecCollection<G, Edge>, roots: VecCollection<G, Node>) -> VecCollection<G, (Node, usize)>
+fn bfs<T>(edges: VecCollection<T, Edge>, roots: VecCollection<T, Node>) -> VecCollection<T, (Node, usize)>
 where
-    G: timely::progress::Timestamp + Lattice + Ord,
+    T: timely::progress::Timestamp + Lattice + Ord,
 {
     // initialize roots as reaching themselves at distance 0
     let nodes = roots.map(|x| (x, 0));
diff --git a/differential-dataflow/tests/scc.rs b/differential-dataflow/tests/scc.rs
index 1d12585ce..2e48b41f3 100644
--- a/differential-dataflow/tests/scc.rs
+++ b/differential-dataflow/tests/scc.rs
@@ -214,9 +214,9 @@ fn scc_differential(
         .collect()
 }
 
-fn _strongly_connected<G>(graph: VecCollection<G, Edge>) -> VecCollection<G, Edge>
+fn _strongly_connected<T>(graph: VecCollection<T, Edge>) -> VecCollection<T, Edge>
 where
-    G: timely::progress::Timestamp + Lattice + Ord + Hash,
+    T: timely::progress::Timestamp + Lattice + Ord + Hash,
 {
     graph.clone().iterate(|scope, inner| {
         let edges = graph.enter(&scope);
@@ -225,9 +225,9 @@ where
     })
 }
 
-fn _trim_edges<G>(cycle: VecCollection<G, Edge>, edges: VecCollection<G, Edge>) -> VecCollection<G, Edge>
+fn _trim_edges<T>(cycle: VecCollection<T, Edge>, edges: VecCollection<T, Edge>) -> VecCollection<T, Edge>
 where
-    G: timely::progress::Timestamp + Lattice + Ord + Hash,
+    T: timely::progress::Timestamp + Lattice + Ord + Hash,
 {
     let nodes = edges.clone()
                      .map_in_place(|x| x.0 = x.1)
@@ -243,9 +243,9 @@ where
          .map(|((x1,x2),_)| (x2,x1))
 }
 
-fn _reachability<G>(edges: VecCollection<G, Edge>, nodes: VecCollection<G, (Node, Node)>) -> VecCollection<G, Edge>
+fn _reachability<T>(edges: VecCollection<T, Edge>, nodes: VecCollection<T, (Node, Node)>) -> VecCollection<T, Edge>
 where
-    G: timely::progress::Timestamp + Lattice + Ord + Hash,
+    T: timely::progress::Timestamp + Lattice + Ord + Hash,
 {
     edges.clone()   // <-- wth is this.
          .filter(|_| false)
diff --git a/dogsdogsdogs/src/calculus.rs b/dogsdogsdogs/src/calculus.rs
index b24694b76..8109d1262 100644
--- a/dogsdogsdogs/src/calculus.rs
+++ b/dogsdogsdogs/src/calculus.rs
@@ -21,23 +21,23 @@ use differential_dataflow::difference::Abelian;
 use crate::altneu::AltNeu;
 
 /// Produce a collection containing the changes at the moments they happen.
-pub trait Differentiate<G: Timestamp, D: Data, R: Abelian> {
-    fn differentiate(self, child: &Scope<AltNeu<G>>) -> VecCollection<AltNeu<G>, D, R>;
+pub trait Differentiate<T: Timestamp, D: Data, R: Abelian> {
+    fn differentiate(self, child: &Scope<AltNeu<T>>) -> VecCollection<AltNeu<T>, D, R>;
 }
 
 /// Collect instantaneous changes back in to a collection.
-pub trait Integrate<G: Timestamp, D: Data, R: Abelian> {
-    fn integrate(self, outer: &Scope<G>) -> VecCollection<G, D, R>;
+pub trait Integrate<T: Timestamp, D: Data, R: Abelian> {
+    fn integrate(self, outer: &Scope<T>) -> VecCollection<T, D, R>;
 }
 
-impl<G, D, R> Differentiate<G, D, R> for VecCollection<G, D, R>
+impl<T, D, R> Differentiate<T, D, R> for VecCollection<T, D, R>
 where
-    G: Timestamp,
+    T: Timestamp,
     D: Data,
     R: Abelian + 'static,
 {
     // For each (data, Alt(time), diff) we add a (data, Neu(time), -diff).
-    fn differentiate(self, child: &Scope<AltNeu<G>>) -> VecCollection<AltNeu<G>, D, R> {
+    fn differentiate(self, child: &Scope<AltNeu<T>>) -> VecCollection<AltNeu<T>, D, R> {
         self.enter(child)
             .inner
             .flat_map(|(data, time, diff)| {
@@ -51,14 +51,14 @@ where
     }
 }
 
-impl<G, D, R> Integrate<G, D, R> for VecCollection<AltNeu<G>, D, R>
+impl<T, D, R> Integrate<T, D, R> for VecCollection<AltNeu<T>, D, R>
 where
-    G: Timestamp,
+    T: Timestamp,
     D: Data,
     R: Abelian + 'static,
 {
     // We discard each `neu` variant and strip off the `alt` wrapper.
-    fn integrate(self, outer: &Scope<G>) -> VecCollection<G, D, R> {
+    fn integrate(self, outer: &Scope<T>) -> VecCollection<T, D, R> {
         self.inner
             .filter(|(_d,t,_r)| !t.neu)
             .as_collection()
diff --git a/dogsdogsdogs/src/lib.rs b/dogsdogsdogs/src/lib.rs
index 8550bcf79..e2699ee0d 100644
--- a/dogsdogsdogs/src/lib.rs
+++ b/dogsdogsdogs/src/lib.rs
@@ -19,37 +19,37 @@ pub mod operators;
     Implementors of `PrefixExtension` provide types and methods for extending a differential dataflow collection,
     via the three methods `count`, `propose`, and `validate`.
 **/
-pub trait PrefixExtender<G: Timestamp, R: Monoid+Multiply<Output = R>> {
+pub trait PrefixExtender<T: Timestamp, R: Monoid+Multiply<Output = R>> {
     /// The required type of prefix to extend.
     type Prefix;
     /// The type to be produced as extension.
     type Extension;
     /// Annotates prefixes with the number of extensions the relation would propose.
-    fn count(&mut self, prefixes: VecCollection<G, (Self::Prefix, usize, usize), R>, index: usize) -> VecCollection<G, (Self::Prefix, usize, usize), R>;
+    fn count(&mut self, prefixes: VecCollection<T, (Self::Prefix, usize, usize), R>, index: usize) -> VecCollection<T, (Self::Prefix, usize, usize), R>;
     /// Extends each prefix with corresponding extensions.
-    fn propose(&mut self, prefixes: VecCollection<G, Self::Prefix, R>) -> VecCollection<G, (Self::Prefix, Self::Extension), R>;
+    fn propose(&mut self, prefixes: VecCollection<T, Self::Prefix, R>) -> VecCollection<T, (Self::Prefix, Self::Extension), R>;
     /// Restricts proposed extensions by those the extender would have proposed.
-    fn validate(&mut self, extensions: VecCollection<G, (Self::Prefix, Self::Extension), R>) -> VecCollection<G, (Self::Prefix, Self::Extension), R>;
+    fn validate(&mut self, extensions: VecCollection<T, (Self::Prefix, Self::Extension), R>) -> VecCollection<T, (Self::Prefix, Self::Extension), R>;
 }
 
-pub trait ProposeExtensionMethod<G: Timestamp, P: ExchangeData+Ord, R: Monoid+Multiply<Output = R>> {
-    fn propose_using<PE: PrefixExtender<G, R, Prefix=P>>(self, extender: &mut PE) -> VecCollection<G, (P, PE::Extension), R>;
-    fn extend<E: ExchangeData+Ord>(self, extenders: &mut [&mut dyn PrefixExtender<G,R,Prefix=P,Extension=E>]) -> VecCollection<G, (P, E), R>;
+pub trait ProposeExtensionMethod<T: Timestamp, P: ExchangeData+Ord, R: Monoid+Multiply<Output = R>> {
+    fn propose_using<PE: PrefixExtender<T, R, Prefix=P>>(self, extender: &mut PE) -> VecCollection<T, (P, PE::Extension), R>;
+    fn extend<E: ExchangeData+Ord>(self, extenders: &mut [&mut dyn PrefixExtender<T,R,Prefix=P,Extension=E>]) -> VecCollection<T, (P, E), R>;
 }
 
-impl<G, P, R> ProposeExtensionMethod<G, P, R> for VecCollection<G, P, R>
+impl<T, P, R> ProposeExtensionMethod<T, P, R> for VecCollection<T, P, R>
 where
-    G: Timestamp,
+    T: Timestamp,
     P: ExchangeData+Ord,
     R: Monoid+Multiply<Output = R>+'static,
 {
-    fn propose_using<PE>(self, extender: &mut PE) -> VecCollection<G, (P, PE::Extension), R>
+    fn propose_using<PE>(self, extender: &mut PE) -> VecCollection<T, (P, PE::Extension), R>
     where
-        PE: PrefixExtender<G, R, Prefix=P>
+        PE: PrefixExtender<T, R, Prefix=P>
     {
         extender.propose(self)
     }
-    fn extend<E>(self, extenders: &mut [&mut dyn PrefixExtender<G,R,Prefix=P,Extension=E>]) -> VecCollection<G, (P, E), R>
+    fn extend<E>(self, extenders: &mut [&mut dyn PrefixExtender<T,R,Prefix=P,Extension=E>]) -> VecCollection<T, (P, E), R>
     where
         E: ExchangeData+Ord
     {
@@ -80,12 +80,12 @@ where
     }
 }
 
-pub trait ValidateExtensionMethod<G: Timestamp, R: Monoid+Multiply<Output = R>, P, E> {
-    fn validate_using<PE: PrefixExtender<G, R, Prefix=P, Extension=E>>(self, extender: &mut PE) -> VecCollection<G, (P, E), R>;
+pub trait ValidateExtensionMethod<T: Timestamp, R: Monoid+Multiply<Output = R>, P, E> {
+    fn validate_using<PE: PrefixExtender<T, R, Prefix=P, Extension=E>>(self, extender: &mut PE) -> VecCollection<T, (P, E), R>;
 }
 
-impl<G: Timestamp, R: Monoid+Multiply<Output = R>, P, E> ValidateExtensionMethod<G, R, P, E> for VecCollection<G, (P, E), R> {
-    fn validate_using<PE: PrefixExtender<G, R, Prefix=P, Extension=E>>(self, extender: &mut PE) -> VecCollection<G, (P, E), R> {
+impl<T: Timestamp, R: Monoid+Multiply<Output = R>, P, E> ValidateExtensionMethod<T, R, P, E> for VecCollection<T, (P, E), R> {
+    fn validate_using<PE: PrefixExtender<T, R, Prefix=P, Extension=E>>(self, extender: &mut PE) -> VecCollection<T, (P, E), R> {
         extender.validate(self)
     }
 }
@@ -179,9 +179,9 @@ where
     key_selector: F,
 }
 
-impl<G, K, V, R, P, F> PrefixExtender<G, R> for CollectionExtender<K, V, G, R, P, F>
+impl<T, K, V, R, P, F> PrefixExtender<T, R> for CollectionExtender<K, V, T, R, P, F>
 where
-    G: Timestamp + Lattice + ExchangeData + Hash,
+    T: Timestamp + Lattice + ExchangeData + Hash,
     K: ExchangeData+Hash+Default,
     V: ExchangeData+Hash+Default,
     P: ExchangeData,
@@ -191,17 +191,17 @@ where
     type Prefix = P;
     type Extension = V;
 
-    fn count(&mut self, prefixes: VecCollection<G, (P, usize, usize), R>, index: usize) -> VecCollection<G, (P, usize, usize), R> {
+    fn count(&mut self, prefixes: VecCollection<T, (P, usize, usize), R>, index: usize) -> VecCollection<T, (P, usize, usize), R> {
         let counts = self.indices.count_trace.import(&prefixes.scope());
         operators::count::count(prefixes, counts, self.key_selector.clone(), index)
     }
 
-    fn propose(&mut self, prefixes: VecCollection<G, P, R>) -> VecCollection<G, (P, V), R> {
+    fn propose(&mut self, prefixes: VecCollection<T, P, R>) -> VecCollection<T, (P, V), R> {
         let propose = self.indices.propose_trace.import(&prefixes.scope());
         operators::propose::propose(prefixes, propose, self.key_selector.clone())
     }
 
-    fn validate(&mut self, extensions: VecCollection<G, (P, V), R>) -> VecCollection<G, (P, V), R> {
+    fn validate(&mut self, extensions: VecCollection<T, (P, V), R>) -> VecCollection<T, (P, V), R> {
         let validate = self.indices.validate_trace.import(&extensions.scope());
         operators::validate::validate(extensions, validate, self.key_selector.clone())
     }
diff --git a/experiments/src/bin/graphs-interactive-alt.rs b/experiments/src/bin/graphs-interactive-alt.rs
index ee5b2d07a..0ba7ddd4b 100644
--- a/experiments/src/bin/graphs-interactive-alt.rs
+++ b/experiments/src/bin/graphs-interactive-alt.rs
@@ -258,13 +258,13 @@ use differential_dataflow::trace::implementations::ValSpine;
 use differential_dataflow::operators::arrange::TraceAgent;
 use differential_dataflow::operators::arrange::Arranged;
 
-type Arrange<G, K, V, R> = Arranged<TraceAgent<ValSpine<K, V, G, R>>>;
+type Arrange<T, K, V, R> = Arranged<TraceAgent<ValSpine<K, V, T, R>>>;
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn three_hop<G: Timestamp + Lattice + Ord>(
-    forward_graph: Arrange<G, Node, Node, isize>,
-    reverse_graph: Arrange<G, Node, Node, isize>,
-    goals: VecCollection<G, (Node, Node)>) -> VecCollection<G, ((Node, Node), u32)>
+fn three_hop<T: Timestamp + Lattice + Ord>(
+    forward_graph: Arrange<T, Node, Node, isize>,
+    reverse_graph: Arrange<T, Node, Node, isize>,
+    goals: VecCollection<T, (Node, Node)>) -> VecCollection<T, ((Node, Node), u32)>
 {
 
     let sources = goals.clone().map(|(x,_)| x);
@@ -288,10 +288,10 @@ fn three_hop<G: Timestamp + Lattice + Ord>(
 }
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn _bidijkstra<G: Timestamp + Lattice + Ord>(
-    forward_graph: Arrange<G, Node, Node, isize>,
-    reverse_graph: Arrange<G, Node, Node, isize>,
-    goals: VecCollection<G, (Node, Node)>) -> VecCollection<G, ((Node, Node), u32)>
+fn _bidijkstra<T: Timestamp + Lattice + Ord>(
+    forward_graph: Arrange<T, Node, Node, isize>,
+    reverse_graph: Arrange<T, Node, Node, isize>,
+    goals: VecCollection<T, (Node, Node)>) -> VecCollection<T, ((Node, Node), u32)>
 {
 
     let outer = goals.scope();
@@ -362,8 +362,8 @@ fn _bidijkstra<G: Timestamp + Lattice + Ord>(
 }
 
 
-fn connected_components<G: Timestamp + Lattice + Ord>(graph: Arrange<G, Node, Node, isize>) -> VecCollection<G, (Node, Node)>
-where G: Lattice + std::hash::Hash
+fn connected_components<T: Timestamp + Lattice + Ord>(graph: Arrange<T, Node, Node, isize>) -> VecCollection<T, (Node, Node)>
+where T: Lattice + std::hash::Hash
 {
 
     // each edge (x,y) means that we need at least a label for the min of x and y.
diff --git a/experiments/src/bin/graphs-interactive-neu-zwei.rs b/experiments/src/bin/graphs-interactive-neu-zwei.rs
index 6e6d0ea4c..0a5ee0d25 100644
--- a/experiments/src/bin/graphs-interactive-neu-zwei.rs
+++ b/experiments/src/bin/graphs-interactive-neu-zwei.rs
@@ -226,13 +226,13 @@ use differential_dataflow::trace::implementations::ValSpine;
 use differential_dataflow::operators::arrange::TraceAgent;
 use differential_dataflow::operators::arrange::Arranged;
 
-type Arrange<G, K, V, R> = Arranged<TraceAgent<ValSpine<K, V, G, R>>>;
+type Arrange<T, K, V, R> = Arranged<TraceAgent<ValSpine<K, V, T, R>>>;
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn three_hop<G: Timestamp + Lattice + Ord>(
-    forward_graph: Arrange<G, Node, Node, isize>,
-    reverse_graph: Arrange<G, Node, Node, isize>,
-    goals: VecCollection<G, (Node, Node)>) -> VecCollection<G, ((Node, Node), u32)>
+fn three_hop<T: Timestamp + Lattice + Ord>(
+    forward_graph: Arrange<T, Node, Node, isize>,
+    reverse_graph: Arrange<T, Node, Node, isize>,
+    goals: VecCollection<T, (Node, Node)>) -> VecCollection<T, ((Node, Node), u32)>
 {
 
     let sources = goals.clone().map(|(x,_)| x);
@@ -256,12 +256,12 @@ fn three_hop<G: Timestamp + Lattice + Ord>(
 }
 
 // // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-// fn bidijkstra<G: Timestamp + Lattice + Ord>(
-//     forward_graph: &Arrange<G, Node, Node, isize>,
-//     reverse_graph: &Arrange<G, Node, Node, isize>,
-//     goals: VecCollection<G, (Node, Node)>,
-//     bound: u64) -> VecCollection<G, ((Node, Node), u32)>
-// where G: Lattice+Ord {
+// fn bidijkstra<T: Timestamp + Lattice + Ord>(
+//     forward_graph: &Arrange<T, Node, Node, isize>,
+//     reverse_graph: &Arrange<T, Node, Node, isize>,
+//     goals: VecCollection<T, (Node, Node)>,
+//     bound: u64) -> VecCollection<T, ((Node, Node), u32)>
+// where T: Lattice+Ord {
 
 //     goals.scope().scoped(|inner| {
 
diff --git a/experiments/src/bin/graphs-interactive-neu.rs b/experiments/src/bin/graphs-interactive-neu.rs
index 8d1cdfd7e..ceda7913c 100644
--- a/experiments/src/bin/graphs-interactive-neu.rs
+++ b/experiments/src/bin/graphs-interactive-neu.rs
@@ -291,13 +291,13 @@ use differential_dataflow::trace::implementations::ValSpine;
 use differential_dataflow::operators::arrange::TraceAgent;
 use differential_dataflow::operators::arrange::Arranged;
 
-type Arrange<G, K, V, R> = Arranged<TraceAgent<ValSpine<K, V, G, R>>>;
+type Arrange<T, K, V, R> = Arranged<TraceAgent<ValSpine<K, V, T, R>>>;
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn three_hop<G: Timestamp + Lattice + Ord>(
-    forward_graph: Arrange<G, Node, Node, isize>,
-    reverse_graph: Arrange<G, Node, Node, isize>,
-    goals: VecCollection<G, (Node, Node)>) -> VecCollection<G, ((Node, Node), u32)>
+fn three_hop<T: Timestamp + Lattice + Ord>(
+    forward_graph: Arrange<T, Node, Node, isize>,
+    reverse_graph: Arrange<T, Node, Node, isize>,
+    goals: VecCollection<T, (Node, Node)>) -> VecCollection<T, ((Node, Node), u32)>
 {
 
     let sources = goals.clone().map(|(x,_)| x);
@@ -321,10 +321,10 @@ fn three_hop<G: Timestamp + Lattice + Ord>(
 }
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn _bidijkstra<G: Timestamp + Lattice + Ord>(
-    forward_graph: Arrange<G, Node, Node, isize>,
-    reverse_graph: Arrange<G, Node, Node, isize>,
-    goals: VecCollection<G, (Node, Node)>) -> VecCollection<G, ((Node, Node), u32)>
+fn _bidijkstra<T: Timestamp + Lattice + Ord>(
+    forward_graph: Arrange<T, Node, Node, isize>,
+    reverse_graph: Arrange<T, Node, Node, isize>,
+    goals: VecCollection<T, (Node, Node)>) -> VecCollection<T, ((Node, Node), u32)>
 {
 
     let outer = goals.scope();
diff --git a/experiments/src/bin/graphs-interactive.rs b/experiments/src/bin/graphs-interactive.rs
index 7976d1a4c..9ee11bf7b 100644
--- a/experiments/src/bin/graphs-interactive.rs
+++ b/experiments/src/bin/graphs-interactive.rs
@@ -194,14 +194,14 @@ use differential_dataflow::trace::implementations::ValSpine;
 use differential_dataflow::operators::arrange::TraceAgent;
 use differential_dataflow::operators::arrange::Arranged;
 
-type Arrange<G, K, V, R> = Arranged<TraceAgent<ValSpine<K, V, G, R>>>;
+type Arrange<T, K, V, R> = Arranged<TraceAgent<ValSpine<K, V, T, R>>>;
 
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn three_hop<G: Timestamp + Lattice + Ord>(
-    forward_graph: Arrange<G, Node, Node, isize>,
-    reverse_graph: Arrange<G, Node, Node, isize>,
-    goals: VecCollection<G, (Node, Node)>) -> VecCollection<G, ((Node, Node), u32)>
+fn three_hop<T: Timestamp + Lattice + Ord>(
+    forward_graph: Arrange<T, Node, Node, isize>,
+    reverse_graph: Arrange<T, Node, Node, isize>,
+    goals: VecCollection<T, (Node, Node)>) -> VecCollection<T, ((Node, Node), u32)>
 {
 
     let sources = goals.clone().map(|(x,_)| x);
@@ -225,10 +225,10 @@ fn three_hop<G: Timestamp + Lattice + Ord>(
 }
 
 // returns pairs (n, s) indicating node n can be reached from a root in s steps.
-fn _bidijkstra<G: Timestamp + Lattice + Ord>(
-    forward_graph: Arrange<G, Node, Node, isize>,
-    reverse_graph: Arrange<G, Node, Node, isize>,
-    goals: VecCollection<G, (Node, Node)>) -> VecCollection<G, ((Node, Node), u32)>
+fn _bidijkstra<T: Timestamp + Lattice + Ord>(
+    forward_graph: Arrange<T, Node, Node, isize>,
+    reverse_graph: Arrange<T, Node, Node, isize>,
+    goals: VecCollection<T, (Node, Node)>) -> VecCollection<T, ((Node, Node), u32)>
 {
 
     let outer = goals.scope();
diff --git a/mdbook/src/chapter_2/chapter_2_1.md b/mdbook/src/chapter_2/chapter_2_1.md
index 1d0e9ed9a..1967e053c 100644
--- a/mdbook/src/chapter_2/chapter_2_1.md
+++ b/mdbook/src/chapter_2/chapter_2_1.md
@@ -10,7 +10,7 @@ As an example, our example program used `map` to reverse the pairs of identifier
 # use timely::progress::Timestamp;
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::lattice::Lattice;
-# fn example<G: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<G, (u64, u64)>)
+# fn example<T: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<T, (u64, u64)>)
 # {
     manages
         .clone()
@@ -28,7 +28,7 @@ If instead we had just written
 # use timely::progress::Timestamp;
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::lattice::Lattice;
-# fn example<G: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<G, (u64, u64)>)
+# fn example<T: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<T, (u64, u64)>)
 # {
     manages
         .map(|(m2, m1)| m2);
diff --git a/mdbook/src/chapter_2/chapter_2_2.md b/mdbook/src/chapter_2/chapter_2_2.md
index 976ba87ea..f34636636 100644
--- a/mdbook/src/chapter_2/chapter_2_2.md
+++ b/mdbook/src/chapter_2/chapter_2_2.md
@@ -10,7 +10,7 @@ As an example, we might select out those management relation where the manager h
 # use timely::progress::Timestamp;
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::lattice::Lattice;
-# fn example<G: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<G, (u64, u64)>)
+# fn example<T: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<T, (u64, u64)>)
 # {
     manages
         .filter(|&(m2, m1)| m2 > m1);
diff --git a/mdbook/src/chapter_2/chapter_2_3.md b/mdbook/src/chapter_2/chapter_2_3.md
index fee20b65d..a8d2fc9b4 100644
--- a/mdbook/src/chapter_2/chapter_2_3.md
+++ b/mdbook/src/chapter_2/chapter_2_3.md
@@ -10,7 +10,7 @@ For example, we might form the symmetric "management relation" by concatenating
 # use timely::progress::Timestamp;
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::lattice::Lattice;
-# fn example<G: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<G, (u64, u64)>)
+# fn example<T: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<T, (u64, u64)>)
 # {
     manages
         .clone()
diff --git a/mdbook/src/chapter_2/chapter_2_4.md b/mdbook/src/chapter_2/chapter_2_4.md
index 9afb42941..5566f6a33 100644
--- a/mdbook/src/chapter_2/chapter_2_4.md
+++ b/mdbook/src/chapter_2/chapter_2_4.md
@@ -12,7 +12,7 @@ As an example, if we were to inspect
 # use timely::progress::Timestamp;
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::lattice::Lattice;
-# fn example<G: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<G, (u64, u64)>)
+# fn example<T: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<T, (u64, u64)>)
 # {
     manages
         .clone()
@@ -37,7 +37,7 @@ However, by introducing `consolidate`
 # use timely::progress::Timestamp;
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::lattice::Lattice;
-# fn example<G: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<G, (u64, u64)>)
+# fn example<T: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<T, (u64, u64)>)
 # {
     manages
         .clone()
diff --git a/mdbook/src/chapter_2/chapter_2_5.md b/mdbook/src/chapter_2/chapter_2_5.md
index aee1ecce8..84d694d0a 100644
--- a/mdbook/src/chapter_2/chapter_2_5.md
+++ b/mdbook/src/chapter_2/chapter_2_5.md
@@ -10,7 +10,7 @@ Our example from earlier uses a join to match up pairs `(m2, m1)` and `(m1, p)`
 # use timely::progress::Timestamp;
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::lattice::Lattice;
-# fn example<G: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<G, (u64, u64)>)
+# fn example<T: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<T, (u64, u64)>)
 # {
     manages
         .clone()
diff --git a/mdbook/src/chapter_2/chapter_2_6.md b/mdbook/src/chapter_2/chapter_2_6.md
index bd017f8fe..5c23c56c8 100644
--- a/mdbook/src/chapter_2/chapter_2_6.md
+++ b/mdbook/src/chapter_2/chapter_2_6.md
@@ -10,7 +10,7 @@ For example, to produce for each manager their managee with the lowest identifie
 # use timely::progress::Timestamp;
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::lattice::Lattice;
-# fn example<G: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<G, (u64, u64), i64>)
+# fn example<T: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<T, (u64, u64), i64>)
 # {
     manages
         .reduce(|_key, input, output| {
diff --git a/mdbook/src/chapter_2/chapter_2_7.md b/mdbook/src/chapter_2/chapter_2_7.md
index c18f9dd68..18c58965a 100644
--- a/mdbook/src/chapter_2/chapter_2_7.md
+++ b/mdbook/src/chapter_2/chapter_2_7.md
@@ -11,7 +11,7 @@ As an example, we can take our `manages` relation and determine for all employee
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::operators::Iterate;
 # use differential_dataflow::lattice::Lattice;
-# fn example<G: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<G, (u64, u64)>)
+# fn example<T: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<T, (u64, u64)>)
 # {
     manages   // transitive contains (manager, person) for many hops.
         .iterate(|_scope, transitive| {
@@ -47,7 +47,7 @@ In the example above, we could rewrite
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::operators::{Iterate, iterate::VecVariable};
 # use differential_dataflow::lattice::Lattice;
-# fn example<G: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<G, (u64, u64)>)
+# fn example<T: timely::progress::Timestamp + differential_dataflow::lattice::Lattice>(manages: VecCollection<T, (u64, u64)>)
 # {
     manages   // transitive contains (manager, person) for many hops.
         .clone()
@@ -88,7 +88,7 @@ As an example, the implementation of the `iterate` operator looks something like
 # use differential_dataflow::VecCollection;
 # use differential_dataflow::operators::{Iterate, iterate::VecVariable};
 # use differential_dataflow::lattice::Lattice;
-# fn logic<G: Timestamp + Lattice>(collection: VecCollection<G, (u64, u64), isize>) -> VecCollection<G, (u64, u64)>
+# fn logic<T: Timestamp + Lattice>(collection: VecCollection<T, (u64, u64), isize>) -> VecCollection<T, (u64, u64)>
 # {
 #     collection
 # }

From a9a799e3821ac7d797674c508b6f0769923fdca4 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Thu, 9 Apr 2026 12:33:37 -0400
Subject: [PATCH 09/13] Remove as Timestamp prompts

---
 differential-dataflow/examples/graspan.rs                 | 2 +-
 differential-dataflow/src/collection.rs                   | 4 ++--
 differential-dataflow/src/operators/arrange/agent.rs      | 4 ++--
 .../src/operators/arrange/arrangement.rs                  | 2 +-
 differential-dataflow/src/operators/arrange/upsert.rs     | 2 +-
 differential-dataflow/src/operators/iterate.rs            | 8 ++++----
 dogsdogsdogs/src/altneu.rs                                | 2 +-
 7 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/differential-dataflow/examples/graspan.rs b/differential-dataflow/examples/graspan.rs
index f6f89cfb7..62a0e053f 100644
--- a/differential-dataflow/examples/graspan.rs
+++ b/differential-dataflow/examples/graspan.rs
@@ -88,7 +88,7 @@ pub struct EdgeVariable<T: Timestamp + Lattice> {
 
 impl<T: Timestamp + Lattice> EdgeVariable<T> {
     /// Creates a new variable initialized with `source`.
-    pub fn from(source: VecCollection<T, Edge>, step: <T as Timestamp>::Summary) -> Self {
+    pub fn from(source: VecCollection<T, Edge>, step: T::Summary) -> Self {
         let (variable, collection) = VecVariable::new(&mut source.scope(), step);
         EdgeVariable {
             variable,
diff --git a/differential-dataflow/src/collection.rs b/differential-dataflow/src/collection.rs
index 4af2a69f2..7cb18c2dd 100644
--- a/differential-dataflow/src/collection.rs
+++ b/differential-dataflow/src/collection.rs
@@ -249,9 +249,9 @@ impl<T: Timestamp, C: Container> Collection<T, C> {
     ///     data.results_in(summary1);
     /// });
     /// ```
-    pub fn results_in(self, step: <T as Timestamp>::Summary) -> Self
+    pub fn results_in(self, step: T::Summary) -> Self
     where
-        C: containers::ResultsIn<<T as Timestamp>::Summary>,
+        C: containers::ResultsIn<T::Summary>,
     {
         use timely::dataflow::channels::pact::Pipeline;
         self.inner
diff --git a/differential-dataflow/src/operators/arrange/agent.rs b/differential-dataflow/src/operators/arrange/agent.rs
index 1cc88bd96..7ae253d2c 100644
--- a/differential-dataflow/src/operators/arrange/agent.rs
+++ b/differential-dataflow/src/operators/arrange/agent.rs
@@ -102,7 +102,7 @@ impl<Tr: TraceReader> TraceAgent<Tr> {
         };
 
         let writer = TraceWriter::new(
-            vec![<Tr::Time as Timestamp>::minimum()],
+            vec![Tr::Time::minimum()],
             Rc::downgrade(&trace),
             queues,
         );
@@ -126,7 +126,7 @@ impl<Tr: TraceReader> TraceAgent<Tr> {
             .borrow_mut()
             .trace
             .map_batches(|batch| {
-                new_queue.push_back(TraceReplayInstruction::Batch(batch.clone(), Some(<Tr::Time as Timestamp>::minimum())));
+                new_queue.push_back(TraceReplayInstruction::Batch(batch.clone(), Some(Tr::Time::minimum())));
                 upper = Some(batch.upper().clone());
             });
 
diff --git a/differential-dataflow/src/operators/arrange/arrangement.rs b/differential-dataflow/src/operators/arrange/arrangement.rs
index eeb47095e..07ff2be10 100644
--- a/differential-dataflow/src/operators/arrange/arrangement.rs
+++ b/differential-dataflow/src/operators/arrange/arrangement.rs
@@ -407,7 +407,7 @@ where
         *reader_ref = Some(reader_local);
 
         // Initialize to the minimal input frontier.
-        let mut prev_frontier = Antichain::from_elem(<T as Timestamp>::minimum());
+        let mut prev_frontier = Antichain::from_elem(T::minimum());
 
         move |(input, frontier), output| {
 
diff --git a/differential-dataflow/src/operators/arrange/upsert.rs b/differential-dataflow/src/operators/arrange/upsert.rs
index 16463022e..4ae9d9013 100644
--- a/differential-dataflow/src/operators/arrange/upsert.rs
+++ b/differential-dataflow/src/operators/arrange/upsert.rs
@@ -176,7 +176,7 @@ where
             *reader = Some(reader_local.clone());
 
             // Tracks the input frontier, used to populate the lower bound of new batches.
-            let mut prev_frontier = Antichain::from_elem(<T as Timestamp>::minimum());
+            let mut prev_frontier = Antichain::from_elem(T::minimum());
 
             // For stashing input upserts, ordered increasing by time (`BinaryHeap` is a max-heap).
             let mut priority_queue = BinaryHeap::<std::cmp::Reverse<(T, K, Option<V>)>>::new();
diff --git a/differential-dataflow/src/operators/iterate.rs b/differential-dataflow/src/operators/iterate.rs
index 4efd8223f..8e04fe61c 100644
--- a/differential-dataflow/src/operators/iterate.rs
+++ b/differential-dataflow/src/operators/iterate.rs
@@ -197,7 +197,7 @@ where
 {
     feedback: Handle<T, C>,
     source: Option<Collection<T, C>>,
-    step: <T as Timestamp>::Summary,
+    step: T::Summary,
 }
 
 /// A `Variable` specialized to a vector container of update triples (data, time, diff).
@@ -206,7 +206,7 @@ pub type VecVariable<T, D, R> = Variable<T, Vec<(D, T, R)>>;
 impl<T, C: Container> Variable<T, C>
 where
     T: Timestamp + Lattice,
-    C: crate::collection::containers::ResultsIn<<T as Timestamp>::Summary>,
+    C: crate::collection::containers::ResultsIn<T::Summary>,
 {
     /// Creates a new initially empty `Variable` and its associated `Collection`.
     ///
@@ -219,7 +219,7 @@ where
     /// will produce its fixed point in the outer scope.
     ///
     /// In a non-iterative scope the mechanics are the same, but the interpretation varies.
-    pub fn new(scope: &mut Scope<T>, step: <T as Timestamp>::Summary) -> (Self, Collection<T, C>) {
+    pub fn new(scope: &mut Scope<T>, step: T::Summary) -> (Self, Collection<T, C>) {
         let (feedback, updates) = scope.feedback(step.clone());
         let collection = Collection::<T, C>::new(updates);
         (Self { feedback, source: None, step }, collection)
@@ -250,7 +250,7 @@ where
     /// adding the source, doing the logic, then subtracting the source, it is appropriate to do.
     /// For example, if the logic modifies a few records it is possible to produce this update
     /// directly without using the backstop implementation this method provides.
-    pub fn new_from(source: Collection<T, C>, step: <T as Timestamp>::Summary) -> (Self, Collection<T, C>) where C: Clone + crate::collection::containers::Negate {
+    pub fn new_from(source: Collection<T, C>, step: T::Summary) -> (Self, Collection<T, C>) where C: Clone + crate::collection::containers::Negate {
         let (feedback, updates) = source.inner.scope().feedback(step.clone());
         let collection = Collection::<T, C>::new(updates).concat(source.clone());
         (Variable { feedback, source: Some(source.negate()), step }, collection)
diff --git a/dogsdogsdogs/src/altneu.rs b/dogsdogsdogs/src/altneu.rs
index 95d69cbc0..0ddb9572a 100644
--- a/dogsdogsdogs/src/altneu.rs
+++ b/dogsdogsdogs/src/altneu.rs
@@ -66,7 +66,7 @@ impl<T: Timestamp> Refines<T> for AltNeu<T> {
     fn to_outer(self: AltNeu<T>) -> T {
         self.time
     }
-    fn summarize(_path: ()) -> <T as Timestamp>::Summary {
+    fn summarize(_path: ()) -> T::Summary {
         Default::default()
     }
 }

From 6bd54bcb654133ab2e0aa94af3852f148b16aebf Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Thu, 9 Apr 2026 13:00:31 -0400
Subject: [PATCH 10/13] Remove T generics bound by Tr

---
 .../examples/columnar/main.rs                 |  2 +-
 .../src/algorithms/graphs/bfs.rs              |  5 +-
 .../src/algorithms/graphs/bijkstra.rs         |  9 ++--
 .../src/algorithms/graphs/propagate.rs        |  5 +-
 .../src/operators/arrange/arrangement.rs      |  2 +-
 .../src/operators/arrange/upsert.rs           | 22 ++++-----
 differential-dataflow/src/operators/count.rs  | 11 ++---
 differential-dataflow/src/operators/join.rs   | 13 +++--
 .../src/operators/threshold.rs                | 11 ++---
 dogsdogsdogs/src/operators/count.rs           | 11 ++---
 dogsdogsdogs/src/operators/half_join.rs       | 48 +++++++++----------
 dogsdogsdogs/src/operators/half_join2.rs      | 43 ++++++++---------
 dogsdogsdogs/src/operators/lookup_map.rs      | 14 +++---
 dogsdogsdogs/src/operators/propose.rs         | 20 ++++----
 dogsdogsdogs/src/operators/validate.rs        | 11 ++---
 15 files changed, 101 insertions(+), 126 deletions(-)

diff --git a/differential-dataflow/examples/columnar/main.rs b/differential-dataflow/examples/columnar/main.rs
index 02fc56970..1cbede8a1 100644
--- a/differential-dataflow/examples/columnar/main.rs
+++ b/differential-dataflow/examples/columnar/main.rs
@@ -141,7 +141,7 @@ mod reachability {
 
             // join_traces with ValColBuilder: produces Stream<_, RecordedUpdates<...>>.
             let proposed =
-                join_traces::<_, _, _, _, ValColBuilder<(Node, (), IterTime, Diff)>>(
+                join_traces::<_, _, _, ValColBuilder<(Node, (), IterTime, Diff)>>(
                     edges_arr,
                     reach_arr,
                     |_src, dst, (), time, d1, d2, session| {
diff --git a/differential-dataflow/src/algorithms/graphs/bfs.rs b/differential-dataflow/src/algorithms/graphs/bfs.rs
index ac32e6e39..f6676e94b 100644
--- a/differential-dataflow/src/algorithms/graphs/bfs.rs
+++ b/differential-dataflow/src/algorithms/graphs/bfs.rs
@@ -22,11 +22,10 @@ use crate::trace::TraceReader;
 use crate::operators::arrange::Arranged;
 
 /// Returns pairs (node, dist) indicating distance of each node from a root.
-pub fn bfs_arranged<T, N, Tr>(edges: Arranged<Tr>, roots: VecCollection<T, N>) -> VecCollection<T, (N, u32)>
+pub fn bfs_arranged<N, Tr>(edges: Arranged<Tr>, roots: VecCollection<Tr::Time, N>) -> VecCollection<Tr::Time, (N, u32)>
 where
-    T: Timestamp + Lattice + Ord,
     N: ExchangeData+Hash,
-    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Time=T, Diff=isize>+Clone+'static,
+    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Diff=isize, Time: Lattice + Ord>+Clone+'static,
 {
     // initialize roots as reaching themselves at distance 0
     let nodes = roots.map(|x| (x, 0));
diff --git a/differential-dataflow/src/algorithms/graphs/bijkstra.rs b/differential-dataflow/src/algorithms/graphs/bijkstra.rs
index 002956595..4559944a1 100644
--- a/differential-dataflow/src/algorithms/graphs/bijkstra.rs
+++ b/differential-dataflow/src/algorithms/graphs/bijkstra.rs
@@ -33,15 +33,14 @@ use crate::trace::TraceReader;
 use crate::operators::arrange::Arranged;
 
 /// Bi-directional Dijkstra search using arranged forward and reverse edge collections.
-pub fn bidijkstra_arranged<T, N, Tr>(
+pub fn bidijkstra_arranged<N, Tr>(
     forward: Arranged<Tr>,
     reverse: Arranged<Tr>,
-    goals: VecCollection<T, (N,N)>
-) -> VecCollection<T, ((N,N), u32)>
+    goals: VecCollection<Tr::Time, (N,N)>
+) -> VecCollection<Tr::Time, ((N,N), u32)>
 where
-    T: Timestamp + Lattice + Ord,
     N: ExchangeData+Hash,
-    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Time=T, Diff=isize>+Clone+'static,
+    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Diff=isize, Time: Lattice + Ord>+Clone+'static,
 {
     let outer = forward.stream.scope();
     outer.iterative::<u64,_,_>(|inner| {
diff --git a/differential-dataflow/src/algorithms/graphs/propagate.rs b/differential-dataflow/src/algorithms/graphs/propagate.rs
index b11e3bc0d..c78bd6f92 100644
--- a/differential-dataflow/src/algorithms/graphs/propagate.rs
+++ b/differential-dataflow/src/algorithms/graphs/propagate.rs
@@ -51,15 +51,14 @@ use crate::operators::arrange::arrangement::Arranged;
 /// This variant takes a pre-arranged edge collection, to facilitate re-use, and allows
 /// a method `logic` to specify the rounds in which we introduce various labels. The output
 /// of `logic should be a number in the interval \[0,64\],
-pub fn propagate_core<T, N, L, Tr, F, R>(edges: Arranged<Tr>, nodes: VecCollection<T,(N,L),R>, logic: F) -> VecCollection<T,(N,L),R>
+pub fn propagate_core<N, L, Tr, F, R>(edges: Arranged<Tr>, nodes: VecCollection<Tr::Time,(N,L),R>, logic: F) -> VecCollection<Tr::Time,(N,L),R>
 where
-    T: Timestamp + Lattice + Ord + Hash,
     N: ExchangeData+Hash,
     R: ExchangeData+Abelian,
     R: Multiply<R, Output=R>,
     R: From<i8>,
     L: ExchangeData,
-    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Time=T, Diff=R>+Clone+'static,
+    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Diff=R, Time: Lattice + Ord + Hash>+Clone+'static,
     F: Fn(&L)->u64+Clone+'static,
 {
     // Morally the code performs the following iterative computation. However, in the interest of a simplified
diff --git a/differential-dataflow/src/operators/arrange/arrangement.rs b/differential-dataflow/src/operators/arrange/arrangement.rs
index 07ff2be10..b65efd839 100644
--- a/differential-dataflow/src/operators/arrange/arrangement.rs
+++ b/differential-dataflow/src/operators/arrange/arrangement.rs
@@ -249,7 +249,7 @@ where
         };
 
         use crate::operators::join::join_traces;
-        join_traces::<_, _, _, _, crate::consolidation::ConsolidatingContainerBuilder<_>>(
+        join_traces::<_, _, _, crate::consolidation::ConsolidatingContainerBuilder<_>>(
             self,
             other,
             move |k, v1, v2, t, d1, d2, c| {
diff --git a/differential-dataflow/src/operators/arrange/upsert.rs b/differential-dataflow/src/operators/arrange/upsert.rs
index 4ae9d9013..8534aa5d6 100644
--- a/differential-dataflow/src/operators/arrange/upsert.rs
+++ b/differential-dataflow/src/operators/arrange/upsert.rs
@@ -59,7 +59,7 @@
 //!         use differential_dataflow::operators::arrange::upsert;
 //!
 //!         let stream = scope.input_from(&mut input);
-//!         let arranged = upsert::arrange_from_upsert::<_, ValBuilder<Key, Val, _, _>, ValSpine<Key, Val, _, _>,String,String>(stream, &"test");
+//!         let arranged = upsert::arrange_from_upsert::<ValBuilder<Key, Val, _, _>, ValSpine<Key, Val, _, _>,String,String>(stream, &"test");
 //!
 //!         arranged
 //!             .as_collection(|k,v| (k.clone(), v.clone()))
@@ -129,22 +129,20 @@ use super::TraceAgent;
 /// This method is only implemented for totally ordered times, as we do not yet
 /// understand what a "sequence" of upserts would mean for partially ordered
 /// timestamps.
-pub fn arrange_from_upsert<T, Bu, Tr, K, V>(
-    stream: Stream<T, Vec<(K, Option<V>, T)>>,
+pub fn arrange_from_upsert<Bu, Tr, K, V>(
+    stream: Stream<Tr::Time, Vec<(K, Option<V>, Tr::Time)>>,
     name: &str,
 ) -> Arranged<TraceAgent<Tr>>
 where
-    T: Timestamp,
     K: ExchangeData+Hashable+std::hash::Hash,
     V: ExchangeData,
     Tr: for<'a> Trace<
         Key<'a> = &'a K,
         Val<'a> = &'a V,
-        Time = T,
+        Time: TotalOrder+ExchangeData,
         Diff=isize,
     >+'static,
-    T: TotalOrder+ExchangeData,
-    Bu: Builder<Time=T, Input = Vec<((K, V), Tr::Time, Tr::Diff)>, Output = Tr::Batch>,
+    Bu: Builder<Time=Tr::Time, Input = Vec<((K, V), Tr::Time, Tr::Diff)>, Output = Tr::Batch>,
 {
     let mut reader: Option<TraceAgent<Tr>> = None;
 
@@ -153,7 +151,7 @@ where
 
         let reader = &mut reader;
 
-        let exchange = Exchange::new(move |update: &(K,Option<V>,T)| (update.0).hashed().into());
+        let exchange = Exchange::new(move |update: &(K,Option<V>,Tr::Time)| (update.0).hashed().into());
 
         let scope = stream.scope();
         stream.unary_frontier(exchange, name, move |_capability, info| {
@@ -162,7 +160,7 @@ where
             let logger = scope.logger_for::<crate::logging::DifferentialEventBuilder>("differential/arrange").map(Into::into);
 
             // Tracks the lower envelope of times in `priority_queue`.
-            let mut capabilities = Antichain::<Capability<T>>::new();
+            let mut capabilities = Antichain::<Capability<Tr::Time>>::new();
             // Form the trace we will both use internally and publish.
             let activator = Some(scope.activator_for(info.address.clone()));
             let mut empty_trace = Tr::new(info.clone(), logger.clone(), activator);
@@ -176,10 +174,10 @@ where
             *reader = Some(reader_local.clone());
 
             // Tracks the input frontier, used to populate the lower bound of new batches.
-            let mut prev_frontier = Antichain::from_elem(T::minimum());
+            let mut prev_frontier = Antichain::from_elem(Tr::Time::minimum());
 
             // For stashing input upserts, ordered increasing by time (`BinaryHeap` is a max-heap).
-            let mut priority_queue = BinaryHeap::<std::cmp::Reverse<(T, K, Option<V>)>>::new();
+            let mut priority_queue = BinaryHeap::<std::cmp::Reverse<(Tr::Time, K, Option<V>)>>::new();
             let mut updates = Vec::new();
 
             move |(input, frontier), output| {
@@ -282,7 +280,7 @@ where
                                     updates.sort();
                                     builder.push(&mut updates);
                                 }
-                                let description = Description::new(prev_frontier.clone(), upper.clone(), Antichain::from_elem(T::minimum()));
+                                let description = Description::new(prev_frontier.clone(), upper.clone(), Antichain::from_elem(Tr::Time::minimum()));
                                 let batch = builder.done(description);
                                 prev_frontier.clone_from(&upper);
 
diff --git a/differential-dataflow/src/operators/count.rs b/differential-dataflow/src/operators/count.rs
index 95b2f8825..23d7c7f84 100644
--- a/differential-dataflow/src/operators/count.rs
+++ b/differential-dataflow/src/operators/count.rs
@@ -52,26 +52,25 @@ where
     }
 }
 
-impl<T, K, Tr> CountTotal<T, K, Tr::Diff> for Arranged<Tr>
+impl<K, Tr> CountTotal<Tr::Time, K, Tr::Diff> for Arranged<Tr>
 where
-    T: Timestamp + TotalOrder + Lattice + Ord,
     Tr: for<'a> TraceReader<
         Key<'a> = &'a K,
         Val<'a>=&'a (),
-        Time = T,
+        Time: TotalOrder + Lattice + Ord,
         Diff: ExchangeData+Semigroup<Tr::DiffGat<'a>>
     >+Clone+'static,
     K: ExchangeData,
 {
-    fn count_total_core<R2: Semigroup + From<i8> + 'static>(self) -> VecCollection<T, (K, Tr::Diff), R2> {
+    fn count_total_core<R2: Semigroup + From<i8> + 'static>(self) -> VecCollection<Tr::Time, (K, Tr::Diff), R2> {
 
         let mut trace = self.trace.clone();
 
         self.stream.unary_frontier(Pipeline, "CountTotal", move |_,_| {
 
             // tracks the lower and upper limit of received batches.
-            let mut lower_limit = timely::progress::frontier::Antichain::from_elem(<T as timely::progress::Timestamp>::minimum());
-            let mut upper_limit = timely::progress::frontier::Antichain::from_elem(<T as timely::progress::Timestamp>::minimum());
+            let mut lower_limit = timely::progress::frontier::Antichain::from_elem(Tr::Time::minimum());
+            let mut upper_limit = timely::progress::frontier::Antichain::from_elem(Tr::Time::minimum());
 
             move |(input, _frontier), output| {
 
diff --git a/differential-dataflow/src/operators/join.rs b/differential-dataflow/src/operators/join.rs
index 1a1bbd405..31dfca368 100644
--- a/differential-dataflow/src/operators/join.rs
+++ b/differential-dataflow/src/operators/join.rs
@@ -67,12 +67,11 @@ impl<CB: PushInto<D>, D> PushInto<D> for EffortBuilder<CB> {
 /// The "correctness" of this method depends heavily on the behavior of the supplied `result` function.
 ///
 /// [`AsCollection`]: crate::collection::AsCollection
-pub fn join_traces<T, Tr1, Tr2, L, CB>(arranged1: Arranged<Tr1>, arranged2: Arranged<Tr2>, mut result: L) -> Stream<T, CB::Container>
+pub fn join_traces<Tr1, Tr2, L, CB>(arranged1: Arranged<Tr1>, arranged2: Arranged<Tr2>, mut result: L) -> Stream<Tr1::Time, CB::Container>
 where
-    T: Timestamp + Lattice,
-    Tr1: TraceReader<Time = T>+Clone+'static,
-    Tr2: for<'a> TraceReader<Key<'a>=Tr1::Key<'a>, Time = T>+Clone+'static,
-    L: FnMut(Tr1::Key<'_>,Tr1::Val<'_>,Tr2::Val<'_>,&T,&Tr1::Diff,&Tr2::Diff,&mut JoinSession<T, CB, Capability<T>>)+'static,
+    Tr1: TraceReader<Time: Lattice>+Clone+'static,
+    Tr2: for<'a> TraceReader<Key<'a>=Tr1::Key<'a>, Time = Tr1::Time>+Clone+'static,
+    L: FnMut(Tr1::Key<'_>,Tr1::Val<'_>,Tr2::Val<'_>,&Tr1::Time,&Tr1::Diff,&Tr2::Diff,&mut JoinSession<Tr1::Time, CB, Capability<Tr1::Time>>)+'static,
     CB: ContainerBuilder,
 {
     // Rename traces for symmetry from here on out.
@@ -98,8 +97,8 @@ where
         // the physical compaction frontier of their corresponding trace.
         // Should we ever *drop* a trace, these are 1. much harder to maintain correctly, but 2. no longer used.
         use timely::progress::frontier::Antichain;
-        let mut acknowledged1 = Antichain::from_elem(<T>::minimum());
-        let mut acknowledged2 = Antichain::from_elem(<T>::minimum());
+        let mut acknowledged1 = Antichain::from_elem(Tr1::Time::minimum());
+        let mut acknowledged2 = Antichain::from_elem(Tr1::Time::minimum());
 
         // deferred work of batches from each input.
         let mut todo1 = std::collections::VecDeque::new();
diff --git a/differential-dataflow/src/operators/threshold.rs b/differential-dataflow/src/operators/threshold.rs
index f5c3d0037..9e259330f 100644
--- a/differential-dataflow/src/operators/threshold.rs
+++ b/differential-dataflow/src/operators/threshold.rs
@@ -98,18 +98,17 @@ where
     }
 }
 
-impl<T, K, Tr> ThresholdTotal<T, K, Tr::Diff> for Arranged<Tr>
+impl<K, Tr> ThresholdTotal<Tr::Time, K, Tr::Diff> for Arranged<Tr>
 where
-    T: Timestamp + TotalOrder + Lattice + Ord,
     Tr: for<'a> TraceReader<
         Key<'a>=&'a K,
         Val<'a>=&'a (),
-        Time = T,
+        Time: TotalOrder + Lattice + Ord,
         Diff : ExchangeData + Semigroup<Tr::DiffGat<'a>>,
     >+Clone+'static,
     K: ExchangeData,
 {
-    fn threshold_semigroup<R2, F>(self, mut thresh: F) -> VecCollection<T, K, R2>
+    fn threshold_semigroup<R2, F>(self, mut thresh: F) -> VecCollection<Tr::Time, K, R2>
     where
         R2: Semigroup+'static,
         F: for<'a> FnMut(Tr::Key<'a>,&Tr::Diff,Option<&Tr::Diff>)->Option<R2>+'static,
@@ -120,8 +119,8 @@ where
         self.stream.unary_frontier(Pipeline, "ThresholdTotal", move |_,_| {
 
             // tracks the lower and upper limit of received batches.
-            let mut lower_limit = timely::progress::frontier::Antichain::from_elem(<T as timely::progress::Timestamp>::minimum());
-            let mut upper_limit = timely::progress::frontier::Antichain::from_elem(<T as timely::progress::Timestamp>::minimum());
+            let mut lower_limit = timely::progress::frontier::Antichain::from_elem(Tr::Time::minimum());
+            let mut upper_limit = timely::progress::frontier::Antichain::from_elem(Tr::Time::minimum());
 
             move |(input, _frontier), output| {
 
diff --git a/dogsdogsdogs/src/operators/count.rs b/dogsdogsdogs/src/operators/count.rs
index 5a1047ff0..a92066f1e 100644
--- a/dogsdogsdogs/src/operators/count.rs
+++ b/dogsdogsdogs/src/operators/count.rs
@@ -1,5 +1,3 @@
-use timely::progress::Timestamp;
-
 use differential_dataflow::{ExchangeData, VecCollection, Hashable};
 use differential_dataflow::difference::{Semigroup, Monoid, Multiply};
 use differential_dataflow::operators::arrange::Arranged;
@@ -11,15 +9,14 @@ use differential_dataflow::trace::TraceReader;
 /// For each triple, it extracts a key using `key_selector`, and finds the
 /// associated count in `arrangement`. If the found count is less than `count`,
 /// the `count` and `index` fields are overwritten with their new values.
-pub fn count<T, Tr, K, R, F, P>(
-    prefixes: VecCollection<T, (P, usize, usize), R>,
+pub fn count<Tr, K, R, F, P>(
+    prefixes: VecCollection<Tr::Time, (P, usize, usize), R>,
     arrangement: Arranged<Tr>,
     key_selector: F,
     index: usize,
-) -> VecCollection<T, (P, usize, usize), R>
+) -> VecCollection<Tr::Time, (P, usize, usize), R>
 where
-    T: Timestamp + std::hash::Hash,
-    Tr: TraceReader<Time = T, Diff=isize>+Clone+'static,
+    Tr: TraceReader<Time: std::hash::Hash, Diff=isize>+Clone+'static,
     Tr::KeyContainer: differential_dataflow::trace::implementations::BatchContainer<Owned=K>,
     for<'a> Tr::Diff : Semigroup<Tr::DiffGat<'a>>,
     K: Hashable + Ord + Default + 'static,
diff --git a/dogsdogsdogs/src/operators/half_join.rs b/dogsdogsdogs/src/operators/half_join.rs
index aa0783708..80f7153b2 100644
--- a/dogsdogsdogs/src/operators/half_join.rs
+++ b/dogsdogsdogs/src/operators/half_join.rs
@@ -41,7 +41,8 @@ use timely::dataflow::Stream;
 use timely::scheduling::Scheduler;
 use timely::dataflow::channels::pact::{Pipeline, Exchange};
 use timely::dataflow::operators::{Capability, Operator, generic::Session};
-use timely::progress::{Antichain, Timestamp};
+use timely::PartialOrder;
+use timely::progress::Antichain;
 use timely::progress::frontier::AntichainRef;
 
 use differential_dataflow::{ExchangeData, VecCollection, AsCollection, Hashable};
@@ -74,35 +75,33 @@ use differential_dataflow::trace::implementations::BatchContainer;
 /// Notice that the time is hoisted up into data. The expectation is that
 /// once out of the "delta flow region", the updates will be `delay`d to the
 /// times specified in the payloads.
-pub fn half_join<T, K, V, R, Tr, FF, CF, DOut, S>(
-    stream: VecCollection<T, (K, V, T), R>,
+pub fn half_join<K, V, R, Tr, FF, CF, DOut, S>(
+    stream: VecCollection<Tr::Time, (K, V, Tr::Time), R>,
     arrangement: Arranged<Tr>,
     frontier_func: FF,
     comparison: CF,
     mut output_func: S,
-) -> VecCollection<T, (DOut, T), <R as Mul<Tr::Diff>>::Output>
+) -> VecCollection<Tr::Time, (DOut, Tr::Time), <R as Mul<Tr::Diff>>::Output>
 where
-    T: Timestamp + Lattice,
     K: Hashable + ExchangeData,
     V: ExchangeData,
     R: ExchangeData + Monoid,
-    Tr: TraceReader<Time = T>+Clone+'static,
-    T: std::hash::Hash,
+    Tr: TraceReader<Time: Lattice + std::hash::Hash>+Clone+'static,
     Tr::KeyContainer: BatchContainer<Owned=K>,
     R: Mul<Tr::Diff, Output: Semigroup>,
-    FF: Fn(&T, &mut Antichain<T>) + 'static,
-    CF: Fn(Tr::TimeGat<'_>, &T) -> bool + 'static,
+    FF: Fn(&Tr::Time, &mut Antichain<Tr::Time>) + 'static,
+    CF: Fn(Tr::TimeGat<'_>, &Tr::Time) -> bool + 'static,
     DOut: Clone+'static,
     S: FnMut(&K, &V, Tr::Val<'_>)->DOut+'static,
 {
-    let output_func = move |session: &mut SessionFor<T, _>, k: &K, v1: &V, v2: Tr::Val<'_>, initial: &T, diff1: &R, output: &mut Vec<(T, Tr::Diff)>| {
+    let output_func = move |session: &mut SessionFor<Tr::Time, _>, k: &K, v1: &V, v2: Tr::Val<'_>, initial: &Tr::Time, diff1: &R, output: &mut Vec<(Tr::Time, Tr::Diff)>| {
         for (time, diff2) in output.drain(..) {
             let diff = diff1.clone() * diff2.clone();
             let dout = (output_func(k, v1, v2), time.clone());
             session.give((dout, initial.clone(), diff));
         }
     };
-    half_join_internal_unsafe::<_, _, _, _, _, _,_,_,_, CapacityContainerBuilder<Vec<_>>>(stream, arrangement, frontier_func, comparison, |_timer, _count| false, output_func)
+    half_join_internal_unsafe::<_, _, _, _, _, _,_,_, CapacityContainerBuilder<Vec<_>>>(stream, arrangement, frontier_func, comparison, |_timer, _count| false, output_func)
         .as_collection()
 }
 
@@ -141,26 +140,24 @@ type SessionFor<'a, 'b, T, CB> =
 /// yield control, as a function of the elapsed time and the number of matched
 /// records. Note this is not the number of *output* records, owing mainly to
 /// the number of matched records being easiest to record with low overhead.
-pub fn half_join_internal_unsafe<T, K, V, R, Tr, FF, CF, Y, S, CB>(
-    stream: VecCollection<T, (K, V, T), R>,
+pub fn half_join_internal_unsafe<K, V, R, Tr, FF, CF, Y, S, CB>(
+    stream: VecCollection<Tr::Time, (K, V, Tr::Time), R>,
     mut arrangement: Arranged<Tr>,
     frontier_func: FF,
     comparison: CF,
     yield_function: Y,
     mut output_func: S,
-) -> Stream<T, CB::Container>
+) -> Stream<Tr::Time, CB::Container>
 where
-    T: Timestamp + Lattice,
     K: Hashable + ExchangeData,
     V: ExchangeData,
     R: ExchangeData + Monoid,
-    Tr: TraceReader<Time = T>+Clone+'static,
-    T: std::hash::Hash,
+    Tr: TraceReader<Time: Lattice + std::hash::Hash>+Clone+'static,
     Tr::KeyContainer: BatchContainer<Owned=K>,
-    FF: Fn(&T, &mut Antichain<T>) + 'static,
+    FF: Fn(&Tr::Time, &mut Antichain<Tr::Time>) + 'static,
     CF: Fn(Tr::TimeGat<'_>, &Tr::Time) -> bool + 'static,
     Y: Fn(std::time::Instant, usize) -> bool + 'static,
-    S: FnMut(&mut SessionFor<T, CB>, &K, &V, Tr::Val<'_>, &T, &R, &mut Vec<(T, Tr::Diff)>) + 'static,
+    S: FnMut(&mut SessionFor<Tr::Time, CB>, &K, &V, Tr::Val<'_>, &Tr::Time, &R, &mut Vec<(Tr::Time, Tr::Diff)>) + 'static,
     CB: ContainerBuilder,
 {
     // No need to block physical merging for this operator.
@@ -170,7 +167,7 @@ where
 
     let mut stash = HashMap::new();
 
-    let exchange = Exchange::new(move |update: &((K, V, T),T,R)| (update.0).0.hashed().into());
+    let exchange = Exchange::new(move |update: &((K, V, Tr::Time),Tr::Time,R)| (update.0).0.hashed().into());
 
     // Stash for (time, diff) accumulation.
     let mut output_buffer = Vec::new();
@@ -218,7 +215,7 @@ where
 
                         // Update yielded: We can only go from false to {false, true} as
                         // we're checking that `!yielded` holds before entering this block.
-                        yielded = process_proposals::<T, _, _, _, _, _, _, _, _>(
+                        yielded = process_proposals::<_, _, _, _, _, _, _, _>(
                             &comparison,
                             &yield_function,
                             &mut output_func,
@@ -302,7 +299,7 @@ where
 /// Leaves a zero diff in place for all proposals that were processed.
 ///
 /// Returns `true` if the operator should yield.
-fn process_proposals<T, Tr, CF, Y, S, CB, K, V, R>(
+fn process_proposals<Tr, CF, Y, S, CB, K, V, R>(
     comparison: &CF,
     yield_function: &Y,
     output_func: &mut S,
@@ -311,16 +308,15 @@ fn process_proposals<T, Tr, CF, Y, S, CB, K, V, R>(
     work: &mut usize,
     trace: &mut Tr,
     proposals: &mut Vec<((K, V, Tr::Time), Tr::Time, R)>,
-    mut session: SessionFor<T, CB>,
+    mut session: SessionFor<Tr::Time, CB>,
     frontier: AntichainRef<Tr::Time>
 ) -> bool
 where
-    T: Timestamp + Lattice,
-    Tr: TraceReader<Time = T>,
+    Tr: TraceReader<Time: Lattice>,
     Tr::KeyContainer: BatchContainer<Owned=K>,
     CF: Fn(Tr::TimeGat<'_>, &Tr::Time) -> bool + 'static,
     Y: Fn(Instant, usize) -> bool + 'static,
-    S: FnMut(&mut SessionFor<T, CB>, &K, &V, Tr::Val<'_>, &T, &R, &mut Vec<(T, Tr::Diff)>) + 'static,
+    S: FnMut(&mut SessionFor<Tr::Time, CB>, &K, &V, Tr::Val<'_>, &Tr::Time, &R, &mut Vec<(Tr::Time, Tr::Diff)>) + 'static,
     CB: ContainerBuilder,
     K: Ord,
     V: Ord,
diff --git a/dogsdogsdogs/src/operators/half_join2.rs b/dogsdogsdogs/src/operators/half_join2.rs
index 9e04602c4..b6302b2eb 100644
--- a/dogsdogsdogs/src/operators/half_join2.rs
+++ b/dogsdogsdogs/src/operators/half_join2.rs
@@ -26,6 +26,7 @@ use timely::dataflow::Stream;
 use timely::scheduling::Scheduler;
 use timely::dataflow::channels::pact::{Pipeline, Exchange};
 use timely::dataflow::operators::Operator;
+use timely::PartialOrder;
 use timely::progress::{Antichain, ChangeBatch, Timestamp};
 use timely::progress::frontier::MutableAntichain;
 
@@ -61,28 +62,26 @@ use timely::dataflow::operators::CapabilitySet;
 /// Notice that the time is hoisted up into data. The expectation is that
 /// once out of the "delta flow region", the updates will be `delay`d to the
 /// times specified in the payloads.
-pub fn half_join<T, K, V, R, Tr, FF, CF, DOut, S>(
-    stream: VecCollection<T, (K, V, T), R>,
+pub fn half_join<K, V, R, Tr, FF, CF, DOut, S>(
+    stream: VecCollection<Tr::Time, (K, V, Tr::Time), R>,
     arrangement: Arranged<Tr>,
     frontier_func: FF,
     comparison: CF,
     mut output_func: S,
-) -> VecCollection<T, (DOut, T), <R as Mul<Tr::Diff>>::Output>
+) -> VecCollection<Tr::Time, (DOut, Tr::Time), <R as Mul<Tr::Diff>>::Output>
 where
-    T: Timestamp + Lattice,
     K: Hashable + ExchangeData,
     V: ExchangeData,
     R: ExchangeData + Monoid,
-    Tr: TraceReader<Time = T>+Clone+'static,
-    T: std::hash::Hash,
+    Tr: TraceReader<Time: Lattice + std::hash::Hash>+Clone+'static,
     Tr::KeyContainer: BatchContainer<Owned=K>,
     R: Mul<Tr::Diff, Output: Semigroup>,
-    FF: Fn(&T, &mut Antichain<T>) + 'static,
-    CF: Fn(Tr::TimeGat<'_>, &T) -> bool + 'static,
+    FF: Fn(&Tr::Time, &mut Antichain<Tr::Time>) + 'static,
+    CF: Fn(Tr::TimeGat<'_>, &Tr::Time) -> bool + 'static,
     DOut: Clone+'static,
     S: FnMut(&K, &V, Tr::Val<'_>)->DOut+'static,
 {
-    let output_func = move |builder: &mut CapacityContainerBuilder<Vec<_>>, k: &K, v1: &V, v2: Tr::Val<'_>, initial: &T, diff1: &R, output: &mut Vec<(T, Tr::Diff)>| {
+    let output_func = move |builder: &mut CapacityContainerBuilder<Vec<_>>, k: &K, v1: &V, v2: Tr::Val<'_>, initial: &Tr::Time, diff1: &R, output: &mut Vec<(Tr::Time, Tr::Diff)>| {
         for (time, diff2) in output.drain(..) {
             let diff = diff1.clone() * diff2.clone();
             let dout = (output_func(k, v1, v2), time.clone());
@@ -90,7 +89,7 @@ where
             builder.push_into((dout, initial.clone(), diff));
         }
     };
-    half_join_internal_unsafe::<_, _, _, _, _, _,_,_,_, CapacityContainerBuilder<Vec<_>>>(stream, arrangement, frontier_func, comparison, |_timer, _count| false, output_func)
+    half_join_internal_unsafe::<_, _, _, _, _, _,_,_, CapacityContainerBuilder<Vec<_>>>(stream, arrangement, frontier_func, comparison, |_timer, _count| false, output_func)
         .as_collection()
 }
 
@@ -119,26 +118,24 @@ where
 /// yield control, as a function of the elapsed time and the number of matched
 /// records. Note this is not the number of *output* records, owing mainly to
 /// the number of matched records being easiest to record with low overhead.
-pub fn half_join_internal_unsafe<T, K, V, R, Tr, FF, CF, Y, S, CB>(
-    stream: VecCollection<T, (K, V, T), R>,
+pub fn half_join_internal_unsafe<K, V, R, Tr, FF, CF, Y, S, CB>(
+    stream: VecCollection<Tr::Time, (K, V, Tr::Time), R>,
     mut arrangement: Arranged<Tr>,
     frontier_func: FF,
     comparison: CF,
     yield_function: Y,
     mut output_func: S,
-) -> Stream<T, CB::Container>
+) -> Stream<Tr::Time, CB::Container>
 where
-    T: Timestamp + Lattice,
     K: Hashable + ExchangeData,
     V: ExchangeData,
     R: ExchangeData + Monoid,
-    Tr: TraceReader<Time = T>+Clone+'static,
-    T: std::hash::Hash,
+    Tr: TraceReader<Time: Lattice + std::hash::Hash>+Clone+'static,
     Tr::KeyContainer: BatchContainer<Owned=K>,
-    FF: Fn(&T, &mut Antichain<T>) + 'static,
+    FF: Fn(&Tr::Time, &mut Antichain<Tr::Time>) + 'static,
     CF: Fn(Tr::TimeGat<'_>, &Tr::Time) -> bool + 'static,
     Y: Fn(std::time::Instant, usize) -> bool + 'static,
-    S: FnMut(&mut CB, &K, &V, Tr::Val<'_>, &T, &R, &mut Vec<(T, Tr::Diff)>) + 'static,
+    S: FnMut(&mut CB, &K, &V, Tr::Val<'_>, &Tr::Time, &R, &mut Vec<(Tr::Time, Tr::Diff)>) + 'static,
     CB: ContainerBuilder,
 {
     // No need to block physical merging for this operator.
@@ -146,7 +143,7 @@ where
     let mut arrangement_trace = Some(arrangement.trace);
     let arrangement_stream = arrangement.stream;
 
-    let exchange = Exchange::new(move |update: &((K, V, T),T,R)| (update.0).0.hashed().into());
+    let exchange = Exchange::new(move |update: &((K, V, Tr::Time),Tr::Time,R)| (update.0).0.hashed().into());
 
     // Stash for (time, diff) accumulation.
     let mut output_buffer = Vec::new();
@@ -154,7 +151,7 @@ where
     // Unified blobs: each blob holds data in (T, D, R) order, with a stuck_count
     // tracking how many elements at the back are not yet eligible for processing.
     // The ready prefix is sorted by (D, T, R) for cursor traversal.
-    let mut blobs: Vec<Blob<(K, V, T), T, R>> = Vec::new();
+    let mut blobs: Vec<Blob<(K, V, Tr::Time), Tr::Time, R>> = Vec::new();
 
     let scope = stream.scope();
     stream.inner.binary_frontier(arrangement_stream, exchange, Pipeline, "HalfJoin", move |_,info| {
@@ -165,7 +162,7 @@ where
         move |(input1, frontier1), (input2, frontier2), output| {
 
             // Drain all input into a single buffer.
-            let mut arriving: Vec<(T, (K, V, T), R)> = Vec::new();
+            let mut arriving: Vec<(Tr::Time, (K, V, Tr::Time), R)> = Vec::new();
             let mut caps = CapabilitySet::new();
             input1.for_each(|capability, data| {
                 caps.insert(capability.retain(0));
@@ -191,7 +188,7 @@ where
                 if let Some(min_time) = frontier.iter().min() {
                     time_con.push_own(min_time);
                 }
-                let eligible = |initial: &T| -> bool {
+                let eligible = |initial: &Tr::Time| -> bool {
                     !(0..time_con.len()).any(|i| comparison(time_con.index(i), initial))
                 };
 
@@ -267,7 +264,7 @@ where
 
                     let (mut cursor, storage) = trace.cursor();
                     let mut key_con = Tr::KeyContainer::with_capacity(1);
-                    let mut removals: ChangeBatch<T> = ChangeBatch::new();
+                    let mut removals: ChangeBatch<Tr::Time> = ChangeBatch::new();
 
                     // Process ready elements from the front.
                     while blob.data.len() > blob.stuck_count {
diff --git a/dogsdogsdogs/src/operators/lookup_map.rs b/dogsdogsdogs/src/operators/lookup_map.rs
index e1ed17c72..b15aba314 100644
--- a/dogsdogsdogs/src/operators/lookup_map.rs
+++ b/dogsdogsdogs/src/operators/lookup_map.rs
@@ -2,7 +2,8 @@ use std::collections::HashMap;
 
 use timely::dataflow::channels::pact::{Pipeline, Exchange};
 use timely::dataflow::operators::Operator;
-use timely::progress::{Antichain, Timestamp};
+use timely::PartialOrder;
+use timely::progress::Antichain;
 
 use differential_dataflow::{ExchangeData, VecCollection, AsCollection, Hashable};
 use differential_dataflow::difference::{IsZero, Semigroup, Monoid};
@@ -15,19 +16,18 @@ use differential_dataflow::trace::implementations::BatchContainer;
 /// This method takes a stream of prefixes and for each determines a
 /// key with `key_selector` and then proposes all pair af the prefix
 /// and values associated with the key in `arrangement`.
-pub fn lookup_map<T, D, K, R, Tr, F, DOut, ROut, S>(
-    prefixes: VecCollection<T, D, R>,
+pub fn lookup_map<D, K, R, Tr, F, DOut, ROut, S>(
+    prefixes: VecCollection<Tr::Time, D, R>,
     mut arrangement: Arranged<Tr>,
     key_selector: F,
     mut output_func: S,
     supplied_key0: K,
     supplied_key1: K,
     supplied_key2: K,
-) -> VecCollection<T, DOut, ROut>
+) -> VecCollection<Tr::Time, DOut, ROut>
 where
-    T: Timestamp + std::hash::Hash,
     Tr: for<'a> TraceReader<
-        Time = T,
+        Time: std::hash::Hash,
         Diff : Semigroup<Tr::DiffGat<'a>>+Monoid+ExchangeData,
     >+Clone+'static,
     Tr::KeyContainer: BatchContainer<Owned=K>,
@@ -49,7 +49,7 @@ where
     let mut logic2 = key_selector.clone();
 
     let mut key: K = supplied_key0;
-    let exchange = Exchange::new(move |update: &(D,T,R)| {
+    let exchange = Exchange::new(move |update: &(D,Tr::Time,R)| {
         logic1(&update.0, &mut key);
         key.hashed().into()
     });
diff --git a/dogsdogsdogs/src/operators/propose.rs b/dogsdogsdogs/src/operators/propose.rs
index 9897e5697..869e67aab 100644
--- a/dogsdogsdogs/src/operators/propose.rs
+++ b/dogsdogsdogs/src/operators/propose.rs
@@ -1,5 +1,3 @@
-use timely::progress::Timestamp;
-
 use differential_dataflow::{ExchangeData, VecCollection, Hashable};
 use differential_dataflow::difference::{Semigroup, Monoid, Multiply};
 use differential_dataflow::operators::arrange::Arranged;
@@ -13,16 +11,15 @@ use differential_dataflow::trace::TraceReader;
 /// create a join if the `prefixes` collection is also arranged and responds to changes that
 /// `arrangement` undergoes. More complicated patterns are also appropriate, as in the case
 /// of delta queries.
-pub fn propose<T, Tr, K, F, P, V>(
-    prefixes: VecCollection<T, P, Tr::Diff>,
+pub fn propose<Tr, K, F, P, V>(
+    prefixes: VecCollection<Tr::Time, P, Tr::Diff>,
     arrangement: Arranged<Tr>,
     key_selector: F,
-) -> VecCollection<T, (P, V), Tr::Diff>
+) -> VecCollection<Tr::Time, (P, V), Tr::Diff>
 where
-    T: Timestamp + std::hash::Hash,
     Tr: for<'a> TraceReader<
         ValOwn = V,
-        Time = T,
+        Time: std::hash::Hash,
         Diff: Monoid+Multiply<Output = Tr::Diff>+ExchangeData+Semigroup<Tr::DiffGat<'a>>,
     >+Clone+'static,
     Tr::KeyContainer: differential_dataflow::trace::implementations::BatchContainer<Owned=K>,
@@ -47,16 +44,15 @@ where
 /// Unlike `propose`, this method does not scale the multiplicity of matched
 /// prefixes by the number of matches in `arrangement`. This can be useful to
 /// avoid the need to prepare an arrangement of distinct extensions.
-pub fn propose_distinct<T, Tr, K, F, P, V>(
-    prefixes: VecCollection<T, P, Tr::Diff>,
+pub fn propose_distinct<Tr, K, F, P, V>(
+    prefixes: VecCollection<Tr::Time, P, Tr::Diff>,
     arrangement: Arranged<Tr>,
     key_selector: F,
-) -> VecCollection<T, (P, V), Tr::Diff>
+) -> VecCollection<Tr::Time, (P, V), Tr::Diff>
 where
-    T: Timestamp + std::hash::Hash,
     Tr: for<'a> TraceReader<
         ValOwn = V,
-        Time = T,
+        Time: std::hash::Hash,
         Diff : Semigroup<Tr::DiffGat<'a>>+Monoid+Multiply<Output = Tr::Diff>+ExchangeData,
     >+Clone+'static,
     Tr::KeyContainer: differential_dataflow::trace::implementations::BatchContainer<Owned=K>,
diff --git a/dogsdogsdogs/src/operators/validate.rs b/dogsdogsdogs/src/operators/validate.rs
index aab844390..0a28c2483 100644
--- a/dogsdogsdogs/src/operators/validate.rs
+++ b/dogsdogsdogs/src/operators/validate.rs
@@ -1,7 +1,5 @@
 use std::hash::Hash;
 
-use timely::progress::Timestamp;
-
 use differential_dataflow::{ExchangeData, VecCollection};
 use differential_dataflow::difference::{Semigroup, Monoid, Multiply};
 use differential_dataflow::operators::arrange::Arranged;
@@ -12,15 +10,14 @@ use differential_dataflow::trace::TraceReader;
 /// This method takes a stream of prefixes and for each determines a
 /// key with `key_selector` and then proposes all pair af the prefix
 /// and values associated with the key in `arrangement`.
-pub fn validate<T, K, V, Tr, F, P>(
-    extensions: VecCollection<T, (P, V), Tr::Diff>,
+pub fn validate<K, V, Tr, F, P>(
+    extensions: VecCollection<Tr::Time, (P, V), Tr::Diff>,
     arrangement: Arranged<Tr>,
     key_selector: F,
-) -> VecCollection<T, (P, V), Tr::Diff>
+) -> VecCollection<Tr::Time, (P, V), Tr::Diff>
 where
-    T: Timestamp + std::hash::Hash,
     Tr: for<'a> TraceReader<
-        Time = T,
+        Time: std::hash::Hash,
         Diff : Semigroup<Tr::DiffGat<'a>>+Monoid+Multiply<Output = Tr::Diff>+ExchangeData,
     >+Clone+'static,
     Tr::KeyContainer: differential_dataflow::trace::implementations::BatchContainer<Owned=(K,V)>,

From 444b81b50140110199a5d29b88a1c65981b183a7 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Thu, 9 Apr 2026 13:18:42 -0400
Subject: [PATCH 11/13] Remove Scope::clone calls

---
 differential-dataflow/examples/accumulate.rs  |  3 +-
 differential-dataflow/examples/graspan.rs     |  3 +-
 .../examples/iterate_container.rs             |  3 +-
 differential-dataflow/src/collection.rs       |  6 ++--
 .../src/operators/iterate.rs                  |  3 +-
 dogsdogsdogs/examples/delta_query.rs          |  5 ++--
 dogsdogsdogs/examples/delta_query_wcoj.rs     |  3 +-
 experiments/src/bin/graphs-static.rs          | 13 ++++----
 experiments/src/bin/graspan2.rs               | 30 +++++++++----------
 interactive/src/plan/sfw.rs                   |  5 ++--
 10 files changed, 31 insertions(+), 43 deletions(-)

diff --git a/differential-dataflow/examples/accumulate.rs b/differential-dataflow/examples/accumulate.rs
index a29b711ae..d8da7bdcd 100644
--- a/differential-dataflow/examples/accumulate.rs
+++ b/differential-dataflow/examples/accumulate.rs
@@ -17,11 +17,10 @@ fn main() {
         let mut input = worker.dataflow::<(), _, _>(|scope| {
             let (input, data) = scope.new_collection::<_, isize>();
 
-            let outer = scope.clone();
             scope.iterative::<u32,_,_>(|inner| {
                 data.enter_at(inner, |_| 0)
                     .consolidate()
-                    .leave(&outer)
+                    .leave(&scope)
             });
 
             input
diff --git a/differential-dataflow/examples/graspan.rs b/differential-dataflow/examples/graspan.rs
index 62a0e053f..4725cf4af 100644
--- a/differential-dataflow/examples/graspan.rs
+++ b/differential-dataflow/examples/graspan.rs
@@ -161,7 +161,6 @@ impl Query {
         }
 
         // We need a subscope to allow iterative development of variables.
-        let outer = scope.clone();
         scope.iterative::<Iter,_,_>(|subscope| {
 
             // create map from relation name to input handle and collection.
@@ -171,7 +170,7 @@ impl Query {
             // create variables and result handles for each named relation.
             for (name, (input, collection)) in input_map {
                 let edge_variable = EdgeVariable::from(collection.enter(subscope), Product::new(Default::default(), 1));
-                let trace = edge_variable.collection.clone().leave(&outer).arrange_by_self().trace;
+                let trace = edge_variable.collection.clone().leave(&scope).arrange_by_self().trace;
                 result_map.insert(name.clone(), RelationHandles { input, trace });
                 variable_map.insert(name.clone(), edge_variable);
             }
diff --git a/differential-dataflow/examples/iterate_container.rs b/differential-dataflow/examples/iterate_container.rs
index 030094f6e..d2fa85302 100644
--- a/differential-dataflow/examples/iterate_container.rs
+++ b/differential-dataflow/examples/iterate_container.rs
@@ -53,7 +53,6 @@ fn main() {
         let numbers = scope.new_collection_from(1 .. 10u32).1;
         let numbers: Collection<_, _>  = wrap(numbers.inner).as_collection();
 
-        let outer = scope.clone();
         scope.iterative::<u64,_,_>(|nested| {
             let summary = Product::new(Default::default(), 1);
             let (variable, collection) = Variable::new_from(numbers.enter(nested), summary);
@@ -78,7 +77,7 @@ fn main() {
             }).as_collection().consolidate();
             let result = wrap(result.inner).as_collection();
             variable.set(result);
-            collection.leave(&outer)
+            collection.leave(&scope)
         });
     })
 }
diff --git a/differential-dataflow/src/collection.rs b/differential-dataflow/src/collection.rs
index 7cb18c2dd..17d2ebecb 100644
--- a/differential-dataflow/src/collection.rs
+++ b/differential-dataflow/src/collection.rs
@@ -205,11 +205,10 @@ impl<T: Timestamp, C: Container> Collection<T, C> {
     ///
     ///     let data = scope.new_collection_from(1 .. 10).1;
     ///
-    ///     let outer = scope.clone();
     ///     let result = scope.region(|child| {
     ///         data.clone()
     ///             .enter(child)
-    ///             .leave(&outer)
+    ///             .leave(&scope)
     ///     });
     ///
     ///     data.assert_eq(result);
@@ -533,11 +532,10 @@ pub mod vec {
         ///
         ///     let data = scope.new_collection_from(1 .. 10).1;
         ///
-        ///     let outer = scope.clone();
         ///     let result = scope.iterative::<u64,_,_>(|child| {
         ///         data.clone()
         ///             .enter_at(child, |x| *x)
-        ///             .leave(&outer)
+        ///             .leave(&scope)
         ///     });
         ///
         ///     data.assert_eq(result);
diff --git a/differential-dataflow/src/operators/iterate.rs b/differential-dataflow/src/operators/iterate.rs
index 8e04fe61c..140e8888a 100644
--- a/differential-dataflow/src/operators/iterate.rs
+++ b/differential-dataflow/src/operators/iterate.rs
@@ -142,14 +142,13 @@ impl<T: Timestamp + Lattice, D: Ord+Data+Debug, R: Semigroup+'static> Iterate<T,
 ///
 ///     let numbers = scope.new_collection_from(1 .. 10u32).1;
 ///
-///     let outer = scope.clone();
 ///     scope.iterative::<u64,_,_>(|nested| {
 ///         let summary = Product::new(Default::default(), 1);
 ///         let (variable, collection) = Variable::new_from(numbers.enter(nested), summary);
 ///         let result = collection.map(|x| if x % 2 == 0 { x/2 } else { x })
 ///                                .consolidate();
 ///         variable.set(result.clone());
-///         result.leave(&outer)
+///         result.leave(&scope)
 ///     });
 /// })
 /// ```
diff --git a/dogsdogsdogs/examples/delta_query.rs b/dogsdogsdogs/examples/delta_query.rs
index 02cf67c41..74d24b246 100644
--- a/dogsdogsdogs/examples/delta_query.rs
+++ b/dogsdogsdogs/examples/delta_query.rs
@@ -42,7 +42,6 @@ fn main() {
             // let reverse_count = edges.map(|(x,y)| y).arrange_by_self();
 
             // Q(a,b,c) :=  E1(a,b),  E2(b,c),  E3(a,c)
-            let outer = scope.clone();
             let (triangles_prev, triangles_next) = scope.scoped::<AltNeu<usize>,_,_>("DeltaQuery (Triangles)", |inner| {
 
                 // Grab the stream of changes.
@@ -90,7 +89,7 @@ fn main() {
                 let changes3 = validate(changes3, reverse_self_alt.clone(), key2.clone());
                 let changes3 = changes3.map(|((a,c),b)| (a,b,c));
 
-                let prev_changes = changes1.concat(changes2).concat(changes3).leave(&outer);
+                let prev_changes = changes1.concat(changes2).concat(changes3).leave(&scope);
 
                 // New ideas
                 let d_edges = edges.differentiate(inner);
@@ -116,7 +115,7 @@ fn main() {
                     .join_core(forward_key_alt, |a,c,b| Some(((*c, *b), *a)))
                     .join_core(reverse_self_alt, |(c,b), a, &()| Some((*a,*b,*c)));
 
-                let next_changes = changes1.concat(changes2).concat(changes3).integrate(&outer);
+                let next_changes = changes1.concat(changes2).concat(changes3).integrate(&scope);
 
                 (prev_changes, next_changes)
             });
diff --git a/dogsdogsdogs/examples/delta_query_wcoj.rs b/dogsdogsdogs/examples/delta_query_wcoj.rs
index ab047c42e..760c0afc1 100644
--- a/dogsdogsdogs/examples/delta_query_wcoj.rs
+++ b/dogsdogsdogs/examples/delta_query_wcoj.rs
@@ -30,7 +30,6 @@ fn main() {
             let reverse = edges.map(|(x,y)| (y,x));
 
             // Q(a,b,c) :=  E1(a,b),  E2(b,c),  E3(a,c)
-            let outer = scope.clone();
             let triangles = scope.scoped::<AltNeu<usize>,_,_>("DeltaQuery (Triangles)", |inner| {
 
                 // Each relation we'll need.
@@ -80,7 +79,7 @@ fn main() {
                     ])
                     .map(|((a,c),b)| (a,b,c));
 
-                changes1.concat(changes2).concat(changes3).leave(&outer)
+                changes1.concat(changes2).concat(changes3).leave(&scope)
             });
 
             triangles
diff --git a/experiments/src/bin/graphs-static.rs b/experiments/src/bin/graphs-static.rs
index 45e98ade6..46a89b4a2 100644
--- a/experiments/src/bin/graphs-static.rs
+++ b/experiments/src/bin/graphs-static.rs
@@ -169,15 +169,14 @@ fn connected_components(
     let nodes_r = reverse.clone().flat_map_ref(|k,v| if k < v { Some(*k) } else { None });
     let nodes = nodes_f.concat(nodes_r).consolidate().map(|x| (x,x));
 
-    let outer = scope.clone();
-    scope.iterative(|scope| {
+    scope.iterative(|inner_scope| {
 
         // import arrangements, nodes.
-        let forward = forward.enter(scope);
-        let reverse = reverse.enter(scope);
-        let nodes = nodes.enter(scope);
+        let forward = forward.enter(inner_scope);
+        let reverse = reverse.enter(inner_scope);
+        let nodes = nodes.enter(inner_scope);
 
-        let (inner, inner_collection) = Variable::new(scope, Product::new(Default::default(), 1));
+        let (inner, inner_collection) = Variable::new(inner_scope, Product::new(Default::default(), 1));
 
         let labels = inner_collection.clone().arrange_by_key();
         let f_prop = labels.clone().join_core(forward, |_k,l,d| Some((*d,*l)));
@@ -198,6 +197,6 @@ fn connected_components(
             .reduce(|_, s, t| { t.push((*s[0].0, 1)); });
 
         inner.set(result.clone());
-        result.leave(&outer)
+        result.leave(scope)
     })
 }
diff --git a/experiments/src/bin/graspan2.rs b/experiments/src/bin/graspan2.rs
index 87c8b8fb7..f101ae246 100644
--- a/experiments/src/bin/graspan2.rs
+++ b/experiments/src/bin/graspan2.rs
@@ -48,17 +48,16 @@ fn unoptimized() {
 
             let dereference = dereference.arrange::<ValBatcher<_,_,_,_>, ValBuilder<_,_,_,_>, ValSpine<_,_,_,_>>();
 
-            let outer = scope.clone();
             let (value_flow, memory_alias, value_alias) =
             scope
-                .iterative::<Iter,_,_>(|scope| {
+                .iterative::<Iter,_,_>(|inner_scope| {
 
-                    let nodes = nodes.enter(scope);
-                    let assignment = assignment.enter(scope);
-                    let dereference = dereference.enter(scope);
+                    let nodes = nodes.enter(inner_scope);
+                    let assignment = assignment.enter(inner_scope);
+                    let dereference = dereference.enter(inner_scope);
 
-                    let (value_flow, value_flow_collection) = Variable::new(scope, Product::new(Default::default(), 1));
-                    let (memory_alias, memory_alias_collection) = Variable::new(scope, Product::new(Default::default(), 1));
+                    let (value_flow, value_flow_collection) = Variable::new(inner_scope, Product::new(Default::default(), 1));
+                    let (memory_alias, memory_alias_collection) = Variable::new(inner_scope, Product::new(Default::default(), 1));
 
                     let value_flow_arranged = value_flow_collection.arrange::<ValBatcher<_,_,_,_>, ValBuilder<_,_,_,_>, ValSpine<_,_,_,_>>();
                     let memory_alias_arranged = memory_alias_collection.arrange::<ValBatcher<_,_,_,_>, ValBuilder<_,_,_,_>, ValSpine<_,_,_,_>>();
@@ -108,7 +107,7 @@ fn unoptimized() {
                     value_flow.set(value_flow_next.clone());
                     memory_alias.set(memory_alias_next.clone());
 
-                    (value_flow_next.leave(&outer), memory_alias_next.leave(&outer), value_alias_next.leave(&outer))
+                    (value_flow_next.leave(&scope), memory_alias_next.leave(&scope), value_alias_next.leave(&scope))
                 });
 
                 value_flow.map(|_| ()).consolidate().inspect(|x| println!("VF: {:?}", x));
@@ -174,17 +173,16 @@ fn optimized() {
 
             let dereference = dereference.arrange::<ValBatcher<_,_,_,_>, ValBuilder<_,_,_,_>, ValSpine<_,_,_,_>>();
 
-            let outer = scope.clone();
             let (value_flow, memory_alias) =
             scope
-                .iterative::<Iter,_,_>(|scope| {
+                .iterative::<Iter,_,_>(|inner_scope| {
 
-                    let nodes = nodes.enter(scope);
-                    let assignment = assignment.enter(scope);
-                    let dereference = dereference.enter(scope);
+                    let nodes = nodes.enter(inner_scope);
+                    let assignment = assignment.enter(inner_scope);
+                    let dereference = dereference.enter(inner_scope);
 
-                    let (value_flow, value_flow_collection) = Variable::new(scope, Product::new(Default::default(), 1));
-                    let (memory_alias, memory_alias_collection) = Variable::new(scope, Product::new(Default::default(), 1));
+                    let (value_flow, value_flow_collection) = Variable::new(inner_scope, Product::new(Default::default(), 1));
+                    let (memory_alias, memory_alias_collection) = Variable::new(inner_scope, Product::new(Default::default(), 1));
 
                     let value_flow_arranged = value_flow_collection.clone().arrange::<ValBatcher<_,_,_,_>, ValBuilder<_,_,_,_>, ValSpine<_,_,_,_>>();
                     let memory_alias_arranged = memory_alias_collection.arrange::<ValBatcher<_,_,_,_>, ValBuilder<_,_,_,_>, ValSpine<_,_,_,_>>();
@@ -234,7 +232,7 @@ fn optimized() {
                     value_flow.set(value_flow_next.clone());
                     memory_alias.set(memory_alias_next.clone());
 
-                    (value_flow_next.leave(&outer), memory_alias_next.leave(&outer))
+                    (value_flow_next.leave(&scope), memory_alias_next.leave(&scope))
                 });
 
                 value_flow.map(|_| ()).consolidate().inspect(|x| println!("VF: {:?}", x));
diff --git a/interactive/src/plan/sfw.rs b/interactive/src/plan/sfw.rs
index d9e7a2f49..26f84b72a 100644
--- a/interactive/src/plan/sfw.rs
+++ b/interactive/src/plan/sfw.rs
@@ -231,8 +231,7 @@ impl<V: ExchangeData+Hash+Datum> Render for MultiwayJoin<V> {
             use differential_dogs3::altneu::AltNeu;
 
             let scope_name = format!("DeltaRule: {}/{}", index, self.sources.len());
-            let outer = scope.clone();
-            let changes = scope.clone().scoped::<AltNeu<_>,_,_>(&scope_name, |inner| {
+            let changes = scope.scoped::<AltNeu<_>,_,_>(&scope_name, |inner| {
 
                 // This should default to an `AltNeu::Alt` timestamp.
                 let mut changes =
@@ -289,7 +288,7 @@ impl<V: ExchangeData+Hash+Datum> Render for MultiwayJoin<V> {
 
                 changes
                     .map(move |tuple| extract_map.iter().map(|&i| tuple[i].clone()).collect::<Vec<_>>())
-                    .leave(&outer)
+                    .leave(scope)
             });
 
             accumulated_changes.push(changes);

From ffffd018282393e373d6af2562f4a916f3722149 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Thu, 9 Apr 2026 13:48:24 -0400
Subject: [PATCH 12/13] Further tightening of traits

---
 .../examples/columnar/columnar_support.rs     |  4 ++--
 .../examples/columnar/main.rs                 |  6 ++---
 .../src/algorithms/graphs/bfs.rs              |  2 +-
 .../src/algorithms/graphs/bijkstra.rs         |  2 +-
 .../src/algorithms/graphs/propagate.rs        |  2 +-
 differential-dataflow/src/collection.rs       |  6 ++---
 .../src/operators/arrange/arrangement.rs      | 23 +++++++++----------
 .../src/operators/arrange/upsert.rs           |  3 +--
 differential-dataflow/src/operators/count.rs  |  2 +-
 differential-dataflow/src/operators/join.rs   |  2 +-
 differential-dataflow/src/operators/reduce.rs |  2 +-
 .../src/operators/threshold.rs                |  2 +-
 dogsdogsdogs/src/operators/half_join.rs       |  6 ++---
 dogsdogsdogs/src/operators/half_join2.rs      |  4 ++--
 14 files changed, 32 insertions(+), 34 deletions(-)

diff --git a/differential-dataflow/examples/columnar/columnar_support.rs b/differential-dataflow/examples/columnar/columnar_support.rs
index 7e997a003..03a260218 100644
--- a/differential-dataflow/examples/columnar/columnar_support.rs
+++ b/differential-dataflow/examples/columnar/columnar_support.rs
@@ -592,7 +592,7 @@ pub mod arrangement {
 
         impl<U: Update> Merger for TrieMerger<U>
         where
-            U::Time: Ord + PartialOrder + Clone + 'static,
+            U::Time: 'static,
         {
             type Chunk = Updates<U>;
             type Time = U::Time;
@@ -646,7 +646,7 @@ pub mod arrangement {
 
         impl<U: Update> TrieMerger<U>
         where
-            U::Time: Ord + PartialOrder + Clone + 'static,
+            U::Time: 'static,
         {
             /// Iterator-based merge: flatten, merge, consolidate, form.
             /// Correct but slow — used as fallback.
diff --git a/differential-dataflow/examples/columnar/main.rs b/differential-dataflow/examples/columnar/main.rs
index 1cbede8a1..a6a2b9ccd 100644
--- a/differential-dataflow/examples/columnar/main.rs
+++ b/differential-dataflow/examples/columnar/main.rs
@@ -127,13 +127,13 @@ mod reachability {
             let edges_pact = ValPact { hashfunc: |k: columnar::Ref<'_, Node>| *k as u64 };
             let reach_pact = ValPact { hashfunc: |k: columnar::Ref<'_, Node>| *k as u64 };
 
-            let edges_arr = arrange_core::<_, _,
+            let edges_arr = arrange_core::<_,
                 ValBatcher<Node, Node, IterTime, Diff>,
                 ValBuilder<Node, Node, IterTime, Diff>,
                 ValSpine<Node, Node, IterTime, Diff>,
             >(edges_inner.inner, edges_pact, "Edges");
 
-            let reach_arr = arrange_core::<_, _,
+            let reach_arr = arrange_core::<_,
                 ValBatcher<Node, (), IterTime, Diff>,
                 ValBuilder<Node, (), IterTime, Diff>,
                 ValSpine<Node, (), IterTime, Diff>,
@@ -157,7 +157,7 @@ mod reachability {
 
             // Arrange for reduce.
             let combined_pact = ValPact { hashfunc: |k: columnar::Ref<'_, Node>| *k as u64 };
-            let combined_arr = arrange_core::<_, _,
+            let combined_arr = arrange_core::<_,
                 ValBatcher<Node, (), IterTime, Diff>,
                 ValBuilder<Node, (), IterTime, Diff>,
                 ValSpine<Node, (), IterTime, Diff>,
diff --git a/differential-dataflow/src/algorithms/graphs/bfs.rs b/differential-dataflow/src/algorithms/graphs/bfs.rs
index f6676e94b..a9d5ed307 100644
--- a/differential-dataflow/src/algorithms/graphs/bfs.rs
+++ b/differential-dataflow/src/algorithms/graphs/bfs.rs
@@ -25,7 +25,7 @@ use crate::operators::arrange::Arranged;
 pub fn bfs_arranged<N, Tr>(edges: Arranged<Tr>, roots: VecCollection<Tr::Time, N>) -> VecCollection<Tr::Time, (N, u32)>
 where
     N: ExchangeData+Hash,
-    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Diff=isize, Time: Lattice + Ord>+Clone+'static,
+    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Diff=isize>+Clone+'static,
 {
     // initialize roots as reaching themselves at distance 0
     let nodes = roots.map(|x| (x, 0));
diff --git a/differential-dataflow/src/algorithms/graphs/bijkstra.rs b/differential-dataflow/src/algorithms/graphs/bijkstra.rs
index 4559944a1..82f47ecec 100644
--- a/differential-dataflow/src/algorithms/graphs/bijkstra.rs
+++ b/differential-dataflow/src/algorithms/graphs/bijkstra.rs
@@ -40,7 +40,7 @@ pub fn bidijkstra_arranged<N, Tr>(
 ) -> VecCollection<Tr::Time, ((N,N), u32)>
 where
     N: ExchangeData+Hash,
-    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Diff=isize, Time: Lattice + Ord>+Clone+'static,
+    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Diff=isize>+Clone+'static,
 {
     let outer = forward.stream.scope();
     outer.iterative::<u64,_,_>(|inner| {
diff --git a/differential-dataflow/src/algorithms/graphs/propagate.rs b/differential-dataflow/src/algorithms/graphs/propagate.rs
index c78bd6f92..54efb079d 100644
--- a/differential-dataflow/src/algorithms/graphs/propagate.rs
+++ b/differential-dataflow/src/algorithms/graphs/propagate.rs
@@ -58,7 +58,7 @@ where
     R: Multiply<R, Output=R>,
     R: From<i8>,
     L: ExchangeData,
-    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Diff=R, Time: Lattice + Ord + Hash>+Clone+'static,
+    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Diff=R, Time: Hash>+Clone+'static,
     F: Fn(&L)->u64+Clone+'static,
 {
     // Morally the code performs the following iterative computation. However, in the interest of a simplified
diff --git a/differential-dataflow/src/collection.rs b/differential-dataflow/src/collection.rs
index 17d2ebecb..45f3cabd7 100644
--- a/differential-dataflow/src/collection.rs
+++ b/differential-dataflow/src/collection.rs
@@ -217,7 +217,7 @@ impl<T: Timestamp, C: Container> Collection<T, C> {
     pub fn enter<TInner>(self, child: &Scope<TInner>) -> Collection<TInner, <C as containers::Enter<T, TInner>>::InnerContainer>
     where
         C: containers::Enter<T, TInner, InnerContainer: Container>,
-        TInner: Refines<T> + Timestamp,
+        TInner: Refines<T>,
     {
         use timely::dataflow::channels::pact::Pipeline;
         self.inner
@@ -1036,7 +1036,7 @@ pub mod vec {
             Tr: crate::trace::Trace<Time=T> + 'static,
         {
             let exchange = timely::dataflow::channels::pact::Exchange::new(move |update: &((K,V),T,R)| (update.0).0.hashed().into());
-            crate::operators::arrange::arrangement::arrange_core::<_, _, Ba, Bu, _>(self.inner, exchange, name)
+            crate::operators::arrange::arrangement::arrange_core::<_, Ba, Bu, _>(self.inner, exchange, name)
         }
     }
 
@@ -1051,7 +1051,7 @@ pub mod vec {
             Tr: crate::trace::Trace<Time=T> + 'static,
         {
             let exchange = timely::dataflow::channels::pact::Exchange::new(move |update: &((K,()),T,R)| (update.0).0.hashed().into());
-            crate::operators::arrange::arrangement::arrange_core::<_,_,Ba,Bu,_>(self.map(|k| (k, ())).inner, exchange, name)
+            crate::operators::arrange::arrangement::arrange_core::<_,Ba,Bu,_>(self.map(|k| (k, ())).inner, exchange, name)
         }
     }
 
diff --git a/differential-dataflow/src/operators/arrange/arrangement.rs b/differential-dataflow/src/operators/arrange/arrangement.rs
index b65efd839..4034bb9a1 100644
--- a/differential-dataflow/src/operators/arrange/arrangement.rs
+++ b/differential-dataflow/src/operators/arrange/arrangement.rs
@@ -86,7 +86,7 @@ where
     pub fn enter<TInner>(self, child: &Scope<TInner>)
         -> Arranged<TraceEnter<Tr, TInner>>
         where
-            TInner: Refines<Tr::Time>+Lattice+Timestamp+Clone,
+            TInner: Refines<Tr::Time>+Lattice,
     {
         Arranged {
             stream: self.stream.enter(child).map(|bw| BatchEnter::make_from(bw)),
@@ -113,7 +113,7 @@ where
     pub fn enter_at<TInner, F, P>(self, child: &Scope<TInner>, logic: F, prior: P)
         -> Arranged<TraceEnterAt<Tr, TInner, F, P>>
         where
-            TInner: Refines<Tr::Time>+Lattice+Timestamp+Clone+'static,
+            TInner: Refines<Tr::Time>+Lattice+'static,
             F: FnMut(Tr::Key<'_>, Tr::Val<'_>, Tr::TimeGat<'_>)->TInner+Clone+'static,
             P: FnMut(&TInner)->Tr::Time+Clone+'static,
         {
@@ -230,7 +230,7 @@ use crate::difference::Multiply;
 // Direct join implementations.
 impl<Tr1> Arranged<Tr1>
 where
-    Tr1: TraceReader<Time: Lattice> + Clone + 'static,
+    Tr1: TraceReader + Clone + 'static,
 {
     /// A convenience method to join and produce `VecCollection` output.
     ///
@@ -266,7 +266,7 @@ where
 use crate::difference::Abelian;
 impl<Tr1> Arranged<Tr1>
 where
-    Tr1: TraceReader<Time: Lattice> + Clone + 'static,
+    Tr1: TraceReader + Clone + 'static,
 {
     /// A direct implementation of `ReduceCore::reduce_abelian`.
     pub fn reduce_abelian<L, Bu, Tr2, P>(self, name: &str, mut logic: L, push: P) -> Arranged<TraceAgent<Tr2>>
@@ -355,13 +355,12 @@ where
 /// This operator arranges a stream of values into a shared trace, whose contents it maintains.
 /// It uses the supplied parallelization contract to distribute the data, which does not need to
 /// be consistently by key (though this is the most common).
-pub fn arrange_core<T, P, Ba, Bu, Tr>(stream: Stream<T, Ba::Input>, pact: P, name: &str) -> Arranged<TraceAgent<Tr>>
+pub fn arrange_core<P, Ba, Bu, Tr>(stream: Stream<Tr::Time, Ba::Input>, pact: P, name: &str) -> Arranged<TraceAgent<Tr>>
 where
-    T: Timestamp + Lattice,
-    P: ParallelizationContract<T, Ba::Input>,
-    Ba: Batcher<Time=T,Input: Container> + 'static,
-    Bu: Builder<Time=T, Input=Ba::Output, Output = Tr::Batch>,
-    Tr: Trace<Time=T>+'static,
+    P: ParallelizationContract<Tr::Time, Ba::Input>,
+    Ba: Batcher<Time=Tr::Time,Input: Container> + 'static,
+    Bu: Builder<Time=Tr::Time, Input=Ba::Output, Output = Tr::Batch>,
+    Tr: Trace+'static,
 {
     // The `Arrange` operator is tasked with reacting to an advancing input
     // frontier by producing the sequence of batches whose lower and upper
@@ -393,7 +392,7 @@ where
         let mut batcher = Ba::new(logger.clone(), info.global_id);
 
         // Capabilities for the lower envelope of updates in `batcher`.
-        let mut capabilities = Antichain::<Capability<T>>::new();
+        let mut capabilities = Antichain::<Capability<Tr::Time>>::new();
 
         let activator = Some(scope.activator_for(info.address.clone()));
         let mut empty_trace = Tr::new(info.clone(), logger.clone(), activator);
@@ -407,7 +406,7 @@ where
         *reader_ref = Some(reader_local);
 
         // Initialize to the minimal input frontier.
-        let mut prev_frontier = Antichain::from_elem(T::minimum());
+        let mut prev_frontier = Antichain::from_elem(Tr::Time::minimum());
 
         move |(input, frontier), output| {
 
diff --git a/differential-dataflow/src/operators/arrange/upsert.rs b/differential-dataflow/src/operators/arrange/upsert.rs
index 8534aa5d6..33b62a0e8 100644
--- a/differential-dataflow/src/operators/arrange/upsert.rs
+++ b/differential-dataflow/src/operators/arrange/upsert.rs
@@ -104,8 +104,7 @@ use timely::order::{PartialOrder, TotalOrder};
 use timely::dataflow::Stream;
 use timely::dataflow::operators::generic::Operator;
 use timely::dataflow::channels::pact::Exchange;
-use timely::progress::Timestamp;
-use timely::progress::Antichain;
+use timely::progress::{Antichain, Timestamp};
 use timely::dataflow::operators::Capability;
 use timely::scheduling::Scheduler;
 use timely::worker::AsWorker;
diff --git a/differential-dataflow/src/operators/count.rs b/differential-dataflow/src/operators/count.rs
index 23d7c7f84..8f4e7ad7a 100644
--- a/differential-dataflow/src/operators/count.rs
+++ b/differential-dataflow/src/operators/count.rs
@@ -57,7 +57,7 @@ where
     Tr: for<'a> TraceReader<
         Key<'a> = &'a K,
         Val<'a>=&'a (),
-        Time: TotalOrder + Lattice + Ord,
+        Time: TotalOrder,
         Diff: ExchangeData+Semigroup<Tr::DiffGat<'a>>
     >+Clone+'static,
     K: ExchangeData,
diff --git a/differential-dataflow/src/operators/join.rs b/differential-dataflow/src/operators/join.rs
index 31dfca368..7d514cfec 100644
--- a/differential-dataflow/src/operators/join.rs
+++ b/differential-dataflow/src/operators/join.rs
@@ -69,7 +69,7 @@ impl<CB: PushInto<D>, D> PushInto<D> for EffortBuilder<CB> {
 /// [`AsCollection`]: crate::collection::AsCollection
 pub fn join_traces<Tr1, Tr2, L, CB>(arranged1: Arranged<Tr1>, arranged2: Arranged<Tr2>, mut result: L) -> Stream<Tr1::Time, CB::Container>
 where
-    Tr1: TraceReader<Time: Lattice>+Clone+'static,
+    Tr1: TraceReader+Clone+'static,
     Tr2: for<'a> TraceReader<Key<'a>=Tr1::Key<'a>, Time = Tr1::Time>+Clone+'static,
     L: FnMut(Tr1::Key<'_>,Tr1::Val<'_>,Tr2::Val<'_>,&Tr1::Time,&Tr1::Diff,&Tr2::Diff,&mut JoinSession<Tr1::Time, CB, Capability<Tr1::Time>>)+'static,
     CB: ContainerBuilder,
diff --git a/differential-dataflow/src/operators/reduce.rs b/differential-dataflow/src/operators/reduce.rs
index ec83cfade..4fcaefd08 100644
--- a/differential-dataflow/src/operators/reduce.rs
+++ b/differential-dataflow/src/operators/reduce.rs
@@ -35,7 +35,7 @@ use crate::trace::TraceReader;
 /// key's computation to another, and will likely introduce non-determinism.
 pub fn reduce_trace<Tr1, Bu, Tr2, L, P>(trace: Arranged<Tr1>, name: &str, mut logic: L, mut push: P) -> Arranged<TraceAgent<Tr2>>
 where
-    Tr1: TraceReader<Time: crate::lattice::Lattice> + Clone + 'static,
+    Tr1: TraceReader + Clone + 'static,
     Tr2: for<'a> Trace<Key<'a>=Tr1::Key<'a>, ValOwn: Data, Time = Tr1::Time> + 'static,
     Bu: Builder<Time=Tr2::Time, Output = Tr2::Batch, Input: Default>,
     L: FnMut(Tr1::Key<'_>, &[(Tr1::Val<'_>, Tr1::Diff)], &mut Vec<(Tr2::ValOwn,Tr2::Diff)>, &mut Vec<(Tr2::ValOwn, Tr2::Diff)>)+'static,
diff --git a/differential-dataflow/src/operators/threshold.rs b/differential-dataflow/src/operators/threshold.rs
index 9e259330f..22dfec32b 100644
--- a/differential-dataflow/src/operators/threshold.rs
+++ b/differential-dataflow/src/operators/threshold.rs
@@ -103,7 +103,7 @@ where
     Tr: for<'a> TraceReader<
         Key<'a>=&'a K,
         Val<'a>=&'a (),
-        Time: TotalOrder + Lattice + Ord,
+        Time: TotalOrder,
         Diff : ExchangeData + Semigroup<Tr::DiffGat<'a>>,
     >+Clone+'static,
     K: ExchangeData,
diff --git a/dogsdogsdogs/src/operators/half_join.rs b/dogsdogsdogs/src/operators/half_join.rs
index 80f7153b2..7de73db3f 100644
--- a/dogsdogsdogs/src/operators/half_join.rs
+++ b/dogsdogsdogs/src/operators/half_join.rs
@@ -86,7 +86,7 @@ where
     K: Hashable + ExchangeData,
     V: ExchangeData,
     R: ExchangeData + Monoid,
-    Tr: TraceReader<Time: Lattice + std::hash::Hash>+Clone+'static,
+    Tr: TraceReader<Time: std::hash::Hash>+Clone+'static,
     Tr::KeyContainer: BatchContainer<Owned=K>,
     R: Mul<Tr::Diff, Output: Semigroup>,
     FF: Fn(&Tr::Time, &mut Antichain<Tr::Time>) + 'static,
@@ -152,7 +152,7 @@ where
     K: Hashable + ExchangeData,
     V: ExchangeData,
     R: ExchangeData + Monoid,
-    Tr: TraceReader<Time: Lattice + std::hash::Hash>+Clone+'static,
+    Tr: TraceReader<Time: std::hash::Hash>+Clone+'static,
     Tr::KeyContainer: BatchContainer<Owned=K>,
     FF: Fn(&Tr::Time, &mut Antichain<Tr::Time>) + 'static,
     CF: Fn(Tr::TimeGat<'_>, &Tr::Time) -> bool + 'static,
@@ -312,7 +312,7 @@ fn process_proposals<Tr, CF, Y, S, CB, K, V, R>(
     frontier: AntichainRef<Tr::Time>
 ) -> bool
 where
-    Tr: TraceReader<Time: Lattice>,
+    Tr: TraceReader,
     Tr::KeyContainer: BatchContainer<Owned=K>,
     CF: Fn(Tr::TimeGat<'_>, &Tr::Time) -> bool + 'static,
     Y: Fn(Instant, usize) -> bool + 'static,
diff --git a/dogsdogsdogs/src/operators/half_join2.rs b/dogsdogsdogs/src/operators/half_join2.rs
index b6302b2eb..6b19c0bbd 100644
--- a/dogsdogsdogs/src/operators/half_join2.rs
+++ b/dogsdogsdogs/src/operators/half_join2.rs
@@ -73,7 +73,7 @@ where
     K: Hashable + ExchangeData,
     V: ExchangeData,
     R: ExchangeData + Monoid,
-    Tr: TraceReader<Time: Lattice + std::hash::Hash>+Clone+'static,
+    Tr: TraceReader<Time: std::hash::Hash>+Clone+'static,
     Tr::KeyContainer: BatchContainer<Owned=K>,
     R: Mul<Tr::Diff, Output: Semigroup>,
     FF: Fn(&Tr::Time, &mut Antichain<Tr::Time>) + 'static,
@@ -130,7 +130,7 @@ where
     K: Hashable + ExchangeData,
     V: ExchangeData,
     R: ExchangeData + Monoid,
-    Tr: TraceReader<Time: Lattice + std::hash::Hash>+Clone+'static,
+    Tr: TraceReader<Time: std::hash::Hash>+Clone+'static,
     Tr::KeyContainer: BatchContainer<Owned=K>,
     FF: Fn(&Tr::Time, &mut Antichain<Tr::Time>) + 'static,
     CF: Fn(Tr::TimeGat<'_>, &Tr::Time) -> bool + 'static,

From 36557d9b5692c7014169cfdf660ea27fae2e9d80 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Thu, 9 Apr 2026 14:36:34 -0400
Subject: [PATCH 13/13] Correct docs

---
 differential-dataflow/src/collection.rs | 11 ++++++-----
 dogsdogsdogs/src/operators/half_join.rs |  2 +-
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/differential-dataflow/src/collection.rs b/differential-dataflow/src/collection.rs
index 45f3cabd7..d33463863 100644
--- a/differential-dataflow/src/collection.rs
+++ b/differential-dataflow/src/collection.rs
@@ -342,10 +342,11 @@ pub mod vec {
     /// propagate changes through your functional computation and report the corresponding changes to the
     /// output collections.
     ///
-    /// Each vec collection has three generic parameters. The parameter `T` is for the scope in which the
-    /// collection exists; as you write more complicated programs you may wish to introduce nested scopes
-    /// (e.g. for iteration) and this parameter tracks the scope (for timely dataflow's benefit). The `D`
-    /// parameter is the type of data in your collection, for example `String`, or `(u32, Vec<Option<()>>)`.
+    /// Each vec collection has three generic parameters. The parameter `T` is the timestamp type of the
+    /// scope in which the collection exists; as you write more complicated programs you may wish to
+    /// introduce nested scopes (e.g. for iteration), and this parameter tracks the scope's timestamp
+    /// (for timely dataflow's benefit). The `D` parameter is the type of data in your collection, for
+    /// example `String`, or `(u32, Vec<Option<()>>)`.
     /// The `R` parameter represents the types of changes that the data undergo, and is most commonly (and
     /// defaults to) `isize`, representing changes to the occurrence count of each record.
     ///
@@ -1219,7 +1220,7 @@ pub mod vec {
         /// which produces something implementing `IntoIterator`, where the output collection will have an entry for
         /// every value returned by the iterator.
         ///
-        /// This trait is implemented for arrangements (`Arranged<T, T>`) rather than collections. The `Join` trait
+        /// This trait is implemented for arrangements (`Arranged<Tr>`) rather than collections. The `Join` trait
         /// contains the implementations for collections.
         ///
         /// # Examples
diff --git a/dogsdogsdogs/src/operators/half_join.rs b/dogsdogsdogs/src/operators/half_join.rs
index 7de73db3f..8bedb4cbf 100644
--- a/dogsdogsdogs/src/operators/half_join.rs
+++ b/dogsdogsdogs/src/operators/half_join.rs
@@ -105,7 +105,7 @@ where
         .as_collection()
 }
 
-/// A session with lifetime `'a` in a scope `T` with a container builder `CB`.
+/// A session with lifetime `'a` over timestamp `T` with a container builder `CB`.
 ///
 /// This is a shorthand primarily for the reson of readability.
 type SessionFor<'a, 'b, T, CB> =