diff --git a/dogsdogsdogs/src/operators/count.rs b/dogsdogsdogs/src/operators/count.rs
index bae14c7b3..bb75f26a9 100644
--- a/dogsdogsdogs/src/operators/count.rs
+++ b/dogsdogsdogs/src/operators/count.rs
@@ -4,7 +4,7 @@ use differential_dataflow::{ExchangeData, Collection, Hashable};
 use differential_dataflow::difference::{Monoid, Multiply};
 use differential_dataflow::lattice::Lattice;
 use differential_dataflow::operators::arrange::Arranged;
-use differential_dataflow::trace::{Cursor, TraceReader, BatchReader};
+use differential_dataflow::trace::{Cursor, TraceReader};
 
 /// Reports a number of extensions to a stream of prefixes.
 ///
@@ -23,7 +23,6 @@ where
     G::Timestamp: Lattice,
     Tr: TraceReader<Val=(), Time=G::Timestamp, R=isize>+Clone+'static,
     Tr::Key: Ord+Hashable+Default,
-    Tr::Batch: BatchReader<Tr::Key, (), Tr::Time, Tr::R>,
     Tr::Cursor: Cursor<Tr::Key, (), Tr::Time, Tr::R>,
     R: Monoid+Multiply<Output = R>+ExchangeData,
     F: Fn(&P)->Tr::Key+Clone+'static,
diff --git a/dogsdogsdogs/src/operators/half_join.rs b/dogsdogsdogs/src/operators/half_join.rs
index 8f6f4d0cf..482bbb570 100644
--- a/dogsdogsdogs/src/operators/half_join.rs
+++ b/dogsdogsdogs/src/operators/half_join.rs
@@ -42,7 +42,7 @@ use differential_dataflow::{ExchangeData, Collection, AsCollection, Hashable};
 use differential_dataflow::difference::{Monoid, Semigroup};
 use differential_dataflow::lattice::Lattice;
 use differential_dataflow::operators::arrange::Arranged;
-use differential_dataflow::trace::{Cursor, TraceReader, BatchReader};
+use differential_dataflow::trace::{Cursor, TraceReader};
 use differential_dataflow::consolidation::{consolidate, consolidate_updates};
 
 /// A binary equijoin that responds to updates on only its first input.
@@ -81,7 +81,6 @@ where
     Tr: TraceReader<Time=G::Timestamp>+Clone+'static,
     Tr::Key: Ord+Hashable+ExchangeData,
     Tr::Val: Clone,
-    Tr::Batch: BatchReader<Tr::Key, Tr::Val, Tr::Time, Tr::R>,
     Tr::Cursor: Cursor<Tr::Key, Tr::Val, Tr::Time, Tr::R>,
     Tr::R: Monoid+ExchangeData,
     FF: Fn(&G::Timestamp) -> G::Timestamp + 'static,
@@ -137,7 +136,6 @@ where
     Tr: TraceReader<Time=G::Timestamp>+Clone+'static,
     Tr::Key: Ord+Hashable+ExchangeData,
     Tr::Val: Clone,
-    Tr::Batch: BatchReader<Tr::Key, Tr::Val, Tr::Time, Tr::R>,
     Tr::Cursor: Cursor<Tr::Key, Tr::Val, Tr::Time, Tr::R>,
     Tr::R: Monoid+ExchangeData,
     FF: Fn(&G::Timestamp) -> G::Timestamp + 'static,
diff --git a/dogsdogsdogs/src/operators/lookup_map.rs b/dogsdogsdogs/src/operators/lookup_map.rs
index 671e24921..081f17bc4 100644
--- a/dogsdogsdogs/src/operators/lookup_map.rs
+++ b/dogsdogsdogs/src/operators/lookup_map.rs
@@ -10,7 +10,7 @@ use differential_dataflow::{ExchangeData, Collection, AsCollection, Hashable};
 use differential_dataflow::difference::{Semigroup, Monoid};
 use differential_dataflow::lattice::Lattice;
 use differential_dataflow::operators::arrange::Arranged;
-use differential_dataflow::trace::{Cursor, TraceReader, BatchReader};
+use differential_dataflow::trace::{Cursor, TraceReader};
 
 /// Proposes extensions to a stream of prefixes.
 ///
@@ -32,7 +32,6 @@ where
     Tr: TraceReader<Time=G::Timestamp>+Clone+'static,
     Tr::Key: Ord+Hashable,
     Tr::Val: Clone,
-    Tr::Batch: BatchReader<Tr::Key, Tr::Val, Tr::Time, Tr::R>,
     Tr::Cursor: Cursor<Tr::Key, Tr::Val, Tr::Time, Tr::R>,
     Tr::R: Monoid+ExchangeData,
     F: FnMut(&D, &mut Tr::Key)+Clone+'static,
diff --git a/dogsdogsdogs/src/operators/propose.rs b/dogsdogsdogs/src/operators/propose.rs
index cf7e793c8..105bcc340 100644
--- a/dogsdogsdogs/src/operators/propose.rs
+++ b/dogsdogsdogs/src/operators/propose.rs
@@ -4,7 +4,7 @@ use differential_dataflow::{ExchangeData, Collection, Hashable};
 use differential_dataflow::difference::{Monoid, Multiply};
 use differential_dataflow::lattice::Lattice;
 use differential_dataflow::operators::arrange::Arranged;
-use differential_dataflow::trace::{Cursor, TraceReader, BatchReader};
+use differential_dataflow::trace::{Cursor, TraceReader};
 
 /// Proposes extensions to a prefix stream.
 ///
@@ -25,7 +25,6 @@ where
     Tr: TraceReader<Time=G::Timestamp>+Clone+'static,
     Tr::Key: Ord+Hashable+Default,
     Tr::Val: Clone,
-    Tr::Batch: BatchReader<Tr::Key, Tr::Val, Tr::Time, Tr::R>,
     Tr::Cursor: Cursor<Tr::Key, Tr::Val, Tr::Time, Tr::R>,
     Tr::R: Monoid+Multiply<Output = Tr::R>+ExchangeData,
     F: Fn(&P)->Tr::Key+Clone+'static,
@@ -58,7 +57,6 @@ where
     Tr: TraceReader<Time=G::Timestamp>+Clone+'static,
     Tr::Key: Ord+Hashable+Default,
     Tr::Val: Clone,
-    Tr::Batch: BatchReader<Tr::Key, Tr::Val, Tr::Time, Tr::R>,
     Tr::Cursor: Cursor<Tr::Key, Tr::Val, Tr::Time, Tr::R>,
     Tr::R: Monoid+Multiply<Output = Tr::R>+ExchangeData,
     F: Fn(&P)->Tr::Key+Clone+'static,
diff --git a/dogsdogsdogs/src/operators/validate.rs b/dogsdogsdogs/src/operators/validate.rs
index 7152f1876..3ef2f1d63 100644
--- a/dogsdogsdogs/src/operators/validate.rs
+++ b/dogsdogsdogs/src/operators/validate.rs
@@ -6,7 +6,7 @@ use differential_dataflow::{ExchangeData, Collection};
 use differential_dataflow::difference::{Monoid, Multiply};
 use differential_dataflow::lattice::Lattice;
 use differential_dataflow::operators::arrange::Arranged;
-use differential_dataflow::trace::{Cursor, TraceReader, BatchReader};
+use differential_dataflow::trace::{Cursor, TraceReader};
 
 /// Proposes extensions to a stream of prefixes.
 ///
@@ -24,7 +24,6 @@ where
     Tr: TraceReader<Key=(K,V), Val=(), Time=G::Timestamp>+Clone+'static,
     K: Ord+Hash+Clone+Default,
     V: ExchangeData+Hash+Default,
-    Tr::Batch: BatchReader<Tr::Key, Tr::Val, Tr::Time, Tr::R>,
     Tr::Cursor: Cursor<Tr::Key, Tr::Val, Tr::Time, Tr::R>,
     Tr::R: Monoid+Multiply<Output = Tr::R>+ExchangeData,
     F: Fn(&P)->K+Clone+'static,
diff --git a/src/algorithms/graphs/bfs.rs b/src/algorithms/graphs/bfs.rs
index 2931922a8..6e1a0a5f1 100644
--- a/src/algorithms/graphs/bfs.rs
+++ b/src/algorithms/graphs/bfs.rs
@@ -30,7 +30,6 @@ where
     G::Timestamp: Lattice+Ord,
     N: ExchangeData+Hash,
     Tr: TraceReader<Key=N, Val=N, Time=G::Timestamp, R=isize>+Clone+'static,
-    Tr::Batch: crate::trace::BatchReader<N, N, G::Timestamp, Tr::R>+'static,
     Tr::Cursor: crate::trace::Cursor<N, N, G::Timestamp, Tr::R>+'static,
 {
     // initialize roots as reaching themselves at distance 0
@@ -46,4 +45,4 @@ where
              .concat(&nodes)
              .reduce(|_, s, t| t.push((s[0].0.clone(), 1)))
      })
-}
\ No newline at end of file
+}
diff --git a/src/algorithms/graphs/bijkstra.rs b/src/algorithms/graphs/bijkstra.rs
index 91e02dbde..54dea878e 100644
--- a/src/algorithms/graphs/bijkstra.rs
+++ b/src/algorithms/graphs/bijkstra.rs
@@ -46,7 +46,6 @@ where
     G::Timestamp: Lattice+Ord,
     N: ExchangeData+Hash,
     Tr: TraceReader<Key=N, Val=N, Time=G::Timestamp, R=isize>+Clone+'static,
-    Tr::Batch: crate::trace::BatchReader<N, N, G::Timestamp, Tr::R>+'static,
     Tr::Cursor: crate::trace::Cursor<N, N, G::Timestamp, Tr::R>+'static,
 {
     forward
diff --git a/src/algorithms/graphs/propagate.rs b/src/algorithms/graphs/propagate.rs
index c94e49814..71eed8c9d 100644
--- a/src/algorithms/graphs/propagate.rs
+++ b/src/algorithms/graphs/propagate.rs
@@ -65,7 +65,6 @@ where
     R: From<i8>,
     L: ExchangeData,
     Tr: TraceReader<Key=N, Val=N, Time=G::Timestamp, R=R>+Clone+'static,
-    Tr::Batch: crate::trace::BatchReader<N, N, G::Timestamp, Tr::R>+'static,
     Tr::Cursor: crate::trace::Cursor<N, N, G::Timestamp, Tr::R>+'static,
     F: Fn(&L)->u64+Clone+'static,
 {
diff --git a/src/operators/arrange/agent.rs b/src/operators/arrange/agent.rs
index 13c3b02cd..8f5a469ef 100644
--- a/src/operators/arrange/agent.rs
+++ b/src/operators/arrange/agent.rs
@@ -92,7 +92,7 @@ where
     pub fn new(trace: Tr, operator: ::timely::dataflow::operators::generic::OperatorInfo, logging: Option<::logging::Logger>) -> (Self, TraceWriter<Tr>)
     where
         Tr: Trace,
-        Tr::Batch: Batch<Tr::Key,Tr::Val,Tr::Time,Tr::R>,
+        Tr::Batch: Batch,
     {
         let trace = Rc::new(RefCell::new(TraceBox::new(trace)));
         let queues = Rc::new(RefCell::new(Vec::new()));
diff --git a/src/operators/arrange/arrangement.rs b/src/operators/arrange/arrangement.rs
index 09a48e248..d291fae35 100644
--- a/src/operators/arrange/arrangement.rs
+++ b/src/operators/arrange/arrangement.rs
@@ -65,7 +65,6 @@ impl<G: Scope, Tr> Clone for Arranged<G, Tr>
 where
     G::Timestamp: Lattice+Ord,
     Tr: TraceReader<Time=G::Timestamp> + Clone,
-    Tr::Batch: BatchReader<Tr::Key, Tr::Val, G::Timestamp, Tr::R>,
     Tr::Cursor: Cursor<Tr::Key, Tr::Val, G::Timestamp, Tr::R>,
 {
     fn clone(&self) -> Self {
@@ -83,7 +82,6 @@ impl<G: Scope, Tr> Arranged<G, Tr>
 where
     G::Timestamp: Lattice+Ord,
     Tr: TraceReader<Time=G::Timestamp> + Clone,
-    Tr::Batch: BatchReader<Tr::Key, Tr::Val, G::Timestamp, Tr::R>,
     Tr::Cursor: Cursor<Tr::Key, Tr::Val, G::Timestamp, Tr::R>,
 {
     /// Brings an arranged collection into a nested scope.
@@ -425,7 +423,6 @@ impl<'a, G: Scope, Tr> Arranged<Child<'a, G, G::Timestamp>, Tr>
 where
     G::Timestamp: Lattice+Ord,
     Tr: TraceReader<Time=G::Timestamp> + Clone,
-    Tr::Batch: BatchReader<Tr::Key, Tr::Val, G::Timestamp, Tr::R>,
     Tr::Cursor: Cursor<Tr::Key, Tr::Val, G::Timestamp, Tr::R>,
 {
     /// Brings an arranged collection out of a nested region.
@@ -462,7 +459,7 @@ where
         V: ExchangeData,
         R: ExchangeData,
         Tr: Trace+TraceReader<Key=K,Val=V,Time=G::Timestamp,R=R>+'static,
-        Tr::Batch: Batch<K, V, G::Timestamp, R>,
+        Tr::Batch: Batch,
         Tr::Cursor: Cursor<K, V, G::Timestamp, R>,
     {
         self.arrange_named("Arrange")
@@ -479,7 +476,7 @@ where
         V: ExchangeData,
         R: ExchangeData,
         Tr: Trace+TraceReader<Key=K,Val=V,Time=G::Timestamp,R=R>+'static,
-        Tr::Batch: Batch<K, V, G::Timestamp, R>,
+        Tr::Batch: Batch,
         Tr::Cursor: Cursor<K, V, G::Timestamp, R>,
     {
         let exchange = Exchange::new(move |update: &((K,V),G::Timestamp,R)| (update.0).0.hashed().into());
@@ -495,7 +492,7 @@ where
     where
         P: ParallelizationContract<G::Timestamp, ((K,V),G::Timestamp,R)>,
         Tr: Trace+TraceReader<Key=K,Val=V,Time=G::Timestamp,R=R>+'static,
-        Tr::Batch: Batch<K, V, G::Timestamp, R>,
+        Tr::Batch: Batch,
         Tr::Cursor: Cursor<K, V, G::Timestamp, R>,
     ;
 }
@@ -512,7 +509,7 @@ where
     where
         P: ParallelizationContract<G::Timestamp, ((K,V),G::Timestamp,R)>,
         Tr: Trace+TraceReader<Key=K,Val=V,Time=G::Timestamp,R=R>+'static,
-        Tr::Batch: Batch<K, V, G::Timestamp, R>,
+        Tr::Batch: Batch,
         Tr::Cursor: Cursor<K, V, G::Timestamp, R>,
     {
         // The `Arrange` operator is tasked with reacting to an advancing input
@@ -547,7 +544,7 @@ where
                 };
 
                 // Where we will deposit received updates, and from which we extract batches.
-                let mut batcher = <Tr::Batch as Batch<K,V,G::Timestamp,R>>::Batcher::new();
+                let mut batcher = <Tr::Batch as Batch>::Batcher::new();
 
                 // Capabilities for the lower envelope of updates in `batcher`.
                 let mut capabilities = Antichain::<Capability<G::Timestamp>>::new();
@@ -684,7 +681,7 @@ where
     where
         P: ParallelizationContract<G::Timestamp, ((K,()),G::Timestamp,R)>,
         Tr: Trace+TraceReader<Key=K, Val=(), Time=G::Timestamp, R=R>+'static,
-        Tr::Batch: Batch<K, (), G::Timestamp, R>,
+        Tr::Batch: Batch,
         Tr::Cursor: Cursor<K, (), G::Timestamp, R>,
     {
         self.map(|k| (k, ()))
diff --git a/src/operators/arrange/upsert.rs b/src/operators/arrange/upsert.rs
index 978d9596f..6a7aa6ba3 100644
--- a/src/operators/arrange/upsert.rs
+++ b/src/operators/arrange/upsert.rs
@@ -145,7 +145,7 @@ where
     Tr::Key: ExchangeData+Hashable+std::hash::Hash,
     Tr::Val: ExchangeData,
     Tr: Trace+TraceReader<Time=G::Timestamp,R=isize>+'static,
-    Tr::Batch: Batch<Tr::Key, Tr::Val, G::Timestamp, isize>,
+    Tr::Batch: Batch,
     Tr::Cursor: Cursor<Tr::Key, Tr::Val, G::Timestamp, isize>,
 {
     let mut reader: Option<TraceAgent<Tr>> = None;
@@ -252,7 +252,7 @@ where
                                 // Prepare a cursor to the existing arrangement, and a batch builder for
                                 // new stuff that we add.
                                 let (mut trace_cursor, trace_storage) = reader_local.cursor();
-                                let mut builder = <Tr::Batch as Batch<Tr::Key,Tr::Val,G::Timestamp,Tr::R>>::Builder::new();
+                                let mut builder = <Tr::Batch as Batch>::Builder::new();
                                 for (key, mut list) in to_process.drain(..) {
 
                                     // The prior value associated with the key.
diff --git a/src/operators/arrange/writer.rs b/src/operators/arrange/writer.rs
index b6c4c5710..a42924b75 100644
--- a/src/operators/arrange/writer.rs
+++ b/src/operators/arrange/writer.rs
@@ -23,7 +23,7 @@ pub struct TraceWriter<Tr>
 where
     Tr: Trace,
     Tr::Time: Lattice+Timestamp+Ord+Clone+std::fmt::Debug+'static,
-    Tr::Batch: Batch<Tr::Key,Tr::Val,Tr::Time,Tr::R>,
+    Tr::Batch: Batch,
 {
     /// Current upper limit.
     upper: Antichain<Tr::Time>,
@@ -37,7 +37,7 @@ impl<Tr> TraceWriter<Tr>
 where
     Tr: Trace,
     Tr::Time: Lattice+Timestamp+Ord+Clone+std::fmt::Debug+'static,
-    Tr::Batch: Batch<Tr::Key,Tr::Val,Tr::Time,Tr::R>,
+    Tr::Batch: Batch,
 {
     /// Creates a new `TraceWriter`.
     pub fn new(
@@ -96,7 +96,7 @@ where
     pub fn seal(&mut self, upper: Antichain<Tr::Time>) {
         if self.upper != upper {
             use trace::Builder;
-            let builder = <Tr::Batch as Batch<Tr::Key,Tr::Val,Tr::Time,Tr::R>>::Builder::new();
+            let builder = <Tr::Batch as Batch>::Builder::new();
             let batch = builder.done(self.upper.clone(), upper, Antichain::from_elem(Tr::Time::minimum()));
             self.insert(batch, None);
         }
@@ -107,7 +107,7 @@ impl<Tr> Drop for TraceWriter<Tr>
 where
     Tr: Trace,
     Tr::Time: Lattice+Timestamp+Ord+Clone+std::fmt::Debug+'static,
-    Tr::Batch: Batch<Tr::Key,Tr::Val,Tr::Time,Tr::R>,
+    Tr::Batch: Batch,
 {
     fn drop(&mut self) {
         self.seal(Antichain::new())
diff --git a/src/operators/count.rs b/src/operators/count.rs
index f119d648e..6b6a6bf4e 100644
--- a/src/operators/count.rs
+++ b/src/operators/count.rs
@@ -74,7 +74,6 @@ where
     T1: TraceReader<Val=(), Time=G::Timestamp>+Clone+'static,
     T1::Key: ExchangeData,
     T1::R: ExchangeData+Semigroup,
-    T1::Batch: BatchReader<T1::Key, (), G::Timestamp, T1::R>,
     T1::Cursor: Cursor<T1::Key, (), G::Timestamp, T1::R>,
 {
     fn count_total_core<R2: Semigroup + From<i8>>(&self) -> Collection<G, (T1::Key, T1::R), R2> {
diff --git a/src/operators/join.rs b/src/operators/join.rs
index ea72b32f6..67a6b21d5 100644
--- a/src/operators/join.rs
+++ b/src/operators/join.rs
@@ -190,7 +190,6 @@ where
     Tr::Key: Data+Hashable,
     Tr::Val: Data,
     Tr::R: Semigroup,
-    Tr::Batch: BatchReader<Tr::Key,Tr::Val,G::Timestamp,Tr::R>+'static,
     Tr::Cursor: Cursor<Tr::Key,Tr::Val,G::Timestamp,Tr::R>+'static,
 {
     fn join_map<V2: ExchangeData, R2: ExchangeData+Semigroup, D: Data, L>(&self, other: &Collection<G, (Tr::Key, V2), R2>, mut logic: L) -> Collection<G, D, <Tr::R as Multiply<R2>>::Output>
@@ -258,7 +257,6 @@ pub trait JoinCore<G: Scope, K: 'static, V: 'static, R: Semigroup> where G::Time
     fn join_core<Tr2,I,L> (&self, stream2: &Arranged<G,Tr2>, result: L) -> Collection<G,I::Item,<R as Multiply<Tr2::R>>::Output>
     where
         Tr2: TraceReader<Key=K, Time=G::Timestamp>+Clone+'static,
-        Tr2::Batch: BatchReader<K, Tr2::Val, G::Timestamp, Tr2::R>+'static,
         Tr2::Cursor: Cursor<K, Tr2::Val, G::Timestamp, Tr2::R>+'static,
         Tr2::Val: Ord+Clone+Debug+'static,
         Tr2::R: Semigroup,
@@ -311,7 +309,6 @@ pub trait JoinCore<G: Scope, K: 'static, V: 'static, R: Semigroup> where G::Time
     fn join_core_internal_unsafe<Tr2,I,L,D,ROut> (&self, stream2: &Arranged<G,Tr2>, result: L) -> Collection<G,D,ROut>
     where
         Tr2: TraceReader<Key=K, Time=G::Timestamp>+Clone+'static,
-        Tr2::Batch: BatchReader<K, Tr2::Val, G::Timestamp, Tr2::R>+'static,
         Tr2::Cursor: Cursor<K, Tr2::Val, G::Timestamp, Tr2::R>+'static,
         Tr2::Val: Ord+Clone+Debug+'static,
         Tr2::R: Semigroup,
@@ -334,7 +331,6 @@ where
     fn join_core<Tr2,I,L> (&self, stream2: &Arranged<G,Tr2>, result: L) -> Collection<G,I::Item,<R as Multiply<Tr2::R>>::Output>
     where
         Tr2: TraceReader<Key=K, Time=G::Timestamp>+Clone+'static,
-        Tr2::Batch: BatchReader<K, Tr2::Val, G::Timestamp, Tr2::R>+'static,
         Tr2::Cursor: Cursor<K, Tr2::Val, G::Timestamp, Tr2::R>+'static,
         Tr2::Val: Ord+Clone+Debug+'static,
         Tr2::R: Semigroup,
@@ -351,7 +347,6 @@ where
     fn join_core_internal_unsafe<Tr2,I,L,D,ROut> (&self, stream2: &Arranged<G,Tr2>, result: L) -> Collection<G,D,ROut>
     where
         Tr2: TraceReader<Key=K, Time=G::Timestamp>+Clone+'static,
-        Tr2::Batch: BatchReader<K, Tr2::Val, G::Timestamp, Tr2::R>+'static,
         Tr2::Cursor: Cursor<K, Tr2::Val, G::Timestamp, Tr2::R>+'static,
         Tr2::Val: Ord+Clone+Debug+'static,
         Tr2::R: Semigroup,
@@ -374,14 +369,12 @@ impl<G, T1> JoinCore<G, T1::Key, T1::Val, T1::R> for Arranged<G,T1>
         T1::Key: Ord+Debug+'static,
         T1::Val: Ord+Clone+Debug+'static,
         T1::R: Semigroup,
-        T1::Batch: BatchReader<T1::Key,T1::Val,G::Timestamp,T1::R>+'static,
         T1::Cursor: Cursor<T1::Key,T1::Val,G::Timestamp,T1::R>+'static,
 {
     fn join_core<Tr2,I,L>(&self, other: &Arranged<G,Tr2>, mut result: L) -> Collection<G,I::Item,<T1::R as Multiply<Tr2::R>>::Output>
     where
         Tr2::Val: Ord+Clone+Debug+'static,
         Tr2: TraceReader<Key=T1::Key,Time=G::Timestamp>+Clone+'static,
-        Tr2::Batch: BatchReader<T1::Key, Tr2::Val, G::Timestamp, Tr2::R>+'static,
         Tr2::Cursor: Cursor<T1::Key, Tr2::Val, G::Timestamp, Tr2::R>+'static,
         Tr2::R: Semigroup,
         T1::R: Multiply<Tr2::R>,
@@ -401,7 +394,6 @@ impl<G, T1> JoinCore<G, T1::Key, T1::Val, T1::R> for Arranged<G,T1>
     fn join_core_internal_unsafe<Tr2,I,L,D,ROut> (&self, other: &Arranged<G,Tr2>, mut result: L) -> Collection<G,D,ROut>
     where
         Tr2: TraceReader<Key=T1::Key, Time=G::Timestamp>+Clone+'static,
-        Tr2::Batch: BatchReader<T1::Key, Tr2::Val, G::Timestamp, Tr2::R>+'static,
         Tr2::Cursor: Cursor<T1::Key, Tr2::Val, G::Timestamp, Tr2::R>+'static,
         Tr2::Val: Ord+Clone+Debug+'static,
         Tr2::R: Semigroup,
diff --git a/src/operators/reduce.rs b/src/operators/reduce.rs
index f8d9edeb1..a2e8d58cc 100644
--- a/src/operators/reduce.rs
+++ b/src/operators/reduce.rs
@@ -90,7 +90,6 @@ impl<G: Scope, K: Data, V: Data, T1, R: Semigroup> Reduce<G, K, V, R> for Arrang
 where
     G::Timestamp: Lattice+Ord,
     T1: TraceReader<Key=K, Val=V, Time=G::Timestamp, R=R>+Clone+'static,
-    T1::Batch: BatchReader<K, V, G::Timestamp, R>,
     T1::Cursor: Cursor<K, V, G::Timestamp, R>,
 {
     fn reduce_named<L, V2: Data, R2: Abelian>(&self, name: &str, logic: L) -> Collection<G, (K, V2), R2>
@@ -179,7 +178,6 @@ impl<G: Scope, K: Data, T1, R1: Semigroup> Threshold<G, K, R1> for Arranged<G, T
 where
     G::Timestamp: Lattice+Ord,
     T1: TraceReader<Key=K, Val=(), Time=G::Timestamp, R=R1>+Clone+'static,
-    T1::Batch: BatchReader<K, (), G::Timestamp, R1>,
     T1::Cursor: Cursor<K, (), G::Timestamp, R1>,
 {
     fn threshold_named<R2: Abelian, F: FnMut(&K,&R1)->R2+'static>(&self, name: &str, mut thresh: F) -> Collection<G, K, R2> {
@@ -236,7 +234,6 @@ impl<G: Scope, K: Data, T1, R: Semigroup> Count<G, K, R> for Arranged<G, T1>
 where
     G::Timestamp: Lattice+Ord,
     T1: TraceReader<Key=K, Val=(), Time=G::Timestamp, R=R>+Clone+'static,
-    T1::Batch: BatchReader<K, (), G::Timestamp, R>,
     T1::Cursor: Cursor<K, (), G::Timestamp, R>,
 {
     fn count_core<R2: Abelian + From<i8>>(&self) -> Collection<G, (K, R), R2> {
@@ -282,7 +279,7 @@ pub trait ReduceCore<G: Scope, K: Data, V: Data, R: Semigroup> where G::Timestam
             T2: Trace+TraceReader<Key=K, Time=G::Timestamp>+'static,
             T2::Val: Data,
             T2::R: Abelian,
-            T2::Batch: Batch<K, T2::Val, G::Timestamp, T2::R>,
+            T2::Batch: Batch,
             T2::Cursor: Cursor<K, T2::Val, G::Timestamp, T2::R>,
             L: FnMut(&K, &[(&V, R)], &mut Vec<(T2::Val, T2::R)>)+'static,
         {
@@ -305,7 +302,7 @@ pub trait ReduceCore<G: Scope, K: Data, V: Data, R: Semigroup> where G::Timestam
             T2: Trace+TraceReader<Key=K, Time=G::Timestamp>+'static,
             T2::Val: Data,
             T2::R: Semigroup,
-            T2::Batch: Batch<K, T2::Val, G::Timestamp, T2::R>,
+            T2::Batch: Batch,
             T2::Cursor: Cursor<K, T2::Val, G::Timestamp, T2::R>,
             L: FnMut(&K, &[(&V, R)], &mut Vec<(T2::Val,T2::R)>, &mut Vec<(T2::Val,T2::R)>)+'static
             ;
@@ -324,7 +321,7 @@ where
             T2::Val: Data,
             T2::R: Semigroup,
             T2: Trace+TraceReader<Key=K, Time=G::Timestamp>+'static,
-            T2::Batch: Batch<K, T2::Val, G::Timestamp, T2::R>,
+            T2::Batch: Batch,
             T2::Cursor: Cursor<K, T2::Val, G::Timestamp, T2::R>,
             L: FnMut(&K, &[(&V, R)], &mut Vec<(T2::Val,T2::R)>, &mut Vec<(T2::Val, T2::R)>)+'static
     {
@@ -337,7 +334,6 @@ impl<G: Scope, K: Data, V: Data, T1, R: Semigroup> ReduceCore<G, K, V, R> for Ar
 where
     G::Timestamp: Lattice+Ord,
     T1: TraceReader<Key=K, Val=V, Time=G::Timestamp, R=R>+Clone+'static,
-    T1::Batch: BatchReader<K, V, G::Timestamp, R>,
     T1::Cursor: Cursor<K, V, G::Timestamp, R>,
 {
     fn reduce_core<L, T2>(&self, name: &str, mut logic: L) -> Arranged<G, TraceAgent<T2>>
@@ -345,7 +341,7 @@ where
             T2: Trace+TraceReader<Key=K, Time=G::Timestamp>+'static,
             T2::Val: Data,
             T2::R: Semigroup,
-            T2::Batch: Batch<K, T2::Val, G::Timestamp, T2::R>,
+            T2::Batch: Batch,
             T2::Cursor: Cursor<K, T2::Val, G::Timestamp, T2::R>,
             L: FnMut(&K, &[(&V, R)], &mut Vec<(T2::Val,T2::R)>, &mut Vec<(T2::Val, T2::R)>)+'static {
 
@@ -488,7 +484,7 @@ where
                             let mut builders = Vec::new();
                             for i in 0 .. capabilities.len() {
                                 buffers.push((capabilities[i].time().clone(), Vec::new()));
-                                builders.push(<T2::Batch as Batch<K,T2::Val,G::Timestamp,T2::R>>::Builder::new());
+                                builders.push(<T2::Batch as Batch>::Builder::new());
                             }
 
                             // cursors for navigating input and output traces.
diff --git a/src/operators/threshold.rs b/src/operators/threshold.rs
index 427093a04..939211bc5 100644
--- a/src/operators/threshold.rs
+++ b/src/operators/threshold.rs
@@ -108,7 +108,6 @@ where
     T1: TraceReader<Val=(), Time=G::Timestamp>+Clone+'static,
     T1::Key: ExchangeData,
     T1::R: ExchangeData+Semigroup,
-    T1::Batch: BatchReader<T1::Key, (), G::Timestamp, T1::R>,
     T1::Cursor: Cursor<T1::Key, (), G::Timestamp, T1::R>,
 {
     fn threshold_semigroup<R2, F>(&self, mut thresh: F) -> Collection<G, T1::Key, R2>
diff --git a/src/trace/implementations/merge_batcher.rs b/src/trace/implementations/merge_batcher.rs
index 14ccc0f3a..e281ca6c7 100644
--- a/src/trace/implementations/merge_batcher.rs
+++ b/src/trace/implementations/merge_batcher.rs
@@ -8,7 +8,7 @@ use lattice::Lattice;
 use trace::{Batch, Batcher, Builder};
 
 /// Creates batches from unordered tuples.
-pub struct MergeBatcher<K: Ord, V: Ord, T: Ord, R: Semigroup, B: Batch<K, V, T, R>> {
+pub struct MergeBatcher<K: Ord, V: Ord, T: Ord, R: Semigroup, B: Batch<Key=K, Val=V, Time=T, R=R>> {
     sorter: MergeSorter<(K, V), T, R>,
     lower: Antichain<T>,
     frontier: Antichain<T>,
@@ -21,7 +21,7 @@ where
     V: Ord+Clone,
     T: Lattice+timely::progress::Timestamp+Ord+Clone,
     R: Semigroup,
-    B: Batch<K, V, T, R>,
+    B: Batch<Key=K, Val=V, Time=T, R=R>,
 {
     fn new() -> Self {
         MergeBatcher {
diff --git a/src/trace/implementations/ord.rs b/src/trace/implementations/ord.rs
index f394d2365..d24c9eafc 100644
--- a/src/trace/implementations/ord.rs
+++ b/src/trace/implementations/ord.rs
@@ -62,7 +62,7 @@ where
     pub desc: Description<T>,
 }
 
-impl<K, V, T, R, O> BatchReader<K, V, T, R> for OrdValBatch<K, V, T, R, O>
+impl<K, V, T, R, O> BatchReader for OrdValBatch<K, V, T, R, O>
 where
     K: Ord+Clone+'static,
     V: Ord+Clone+'static,
@@ -70,13 +70,18 @@ where
     R: Semigroup,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
+    type Key = K;
+    type Val = V;
+    type Time = T;
+    type R = R;
+
     type Cursor = OrdValCursor<V, T, R, O>;
     fn cursor(&self) -> Self::Cursor { OrdValCursor { cursor: self.layer.cursor() } }
     fn len(&self) -> usize { <OrderedLayer<K, OrderedLayer<V, OrderedLeaf<T, R>, O>, O> as Trie>::tuples(&self.layer) }
     fn description(&self) -> &Description<T> { &self.desc }
 }
 
-impl<K, V, T, R, O> Batch<K, V, T, R> for OrdValBatch<K, V, T, R, O>
+impl<K, V, T, R, O> Batch for OrdValBatch<K, V, T, R, O>
 where
     K: Ord+Clone+'static,
     V: Ord+Clone+'static,
@@ -409,13 +414,18 @@ where
     pub desc: Description<T>,
 }
 
-impl<K, T, R, O> BatchReader<K, (), T, R> for OrdKeyBatch<K, T, R, O>
+impl<K, T, R, O> BatchReader for OrdKeyBatch<K, T, R, O>
 where
     K: Ord+Clone+'static,
     T: Lattice+Ord+Clone+'static,
     R: Semigroup,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
+    type Key = K;
+    type Val = ();
+    type Time = T;
+    type R = R;
+
     type Cursor = OrdKeyCursor<T, R, O>;
     fn cursor(&self) -> Self::Cursor {
         OrdKeyCursor {
@@ -426,10 +436,10 @@ where
         }
     }
     fn len(&self) -> usize { <OrderedLayer<K, OrderedLeaf<T, R>, O> as Trie>::tuples(&self.layer) }
-    fn description(&self) -> &Description<T> { &self.desc }
+    fn description(&self) -> &Description<Self::Time> { &self.desc }
 }
 
-impl<K, T, R, O> Batch<K, (), T, R> for OrdKeyBatch<K, T, R, O>
+impl<K, T, R, O> Batch for OrdKeyBatch<K, T, R, O>
 where
     K: Ord+Clone+'static,
     T: Lattice+timely::progress::Timestamp+Ord+Clone+'static,
diff --git a/src/trace/implementations/spine_fueled.rs b/src/trace/implementations/spine_fueled.rs
index 8624247e6..5acb3e7e5 100644
--- a/src/trace/implementations/spine_fueled.rs
+++ b/src/trace/implementations/spine_fueled.rs
@@ -87,7 +87,7 @@ use ::timely::order::PartialOrder;
 /// A spine maintains a small number of immutable collections of update tuples, merging the collections when
 /// two have similar sizes. In this way, it allows the addition of more tuples, which may then be merged with
 /// other immutable collections.
-pub struct Spine<K, V, T: Lattice+Ord, R: Semigroup, B: Batch<K, V, T, R>> {
+pub struct Spine<K, V, T: Lattice+Ord, R: Semigroup, B: Batch<Key=K, Val=V, Time=T, R=R>> {
     operator: OperatorInfo,
     logger: Option<Logger>,
     phantom: ::std::marker::PhantomData<(K, V, R)>,
@@ -106,7 +106,7 @@ where
     V: Ord+Clone,           // Clone is required by `batch::advance_*` (in-place could remove).
     T: Lattice+timely::progress::Timestamp+Ord+Clone+Debug,
     R: Semigroup,
-    B: Batch<K, V, T, R>+Clone+'static,
+    B: Batch<Key=K, Val=V, Time=T, R=R>+Clone+'static,
 {
     type Key = K;
     type Val = V;
@@ -114,7 +114,7 @@ where
     type R = R;
 
     type Batch = B;
-    type Cursor = CursorList<K, V, T, R, <B as BatchReader<K, V, T, R>>::Cursor>;
+    type Cursor = CursorList<K, V, T, R, <B as BatchReader>::Cursor>;
 
     fn cursor_through(&mut self, upper: AntichainRef<T>) -> Option<(Self::Cursor, <Self::Cursor as Cursor<K, V, T, R>>::Storage)> {
 
@@ -248,7 +248,7 @@ where
     V: Ord+Clone,
     T: Lattice+timely::progress::Timestamp+Ord+Clone+Debug,
     R: Semigroup,
-    B: Batch<K, V, T, R>+Clone+'static,
+    B: Batch<Key=K, Val=V, Time=T, R=R>+Clone+'static,
 {
     fn new(
         info: ::timely::dataflow::operators::generic::OperatorInfo,
@@ -322,7 +322,7 @@ impl<K, V, T, R, B> Drop for Spine<K, V, T, R, B>
 where
     T: Lattice+Ord,
     R: Semigroup,
-    B: Batch<K, V, T, R>,
+    B: Batch<Key=K, Val=V, Time=T, R=R>,
 {
     fn drop(&mut self) {
         self.drop_batches();
@@ -334,7 +334,7 @@ impl<K, V, T, R, B> Spine<K, V, T, R, B>
 where
     T: Lattice+Ord,
     R: Semigroup,
-    B: Batch<K, V, T, R>,
+    B: Batch<Key=K, Val=V, Time=T, R=R>,
 {
     /// Drops and logs batches. Used in `set_logical_compaction` and drop.
     fn drop_batches(&mut self) {
@@ -382,7 +382,7 @@ where
     V: Ord+Clone,
     T: Lattice+timely::progress::Timestamp+Ord+Clone+Debug,
     R: Semigroup,
-    B: Batch<K, V, T, R>,
+    B: Batch<Key=K, Val=V, Time=T, R=R>,
 {
     /// True iff there is at most one non-empty batch in `self.merging`.
     ///
@@ -766,7 +766,7 @@ where
 ///
 /// A layer can be empty, contain a single batch, or contain a pair of batches
 /// that are in the process of merging into a batch for the next layer.
-enum MergeState<K, V, T, R, B: Batch<K, V, T, R>> {
+enum MergeState<K, V, T, R, B: Batch<Key=K, Val=V, Time=T, R=R>> {
     /// An empty layer, containing no updates.
     Vacant,
     /// A layer containing a single batch.
@@ -778,7 +778,7 @@ enum MergeState<K, V, T, R, B: Batch<K, V, T, R>> {
     Double(MergeVariant<K, V, T, R, B>),
 }
 
-impl<K, V, T: Eq, R, B: Batch<K, V, T, R>> MergeState<K, V, T, R, B> {
+impl<K, V, T: Eq, R, B: Batch<Key=K, Val=V, Time=T, R=R>> MergeState<K, V, T, R, B> {
 
     /// The number of actual updates contained in the level.
     fn len(&self) -> usize {
@@ -864,7 +864,7 @@ impl<K, V, T: Eq, R, B: Batch<K, V, T, R>> MergeState<K, V, T, R, B> {
         match (batch1, batch2) {
             (Some(batch1), Some(batch2)) => {
                 assert!(batch1.upper() == batch2.lower());
-                let begin_merge = <B as Batch<K, V, T, R>>::begin_merge(&batch1, &batch2, compaction_frontier);
+                let begin_merge = <B as Batch>::begin_merge(&batch1, &batch2, compaction_frontier);
                 MergeVariant::InProgress(batch1, batch2, begin_merge)
             }
             (None, Some(x)) => MergeVariant::Complete(Some((x, None))),
@@ -876,14 +876,14 @@ impl<K, V, T: Eq, R, B: Batch<K, V, T, R>> MergeState<K, V, T, R, B> {
     }
 }
 
-enum MergeVariant<K, V, T, R, B: Batch<K, V, T, R>> {
+enum MergeVariant<K, V, T, R, B: Batch<Key=K, Val=V, Time=T, R=R>> {
     /// Describes an actual in-progress merge between two non-trivial batches.
-    InProgress(B, B, <B as Batch<K,V,T,R>>::Merger),
+    InProgress(B, B, <B as Batch>::Merger),
     /// A merge that requires no further work. May or may not represent a non-trivial batch.
     Complete(Option<(B, Option<(B, B)>)>),
 }
 
-impl<K, V, T, R, B: Batch<K, V, T, R>> MergeVariant<K, V, T, R, B> {
+impl<K, V, T, R, B: Batch<Key=K, Val=V, Time=T, R=R>> MergeVariant<K, V, T, R, B> {
 
     /// Completes and extracts the batch, unless structurally empty.
     ///
diff --git a/src/trace/mod.rs b/src/trace/mod.rs
index 45961491d..ad07f8a39 100644
--- a/src/trace/mod.rs
+++ b/src/trace/mod.rs
@@ -41,7 +41,6 @@ pub use self::description::Description;
 /// to update the contents of the trace. These methods are used to examine the contents, and to update the reader's
 /// capabilities (which may release restrictions on the mutations to the underlying trace and cause work to happen).
 pub trait TraceReader {
-
     /// Key by which updates are indexed.
     type Key;
     /// Values associated with keys.
@@ -52,7 +51,7 @@ pub trait TraceReader {
     type R;
 
     /// The type of an immutable collection of updates.
-    type Batch: BatchReader<Self::Key, Self::Val, Self::Time, Self::R>+Clone+'static;
+    type Batch: BatchReader<Key=Self::Key, Val=Self::Val, Time=Self::Time, R=Self::R>+Clone+'static;
 
     /// The type used to enumerate the collections contents.
     type Cursor: Cursor<Self::Key, Self::Val, Self::Time, Self::R>;
@@ -196,9 +195,7 @@ pub trait TraceReader {
 ///
 /// The trace must be constructable from, and navigable by the `Key`, `Val`, `Time` types, but does not need
 /// to return them.
-pub trait Trace : TraceReader
-where <Self as TraceReader>::Batch: Batch<Self::Key, Self::Val, Self::Time, Self::R> {
-
+pub trait Trace: TraceReader {
     /// Allocates a new empty trace.
     fn new(
         info: ::timely::dataflow::operators::generic::OperatorInfo,
@@ -232,12 +229,21 @@ where <Self as TraceReader>::Batch: Batch<Self::Key, Self::Val, Self::Time, Self
 /// but do not expose ways to construct the batches. This trait is appropriate for views of the batch, and is
 /// especially useful for views derived from other sources in ways that prevent the construction of batches
 /// from the type of data in the view (for example, filtered views, or views with extended time coordinates).
-pub trait BatchReader<K, V, T, R>
+pub trait BatchReader
 where
     Self: ::std::marker::Sized,
 {
+    /// Key by which updates are indexed.
+    type Key;
+    /// Values associated with keys.
+    type Val;
+    /// Timestamps associated with updates
+    type Time;
+    /// Associated update.
+    type R;
+
     /// The type used to enumerate the batch's contents.
-    type Cursor: Cursor<K, V, T, R, Storage=Self>;
+    type Cursor: Cursor<Self::Key, Self::Val, Self::Time, Self::R, Storage=Self>;
     /// Acquires a cursor to the batch's contents.
     fn cursor(&self) -> Self::Cursor;
     /// The number of updates in the batch.
@@ -245,39 +251,39 @@ where
     /// True if the batch is empty.
     fn is_empty(&self) -> bool { self.len() == 0 }
     /// Describes the times of the updates in the batch.
-    fn description(&self) -> &Description<T>;
+    fn description(&self) -> &Description<Self::Time>;
 
     /// All times in the batch are greater or equal to an element of `lower`.
-    fn lower(&self) -> &Antichain<T> { self.description().lower() }
+    fn lower(&self) -> &Antichain<Self::Time> { self.description().lower() }
     /// All times in the batch are not greater or equal to any element of `upper`.
-    fn upper(&self) -> &Antichain<T> { self.description().upper() }
+    fn upper(&self) -> &Antichain<Self::Time> { self.description().upper() }
 }
 
 /// An immutable collection of updates.
-pub trait Batch<K, V, T, R> : BatchReader<K, V, T, R> where Self: ::std::marker::Sized {
+pub trait Batch: BatchReader where Self: ::std::marker::Sized {
     /// A type used to assemble batches from disordered updates.
-    type Batcher: Batcher<K, V, T, R, Self>;
+    type Batcher: Batcher<Self::Key, Self::Val, Self::Time, Self::R, Self>;
     /// A type used to assemble batches from ordered update sequences.
-    type Builder: Builder<K, V, T, R, Self>;
+    type Builder: Builder<Self::Key, Self::Val, Self::Time, Self::R, Self>;
     /// A type used to progressively merge batches.
-    type Merger: Merger<K, V, T, R, Self>;
+    type Merger: Merger<Self::Key, Self::Val, Self::Time, Self::R, Self>;
 
     /// Initiates the merging of consecutive batches.
     ///
     /// The result of this method can be exercised to eventually produce the same result
     /// that a call to `self.merge(other)` would produce, but it can be done in a measured
     /// fashion. This can help to avoid latency spikes where a large merge needs to happen.
-    fn begin_merge(&self, other: &Self, compaction_frontier: Option<AntichainRef<T>>) -> Self::Merger {
+    fn begin_merge(&self, other: &Self, compaction_frontier: Option<AntichainRef<Self::Time>>) -> Self::Merger {
         Self::Merger::new(self, other, compaction_frontier)
     }
     /// Creates an empty batch with the stated bounds.
-    fn empty(lower: Antichain<T>, upper: Antichain<T>, since: Antichain<T>) -> Self {
+    fn empty(lower: Antichain<Self::Time>, upper: Antichain<Self::Time>, since: Antichain<Self::Time>) -> Self {
         <Self::Builder>::new().done(lower, upper, since)
     }
 }
 
 /// Functionality for collecting and batching updates.
-pub trait Batcher<K, V, T, R, Output: Batch<K, V, T, R>> {
+pub trait Batcher<K, V, T, R, Output: Batch<Key=K, Val=V, Time=T, R=R>> {
     /// Allocates a new empty batcher.
     fn new() -> Self;
     /// Adds an unordered batch of elements to the batcher.
@@ -289,7 +295,7 @@ pub trait Batcher<K, V, T, R, Output: Batch<K, V, T, R>> {
 }
 
 /// Functionality for building batches from ordered update sequences.
-pub trait Builder<K, V, T, R, Output: Batch<K, V, T, R>> {
+pub trait Builder<K, V, T, R, Output: Batch<Key=K, Val=V, Time=T, R=R>> {
     /// Allocates an empty builder.
     fn new() -> Self;
     /// Allocates an empty builder with some capacity.
@@ -305,7 +311,7 @@ pub trait Builder<K, V, T, R, Output: Batch<K, V, T, R>> {
 }
 
 /// Represents a merge in progress.
-pub trait Merger<K, V, T, R, Output: Batch<K, V, T, R>> {
+pub trait Merger<K, V, T, R, Output: Batch<Key=K, Val=V, Time=T, R=R>> {
     /// Creates a new merger to merge the supplied batches, optionally compacting
     /// up to the supplied frontier.
     fn new(source1: &Output, source2: &Output, compaction_frontier: Option<AntichainRef<T>>) -> Self;
@@ -331,10 +337,14 @@ pub mod rc_blanket_impls {
     use timely::progress::{Antichain, frontier::AntichainRef};
     use super::{Batch, BatchReader, Batcher, Builder, Merger, Cursor, Description};
 
-    impl<K, V, T, R, B: BatchReader<K,V,T,R>> BatchReader<K,V,T,R> for Rc<B> {
+    impl<B: BatchReader> BatchReader for Rc<B> {
+        type Key = B::Key;
+        type Val = B::Val;
+        type Time = B::Time;
+        type R = B::R;
 
         /// The type used to enumerate the batch's contents.
-        type Cursor = RcBatchCursor<K, V, T, R, B>;
+        type Cursor = RcBatchCursor<Self::Key, Self::Val, Self::Time, Self::R, B>;
         /// Acquires a cursor to the batch's contents.
         fn cursor(&self) -> Self::Cursor {
             RcBatchCursor::new((&**self).cursor())
@@ -343,16 +353,16 @@ pub mod rc_blanket_impls {
         /// The number of updates in the batch.
         fn len(&self) -> usize { (&**self).len() }
         /// Describes the times of the updates in the batch.
-        fn description(&self) -> &Description<T> { (&**self).description() }
+        fn description(&self) -> &Description<Self::Time> { (&**self).description() }
     }
 
     /// Wrapper to provide cursor to nested scope.
-    pub struct RcBatchCursor<K, V, T, R, B: BatchReader<K, V, T, R>> {
+    pub struct RcBatchCursor<K, V, T, R, B: BatchReader<Key=K, Val=V, Time=T, R=R>> {
         phantom: ::std::marker::PhantomData<(K, V, T, R)>,
         cursor: B::Cursor,
     }
 
-    impl<K, V, T, R, B: BatchReader<K, V, T, R>> RcBatchCursor<K, V, T, R, B> {
+    impl<K, V, T, R, B: BatchReader<Key=K, Val=V, Time=T, R=R>> RcBatchCursor<K, V, T, R, B> {
         fn new(cursor: B::Cursor) -> Self {
             RcBatchCursor {
                 cursor,
@@ -361,7 +371,7 @@ pub mod rc_blanket_impls {
         }
     }
 
-    impl<K, V, T, R, B: BatchReader<K, V, T, R>> Cursor<K, V, T, R> for RcBatchCursor<K, V, T, R, B> {
+    impl<K, V, T, R, B: BatchReader<Key=K, Val=V, Time=T, R=R>> Cursor<K, V, T, R> for RcBatchCursor<K, V, T, R, B> {
 
         type Storage = Rc<B>;
 
@@ -387,17 +397,17 @@ pub mod rc_blanket_impls {
     }
 
     /// An immutable collection of updates.
-    impl<K,V,T,R,B: Batch<K,V,T,R>> Batch<K, V, T, R> for Rc<B> {
-        type Batcher = RcBatcher<K, V, T, R, B>;
-        type Builder = RcBuilder<K, V, T, R, B>;
-        type Merger = RcMerger<K, V, T, R, B>;
+    impl<B: Batch> Batch for Rc<B> {
+        type Batcher = RcBatcher<B::Key, B::Val, B::Time, B::R, B>;
+        type Builder = RcBuilder<B::Key, B::Val, B::Time, B::R, B>;
+        type Merger = RcMerger<B::Key, B::Val, B::Time, B::R, B>;
     }
 
     /// Wrapper type for batching reference counted batches.
-    pub struct RcBatcher<K,V,T,R,B:Batch<K,V,T,R>> { batcher: B::Batcher }
+    pub struct RcBatcher<K,V,T,R,B:Batch<Key=K,Val=V,Time=T,R=R>> { batcher: B::Batcher }
 
     /// Functionality for collecting and batching updates.
-    impl<K,V,T,R,B:Batch<K,V,T,R>> Batcher<K, V, T, R, Rc<B>> for RcBatcher<K,V,T,R,B> {
+    impl<K,V,T,R,B:Batch<Key=K,Val=V,Time=T,R=R>> Batcher<K, V, T, R, Rc<B>> for RcBatcher<K,V,T,R,B> {
         fn new() -> Self { RcBatcher { batcher: <B::Batcher as Batcher<K,V,T,R,B>>::new() } }
         fn push_batch(&mut self, batch: &mut Vec<((K, V), T, R)>) { self.batcher.push_batch(batch) }
         fn seal(&mut self, upper: Antichain<T>) -> Rc<B> { Rc::new(self.batcher.seal(upper)) }
@@ -405,10 +415,10 @@ pub mod rc_blanket_impls {
     }
 
     /// Wrapper type for building reference counted batches.
-    pub struct RcBuilder<K,V,T,R,B:Batch<K,V,T,R>> { builder: B::Builder }
+    pub struct RcBuilder<K,V,T,R,B:Batch<Key=K,Val=V,Time=T,R=R>> { builder: B::Builder }
 
     /// Functionality for building batches from ordered update sequences.
-    impl<K,V,T,R,B:Batch<K,V,T,R>> Builder<K, V, T, R, Rc<B>> for RcBuilder<K,V,T,R,B> {
+    impl<K,V,T,R,B:Batch<Key=K,Val=V,Time=T,R=R>> Builder<K, V, T, R, Rc<B>> for RcBuilder<K,V,T,R,B> {
         fn new() -> Self { RcBuilder { builder: <B::Builder as Builder<K,V,T,R,B>>::new() } }
         fn with_capacity(cap: usize) -> Self { RcBuilder { builder: <B::Builder as Builder<K,V,T,R,B>>::with_capacity(cap) } }
         fn push(&mut self, element: (K, V, T, R)) { self.builder.push(element) }
@@ -416,10 +426,10 @@ pub mod rc_blanket_impls {
     }
 
     /// Wrapper type for merging reference counted batches.
-    pub struct RcMerger<K,V,T,R,B:Batch<K,V,T,R>> { merger: B::Merger }
+    pub struct RcMerger<K,V,T,R,B:Batch<Key=K,Val=V,Time=T,R=R>> { merger: B::Merger }
 
     /// Represents a merge in progress.
-    impl<K,V,T,R,B:Batch<K,V,T,R>> Merger<K, V, T, R, Rc<B>> for RcMerger<K,V,T,R,B> {
+    impl<K,V,T,R,B:Batch<Key=K,Val=V,Time=T,R=R>> Merger<K, V, T, R, Rc<B>> for RcMerger<K,V,T,R,B> {
         fn new(source1: &Rc<B>, source2: &Rc<B>, compaction_frontier: Option<AntichainRef<T>>) -> Self { RcMerger { merger: B::begin_merge(source1, source2, compaction_frontier) } }
         fn work(&mut self, source1: &Rc<B>, source2: &Rc<B>, fuel: &mut isize) { self.merger.work(source1, source2, fuel) }
         fn done(self) -> Rc<B> { Rc::new(self.merger.done()) }
@@ -438,10 +448,14 @@ pub mod abomonated_blanket_impls {
 
     use super::{Batch, BatchReader, Batcher, Builder, Merger, Cursor, Description};
 
-    impl<K, V, T, R, B: BatchReader<K,V,T,R>+Abomonation> BatchReader<K,V,T,R> for Abomonated<B, Vec<u8>> {
+    impl<B: BatchReader+Abomonation> BatchReader for Abomonated<B, Vec<u8>> {
+        type Key = B::Key;
+        type Val = B::Val;
+        type Time = B::Time;
+        type R = B::R;
 
         /// The type used to enumerate the batch's contents.
-        type Cursor = AbomonatedBatchCursor<K, V, T, R, B>;
+        type Cursor = AbomonatedBatchCursor<Self::Key, Self::Val, Self::Time, Self::R, B>;
         /// Acquires a cursor to the batch's contents.
         fn cursor(&self) -> Self::Cursor {
             AbomonatedBatchCursor::new((&**self).cursor())
@@ -450,16 +464,16 @@ pub mod abomonated_blanket_impls {
         /// The number of updates in the batch.
         fn len(&self) -> usize { (&**self).len() }
         /// Describes the times of the updates in the batch.
-        fn description(&self) -> &Description<T> { (&**self).description() }
+        fn description(&self) -> &Description<Self::Time> { (&**self).description() }
     }
 
     /// Wrapper to provide cursor to nested scope.
-    pub struct AbomonatedBatchCursor<K, V, T, R, B: BatchReader<K, V, T, R>> {
+    pub struct AbomonatedBatchCursor<K, V, T, R, B: BatchReader<Key=K, Val=V, Time=T, R=R>> {
         phantom: ::std::marker::PhantomData<(K, V, T, R)>,
         cursor: B::Cursor,
     }
 
-    impl<K, V, T, R, B: BatchReader<K, V, T, R>> AbomonatedBatchCursor<K, V, T, R, B> {
+    impl<K, V, T, R, B: BatchReader<Key=K, Val=V, Time=T, R=R>> AbomonatedBatchCursor<K, V, T, R, B> {
         fn new(cursor: B::Cursor) -> Self {
             AbomonatedBatchCursor {
                 cursor,
@@ -468,7 +482,7 @@ pub mod abomonated_blanket_impls {
         }
     }
 
-    impl<K, V, T, R, B: BatchReader<K, V, T, R>+Abomonation> Cursor<K, V, T, R> for AbomonatedBatchCursor<K, V, T, R, B> {
+    impl<K, V, T, R, B: BatchReader<Key=K, Val=V, Time=T, R=R>+Abomonation> Cursor<K, V, T, R> for AbomonatedBatchCursor<K, V, T, R, B> {
 
         type Storage = Abomonated<B, Vec<u8>>;
 
@@ -494,17 +508,17 @@ pub mod abomonated_blanket_impls {
     }
 
     /// An immutable collection of updates.
-    impl<K,V,T,R,B: Batch<K,V,T,R>+Abomonation> Batch<K, V, T, R> for Abomonated<B, Vec<u8>> {
-        type Batcher = AbomonatedBatcher<K, V, T, R, B>;
-        type Builder = AbomonatedBuilder<K, V, T, R, B>;
-        type Merger = AbomonatedMerger<K, V, T, R, B>;
+    impl<B: Batch + Abomonation> Batch for Abomonated<B, Vec<u8>> {
+        type Batcher = AbomonatedBatcher<Self::Key, Self::Val, Self::Time, Self::R, B>;
+        type Builder = AbomonatedBuilder<Self::Key, Self::Val, Self::Time, Self::R, B>;
+        type Merger = AbomonatedMerger<Self::Key, Self::Val, Self::Time, Self::R, B>;
     }
 
     /// Wrapper type for batching reference counted batches.
-    pub struct AbomonatedBatcher<K,V,T,R,B:Batch<K,V,T,R>> { batcher: B::Batcher }
+    pub struct AbomonatedBatcher<K,V,T,R,B:Batch<Key=K,Val=V,Time=T,R=R>> { batcher: B::Batcher }
 
     /// Functionality for collecting and batching updates.
-    impl<K,V,T,R,B:Batch<K,V,T,R>+Abomonation> Batcher<K, V, T, R, Abomonated<B,Vec<u8>>> for AbomonatedBatcher<K,V,T,R,B> {
+    impl<K,V,T,R,B:Batch<Key=K,Val=V,Time=T,R=R>+Abomonation> Batcher<K, V, T, R, Abomonated<B,Vec<u8>>> for AbomonatedBatcher<K,V,T,R,B> {
         fn new() -> Self { AbomonatedBatcher { batcher: <B::Batcher as Batcher<K,V,T,R,B>>::new() } }
         fn push_batch(&mut self, batch: &mut Vec<((K, V), T, R)>) { self.batcher.push_batch(batch) }
         fn seal(&mut self, upper: Antichain<T>) -> Abomonated<B, Vec<u8>> {
@@ -517,10 +531,10 @@ pub mod abomonated_blanket_impls {
     }
 
     /// Wrapper type for building reference counted batches.
-    pub struct AbomonatedBuilder<K,V,T,R,B:Batch<K,V,T,R>> { builder: B::Builder }
+    pub struct AbomonatedBuilder<K,V,T,R,B:Batch<Key=K,Val=V,Time=T,R=R>> { builder: B::Builder }
 
     /// Functionality for building batches from ordered update sequences.
-    impl<K,V,T,R,B:Batch<K,V,T,R>+Abomonation> Builder<K, V, T, R, Abomonated<B,Vec<u8>>> for AbomonatedBuilder<K,V,T,R,B> {
+    impl<K,V,T,R,B:Batch<Key=K,Val=V,Time=T,R=R>+Abomonation> Builder<K, V, T, R, Abomonated<B,Vec<u8>>> for AbomonatedBuilder<K,V,T,R,B> {
         fn new() -> Self { AbomonatedBuilder { builder: <B::Builder as Builder<K,V,T,R,B>>::new() } }
         fn with_capacity(cap: usize) -> Self { AbomonatedBuilder { builder: <B::Builder as Builder<K,V,T,R,B>>::with_capacity(cap) } }
         fn push(&mut self, element: (K, V, T, R)) { self.builder.push(element) }
@@ -533,10 +547,10 @@ pub mod abomonated_blanket_impls {
     }
 
     /// Wrapper type for merging reference counted batches.
-    pub struct AbomonatedMerger<K,V,T,R,B:Batch<K,V,T,R>> { merger: B::Merger }
+    pub struct AbomonatedMerger<K,V,T,R,B:Batch<Key=K,Val=V,Time=T,R=R>> { merger: B::Merger }
 
     /// Represents a merge in progress.
-    impl<K,V,T,R,B:Batch<K,V,T,R>+Abomonation> Merger<K, V, T, R, Abomonated<B,Vec<u8>>> for AbomonatedMerger<K,V,T,R,B> {
+    impl<K,V,T,R,B:Batch<Key=K,Val=V,Time=T,R=R>+Abomonation> Merger<K, V, T, R, Abomonated<B,Vec<u8>>> for AbomonatedMerger<K,V,T,R,B> {
         fn new(source1: &Abomonated<B,Vec<u8>>, source2: &Abomonated<B,Vec<u8>>, compaction_frontier: Option<AntichainRef<T>>) -> Self {
             AbomonatedMerger { merger: B::begin_merge(source1, source2, compaction_frontier) }
         }
diff --git a/src/trace/wrappers/enter.rs b/src/trace/wrappers/enter.rs
index c1d28fd92..410b8d642 100644
--- a/src/trace/wrappers/enter.rs
+++ b/src/trace/wrappers/enter.rs
@@ -47,7 +47,7 @@ where
     type Time = TInner;
     type R = Tr::R;
 
-    type Batch = BatchEnter<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Batch, TInner>;
+    type Batch = BatchEnter<Tr::Batch, TInner>;
     type Cursor = CursorEnter<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Cursor, TInner>;
 
     fn map_batches<F: FnMut(&Self::Batch)>(&self, mut f: F) {
@@ -113,42 +113,37 @@ where
 
 
 /// Wrapper to provide batch to nested scope.
-pub struct BatchEnter<K, V, T, R, B, TInner> {
-    phantom: ::std::marker::PhantomData<(K, V, T, R)>,
+#[derive(Clone)]
+pub struct BatchEnter<B, TInner> {
     batch: B,
     description: Description<TInner>,
 }
 
-impl<K, V, T, R, B: Clone, TInner: Clone> Clone for BatchEnter<K, V, T, R, B, TInner> {
-    fn clone(&self) -> Self {
-        BatchEnter {
-            phantom: ::std::marker::PhantomData,
-            batch: self.batch.clone(),
-            description: self.description.clone(),
-        }
-    }
-}
-
-impl<K, V, T, R, B, TInner> BatchReader<K, V, TInner, R> for BatchEnter<K, V, T, R, B, TInner>
+impl<B, TInner> BatchReader for BatchEnter<B, TInner>
 where
-    B: BatchReader<K, V, T, R>,
-    T: Timestamp,
-    TInner: Refines<T>+Lattice,
+    B: BatchReader,
+    B::Time: Timestamp,
+    TInner: Refines<B::Time>+Lattice,
 {
-    type Cursor = BatchCursorEnter<K, V, T, R, B, TInner>;
+    type Key = B::Key;
+    type Val = B::Val;
+    type Time = TInner;
+    type R = B::R;
+
+    type Cursor = BatchCursorEnter<B::Key, B::Val, B::Time, B::R, B, TInner>;
 
     fn cursor(&self) -> Self::Cursor {
         BatchCursorEnter::new(self.batch.cursor())
     }
     fn len(&self) -> usize { self.batch.len() }
-    fn description(&self) -> &Description<TInner> { &self.description }
+    fn description(&self) -> &Description<Self::Time> { &self.description }
 }
 
-impl<K, V, T, R, B, TInner> BatchEnter<K, V, T, R, B, TInner>
+impl<B, TInner> BatchEnter<B, TInner>
 where
-    B: BatchReader<K, V, T, R>,
-    T: Timestamp,
-    TInner: Refines<T>+Lattice,
+    B: BatchReader,
+    B::Time: Timestamp,
+    TInner: Refines<B::Time>+Lattice,
 {
     /// Makes a new batch wrapper
     pub fn make_from(batch: B) -> Self {
@@ -157,7 +152,6 @@ where
         let since: Vec<_> = batch.description().since().elements().iter().map(|x| TInner::to_inner(x.clone())).collect();
 
         BatchEnter {
-            phantom: ::std::marker::PhantomData,
             batch: batch,
             description: Description::new(Antichain::from(lower), Antichain::from(upper), Antichain::from(since))
         }
@@ -213,12 +207,12 @@ where
 
 
 /// Wrapper to provide cursor to nested scope.
-pub struct BatchCursorEnter<K, V, T, R, B: BatchReader<K, V, T, R>, TInner> {
+pub struct BatchCursorEnter<K, V, T, R, B: BatchReader<Key=K, Val=V, Time=T, R=R>, TInner> {
     phantom: ::std::marker::PhantomData<(K, V, R, TInner)>,
     cursor: B::Cursor,
 }
 
-impl<K, V, T, R, B: BatchReader<K, V, T, R>, TInner> BatchCursorEnter<K, V, T, R, B, TInner> {
+impl<K, V, T, R, B: BatchReader<Key=K, Val=V, Time=T, R=R>, TInner> BatchCursorEnter<K, V, T, R, B, TInner> {
     fn new(cursor: B::Cursor) -> Self {
         BatchCursorEnter {
             phantom: ::std::marker::PhantomData,
@@ -227,12 +221,12 @@ impl<K, V, T, R, B: BatchReader<K, V, T, R>, TInner> BatchCursorEnter<K, V, T, R
     }
 }
 
-impl<K, V, T, R, TInner, B: BatchReader<K, V, T, R>> Cursor<K, V, TInner, R> for BatchCursorEnter<K, V, T, R, B, TInner>
+impl<K, V, T, R, TInner, B: BatchReader<Key=K, Val=V, Time=T, R=R>> Cursor<K, V, TInner, R> for BatchCursorEnter<K, V, T, R, B, TInner>
 where
     T: Timestamp,
     TInner: Refines<T>+Lattice,
 {
-    type Storage = BatchEnter<K, V, T, R, B, TInner>;
+    type Storage = BatchEnter<B, TInner>;
 
     #[inline] fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.key_valid(&storage.batch) }
     #[inline] fn val_valid(&self, storage: &Self::Storage) -> bool { self.cursor.val_valid(&storage.batch) }
diff --git a/src/trace/wrappers/enter_at.rs b/src/trace/wrappers/enter_at.rs
index 9562fc90c..e95f885f1 100644
--- a/src/trace/wrappers/enter_at.rs
+++ b/src/trace/wrappers/enter_at.rs
@@ -62,7 +62,7 @@ where
     type Time = TInner;
     type R = Tr::R;
 
-    type Batch = BatchEnter<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Batch, TInner,F>;
+    type Batch = BatchEnter<Tr::Batch, TInner,F>;
     type Cursor = CursorEnter<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Cursor, TInner,F>;
 
     fn map_batches<F2: FnMut(&Self::Batch)>(&self, mut f: F2) {
@@ -131,32 +131,26 @@ where
 
 
 /// Wrapper to provide batch to nested scope.
-pub struct BatchEnter<K, V, T, R, B, TInner, F> {
-    phantom: ::std::marker::PhantomData<(K, V, T, R)>,
+#[derive(Clone)]
+pub struct BatchEnter<B, TInner, F> {
     batch: B,
     description: Description<TInner>,
     logic: F,
 }
 
-impl<K, V, T, R, B: Clone, TInner: Clone, F: Clone> Clone for BatchEnter<K, V, T, R, B, TInner, F> {
-    fn clone(&self) -> Self {
-        BatchEnter {
-            phantom: ::std::marker::PhantomData,
-            batch: self.batch.clone(),
-            description: self.description.clone(),
-            logic: self.logic.clone(),
-        }
-    }
-}
-
-impl<K, V, T, R, B, TInner, F> BatchReader<K, V, TInner, R> for BatchEnter<K, V, T, R, B, TInner, F>
+impl<B, TInner, F> BatchReader for BatchEnter<B, TInner, F>
 where
-    B: BatchReader<K, V, T, R>,
-    T: Timestamp,
-    TInner: Refines<T>+Lattice,
-    F: FnMut(&K, &V, &T)->TInner+Clone,
+    B: BatchReader,
+    B::Time: Timestamp,
+    TInner: Refines<B::Time>+Lattice,
+    F: FnMut(&B::Key, &B::Val, &B::Time)->TInner+Clone,
 {
-    type Cursor = BatchCursorEnter<K, V, T, R, B, TInner, F>;
+    type Key = B::Key;
+    type Val = B::Val;
+    type Time = TInner;
+    type R = B::R;
+
+    type Cursor = BatchCursorEnter<B::Key, B::Val, B::Time, B::R, B, TInner, F>;
 
     fn cursor(&self) -> Self::Cursor {
         BatchCursorEnter::new(self.batch.cursor(), self.logic.clone())
@@ -165,11 +159,11 @@ where
     fn description(&self) -> &Description<TInner> { &self.description }
 }
 
-impl<K, V, T, R, B, TInner, F> BatchEnter<K, V, T, R, B, TInner, F>
+impl<B, TInner, F> BatchEnter<B, TInner, F>
 where
-    B: BatchReader<K, V, T, R>,
-    T: Timestamp,
-    TInner: Refines<T>+Lattice,
+    B: BatchReader,
+    B::Time: Timestamp,
+    TInner: Refines<B::Time>+Lattice,
 {
     /// Makes a new batch wrapper
     pub fn make_from(batch: B, logic: F) -> Self {
@@ -178,7 +172,6 @@ where
         let since: Vec<_> = batch.description().since().elements().iter().map(|x| TInner::to_inner(x.clone())).collect();
 
         BatchEnter {
-            phantom: ::std::marker::PhantomData,
             batch,
             description: Description::new(Antichain::from(lower), Antichain::from(upper), Antichain::from(since)),
             logic,
@@ -241,13 +234,13 @@ where
 
 
 /// Wrapper to provide cursor to nested scope.
-pub struct BatchCursorEnter<K, V, T, R, B: BatchReader<K, V, T, R>, TInner, F> {
+pub struct BatchCursorEnter<K, V, T, R, B: BatchReader<Key=K, Val=V, Time=T, R=R>, TInner, F> {
     phantom: ::std::marker::PhantomData<(K, V, R, TInner)>,
     cursor: B::Cursor,
     logic: F,
 }
 
-impl<K, V, T, R, B: BatchReader<K, V, T, R>, TInner, F> BatchCursorEnter<K, V, T, R, B, TInner, F> {
+impl<K, V, T, R, B: BatchReader<Key=K, Val=V, Time=T, R=R>, TInner, F> BatchCursorEnter<K, V, T, R, B, TInner, F> {
     fn new(cursor: B::Cursor, logic: F) -> Self {
         BatchCursorEnter {
             phantom: ::std::marker::PhantomData,
@@ -257,13 +250,13 @@ impl<K, V, T, R, B: BatchReader<K, V, T, R>, TInner, F> BatchCursorEnter<K, V, T
     }
 }
 
-impl<K, V, T, R, TInner, B: BatchReader<K, V, T, R>, F> Cursor<K, V, TInner, R> for BatchCursorEnter<K, V, T, R, B, TInner, F>
+impl<K, V, T, R, TInner, B: BatchReader<Key=K, Val=V, Time=T, R=R>, F> Cursor<K, V, TInner, R> for BatchCursorEnter<K, V, T, R, B, TInner, F>
 where
     T: Timestamp,
     TInner: Refines<T>+Lattice,
     F: FnMut(&K, &V, &T)->TInner,
 {
-    type Storage = BatchEnter<K, V, T, R, B, TInner, F>;
+    type Storage = BatchEnter<B, TInner, F>;
 
     #[inline] fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.key_valid(&storage.batch) }
     #[inline] fn val_valid(&self, storage: &Self::Storage) -> bool { self.cursor.val_valid(&storage.batch) }
diff --git a/src/trace/wrappers/filter.rs b/src/trace/wrappers/filter.rs
index 0f1a531ab..b61994bc1 100644
--- a/src/trace/wrappers/filter.rs
+++ b/src/trace/wrappers/filter.rs
@@ -40,7 +40,7 @@ where
     type Time = Tr::Time;
     type R = Tr::R;
 
-    type Batch = BatchFilter<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Batch, F>;
+    type Batch = BatchFilter<Tr::Batch, F>;
     type Cursor = CursorFilter<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Cursor, F>;
 
     fn map_batches<F2: FnMut(&Self::Batch)>(&self, mut f: F2) {
@@ -76,46 +76,36 @@ where
 
 
 /// Wrapper to provide batch to nested scope.
-pub struct BatchFilter<K, V, T, R, B, F> {
-    phantom: ::std::marker::PhantomData<(K, V, T, R)>,
+#[derive(Clone)]
+pub struct BatchFilter<B, F> {
     batch: B,
     logic: F,
 }
 
-impl<K, V, T, R, B: Clone, F: Clone> Clone for BatchFilter<K, V, T, R, B, F> {
-    fn clone(&self) -> Self {
-        BatchFilter {
-            phantom: ::std::marker::PhantomData,
-            batch: self.batch.clone(),
-            logic: self.logic.clone(),
-        }
-    }
-}
-
-impl<K, V, T, R, B, F> BatchReader<K, V, T, R> for BatchFilter<K, V, T, R, B, F>
+impl<B, F> BatchReader for BatchFilter<B, F>
 where
-    B: BatchReader<K, V, T, R>,
-    T: Timestamp,
-    F: FnMut(&K, &V)->bool+Clone+'static
+    B: BatchReader,
+    B::Time: Timestamp,
+    F: FnMut(&B::Key, &B::Val)->bool+Clone+'static
 {
-    type Cursor = BatchCursorFilter<K, V, T, R, B, F>;
+    type Key = B::Key;
+    type Val = B::Val;
+    type Time = B::Time;
+    type R = B::R;
+
+    type Cursor = BatchCursorFilter<B::Key, B::Val, B::Time, B::R, B, F>;
 
     fn cursor(&self) -> Self::Cursor {
         BatchCursorFilter::new(self.batch.cursor(), self.logic.clone())
     }
     fn len(&self) -> usize { self.batch.len() }
-    fn description(&self) -> &Description<T> { &self.batch.description() }
+    fn description(&self) -> &Description<Self::Time> { &self.batch.description() }
 }
 
-impl<K, V, T, R, B, F> BatchFilter<K, V, T, R, B, F>
-where
-    B: BatchReader<K, V, T, R>,
-    T: Timestamp,
-{
+impl<B: BatchReader, F> BatchFilter<B, F> {
     /// Makes a new batch wrapper
     pub fn make_from(batch: B, logic: F) -> Self {
         BatchFilter {
-            phantom: ::std::marker::PhantomData,
             batch,
             logic,
         }
@@ -175,13 +165,13 @@ where
 
 
 /// Wrapper to provide cursor to nested scope.
-pub struct BatchCursorFilter<K, V, T, R, B: BatchReader<K, V, T, R>, F> {
+pub struct BatchCursorFilter<K, V, T, R, B: BatchReader<Key=K, Val=V, Time=T, R=R>, F> {
     phantom: ::std::marker::PhantomData<(K, V, R)>,
     cursor: B::Cursor,
     logic: F,
 }
 
-impl<K, V, T, R, B: BatchReader<K, V, T, R>, F> BatchCursorFilter<K, V, T, R, B, F> {
+impl<K, V, T, R, B: BatchReader<Key=K, Val=V, Time=T, R=R>, F> BatchCursorFilter<K, V, T, R, B, F> {
     fn new(cursor: B::Cursor, logic: F) -> Self {
         BatchCursorFilter {
             phantom: ::std::marker::PhantomData,
@@ -191,12 +181,12 @@ impl<K, V, T, R, B: BatchReader<K, V, T, R>, F> BatchCursorFilter<K, V, T, R, B,
     }
 }
 
-impl<K, V, T, R, B: BatchReader<K, V, T, R>, F> Cursor<K, V, T, R> for BatchCursorFilter<K, V, T, R, B, F>
+impl<K, V, T, R, B: BatchReader<Key=K, Val=V, Time=T, R=R>, F> Cursor<K, V, T, R> for BatchCursorFilter<K, V, T, R, B, F>
 where
     T: Timestamp,
     F: FnMut(&K, &V)->bool+'static,
 {
-    type Storage = BatchFilter<K, V, T, R, B, F>;
+    type Storage = BatchFilter<B, F>;
 
     #[inline] fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.key_valid(&storage.batch) }
     #[inline] fn val_valid(&self, storage: &Self::Storage) -> bool { self.cursor.val_valid(&storage.batch) }
diff --git a/src/trace/wrappers/freeze.rs b/src/trace/wrappers/freeze.rs
index fa24b91d7..706d6a1a8 100644
--- a/src/trace/wrappers/freeze.rs
+++ b/src/trace/wrappers/freeze.rs
@@ -41,7 +41,6 @@ where
     T::Key: 'static,
     T::Val: 'static,
     T::R: 'static,
-    T::Batch: BatchReader<T::Key, T::Val, G::Timestamp, T::R>,
     T::Cursor: Cursor<T::Key, T::Val, G::Timestamp, T::R>,
     F: Fn(&G::Timestamp)->Option<G::Timestamp>+'static,
 {
@@ -93,7 +92,7 @@ where
     type Time = Tr::Time;
     type R = Tr::R;
 
-    type Batch = BatchFreeze<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Batch, F>;
+    type Batch = BatchFreeze<Tr::Batch, F>;
     type Cursor = CursorFreeze<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Cursor, F>;
 
     fn map_batches<F2: FnMut(&Self::Batch)>(&self, mut f: F2) {
@@ -137,47 +136,39 @@ where
 
 
 /// Wrapper to provide batch to nested scope.
-pub struct BatchFreeze<K, V, T, R, B, F> {
-    phantom: ::std::marker::PhantomData<(K, V, R, T)>,
+pub struct BatchFreeze<B, F> {
     batch: B,
     func: Rc<F>,
 }
 
-impl<K, V, T: Clone, R, B: Clone, F> Clone for BatchFreeze<K, V, T, R, B, F> {
+impl<B: Clone, F> Clone for BatchFreeze<B, F> {
     fn clone(&self) -> Self {
         BatchFreeze {
-            phantom: ::std::marker::PhantomData,
             batch: self.batch.clone(),
             func: self.func.clone(),
         }
     }
 }
 
-impl<K, V, T, R, B, F> BatchReader<K, V, T, R> for BatchFreeze<K, V, T, R, B, F>
-where
-    B: BatchReader<K, V, T, R>,
-    T: Clone,
-    F: Fn(&T)->Option<T>,
-{
-    type Cursor = BatchCursorFreeze<K, V, T, R, B, F>;
+impl<B: BatchReader, F: Fn(&B::Time) -> Option<B::Time>> BatchReader for BatchFreeze<B, F> {
+    type Key = B::Key;
+    type Val = B::Val;
+    type Time = B::Time;
+    type R = B::R;
+
+    type Cursor = BatchCursorFreeze<Self::Key, Self::Val, Self::Time, Self::R, B, F>;
 
     fn cursor(&self) -> Self::Cursor {
         BatchCursorFreeze::new(self.batch.cursor(), self.func.clone())
     }
     fn len(&self) -> usize { self.batch.len() }
-    fn description(&self) -> &Description<T> { self.batch.description() }
+    fn description(&self) -> &Description<Self::Time> { self.batch.description() }
 }
 
-impl<K, V, T, R, B, F> BatchFreeze<K, V, T, R, B, F>
-where
-    B: BatchReader<K, V, T, R>,
-    T: Clone,
-    F: Fn(&T)->Option<T>
-{
+impl<B: BatchReader, F: Fn(&B::Time) -> Option<B::Time>> BatchFreeze<B, F> {
     /// Makes a new batch wrapper
     pub fn make_from(batch: B, func: Rc<F>) -> Self {
         BatchFreeze {
-            phantom: ::std::marker::PhantomData,
             batch: batch,
             func: func,
         }
@@ -236,13 +227,13 @@ where
 
 
 /// Wrapper to provide cursor to nested scope.
-pub struct BatchCursorFreeze<K, V, T, R, B: BatchReader<K, V, T, R>, F> {
+pub struct BatchCursorFreeze<K, V, T, R, B: BatchReader<Key=K, Val=V, Time=T, R=R>, F> {
     phantom: ::std::marker::PhantomData<(K, V, R, T)>,
     cursor: B::Cursor,
     func: Rc<F>,
 }
 
-impl<K, V, T, R, B: BatchReader<K, V, T, R>, F> BatchCursorFreeze<K, V, T, R, B, F> {
+impl<K, V, T, R, B: BatchReader<Key=K, Val=V, Time=T, R=R>, F> BatchCursorFreeze<K, V, T, R, B, F> {
     fn new(cursor: B::Cursor, func: Rc<F>) -> Self {
         BatchCursorFreeze {
             phantom: ::std::marker::PhantomData,
@@ -252,12 +243,12 @@ impl<K, V, T, R, B: BatchReader<K, V, T, R>, F> BatchCursorFreeze<K, V, T, R, B,
     }
 }
 
-impl<K, V, T, R, B: BatchReader<K, V, T, R>, F> Cursor<K, V, T, R> for BatchCursorFreeze<K, V, T, R, B, F>
+impl<K, V, T, R, B: BatchReader<Key=K, Val=V, Time=T, R=R>, F> Cursor<K, V, T, R> for BatchCursorFreeze<K, V, T, R, B, F>
 where
     F: Fn(&T)->Option<T>,
 {
 
-    type Storage = BatchFreeze<K, V, T, R, B, F>;
+    type Storage = BatchFreeze<B, F>;
 
     #[inline] fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.key_valid(&storage.batch) }
     #[inline] fn val_valid(&self, storage: &Self::Storage) -> bool { self.cursor.val_valid(&storage.batch) }
diff --git a/src/trace/wrappers/frontier.rs b/src/trace/wrappers/frontier.rs
index 43ed2096b..d54c79beb 100644
--- a/src/trace/wrappers/frontier.rs
+++ b/src/trace/wrappers/frontier.rs
@@ -47,7 +47,7 @@ where
     type Time = Tr::Time;
     type R = Tr::R;
 
-    type Batch = BatchFrontier<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Batch>;
+    type Batch = BatchFrontier<Tr::Batch>;
     type Cursor = CursorFrontier<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Cursor>;
 
     fn map_batches<F: FnMut(&Self::Batch)>(&self, mut f: F) {
@@ -83,45 +83,37 @@ where
 
 
 /// Wrapper to provide batch to nested scope.
-pub struct BatchFrontier<K, V, T, R, B> {
-    phantom: ::std::marker::PhantomData<(K, V, T, R)>,
+#[derive(Clone)]
+pub struct BatchFrontier<B: BatchReader> {
     batch: B,
-    frontier: Antichain<T>,
+    frontier: Antichain<B::Time>,
 }
 
-impl<K, V, T: Clone, R, B: Clone> Clone for BatchFrontier<K, V, T, R, B> {
-    fn clone(&self) -> Self {
-        BatchFrontier {
-            phantom: ::std::marker::PhantomData,
-            batch: self.batch.clone(),
-            frontier: self.frontier.to_owned(),
-        }
-    }
-}
-
-impl<K, V, T, R, B> BatchReader<K, V, T, R> for BatchFrontier<K, V, T, R, B>
+impl<B: BatchReader> BatchReader for BatchFrontier<B>
 where
-    B: BatchReader<K, V, T, R>,
-    T: Timestamp+Lattice,
+    B::Time: Timestamp + Lattice
 {
-    type Cursor = BatchCursorFrontier<K, V, T, R, B>;
+    type Key = B::Key;
+    type Val = B::Val;
+    type Time = B::Time;
+    type R = B::R;
+
+    type Cursor = BatchCursorFrontier<Self::Key, Self::Val, Self::Time, Self::R, B>;
 
     fn cursor(&self) -> Self::Cursor {
         BatchCursorFrontier::new(self.batch.cursor(), self.frontier.borrow())
     }
     fn len(&self) -> usize { self.batch.len() }
-    fn description(&self) -> &Description<T> { &self.batch.description() }
+    fn description(&self) -> &Description<Self::Time> { &self.batch.description() }
 }
 
-impl<K, V, T, R, B> BatchFrontier<K, V, T, R, B>
+impl<B: BatchReader> BatchFrontier<B>
 where
-    B: BatchReader<K, V, T, R>,
-    T: Timestamp+Lattice,
+    B::Time: Timestamp+Lattice
 {
     /// Makes a new batch wrapper
-    pub fn make_from(batch: B, frontier: AntichainRef<T>) -> Self {
+    pub fn make_from(batch: B, frontier: AntichainRef<B::Time>) -> Self {
         BatchFrontier {
-            phantom: ::std::marker::PhantomData,
             batch,
             frontier: frontier.to_owned(),
         }
@@ -182,13 +174,13 @@ where
 
 
 /// Wrapper to provide cursor to nested scope.
-pub struct BatchCursorFrontier<K, V, T, R, B: BatchReader<K, V, T, R>> {
+pub struct BatchCursorFrontier<K, V, T, R, B: BatchReader<Key=K, Val=V, Time=T, R=R>> {
     phantom: ::std::marker::PhantomData<(K, V, R)>,
     cursor: B::Cursor,
     frontier: Antichain<T>,
 }
 
-impl<K, V, T: Clone, R, B: BatchReader<K, V, T, R>> BatchCursorFrontier<K, V, T, R, B> {
+impl<K, V, T: Clone, R, B: BatchReader<Key=K, Val=V, Time=T, R=R>> BatchCursorFrontier<K, V, T, R, B> {
     fn new(cursor: B::Cursor, frontier: AntichainRef<T>) -> Self {
         BatchCursorFrontier {
             phantom: ::std::marker::PhantomData,
@@ -198,11 +190,11 @@ impl<K, V, T: Clone, R, B: BatchReader<K, V, T, R>> BatchCursorFrontier<K, V, T,
     }
 }
 
-impl<K, V, T, R, B: BatchReader<K, V, T, R>> Cursor<K, V, T, R> for BatchCursorFrontier<K, V, T, R, B>
+impl<K, V, T, R, B: BatchReader<Key=K, Val=V, Time=T, R=R>> Cursor<K, V, T, R> for BatchCursorFrontier<K, V, T, R, B>
 where
     T: Timestamp+Lattice,
 {
-    type Storage = BatchFrontier<K, V, T, R, B>;
+    type Storage = BatchFrontier<B>;
 
     #[inline] fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.key_valid(&storage.batch) }
     #[inline] fn val_valid(&self, storage: &Self::Storage) -> bool { self.cursor.val_valid(&storage.batch) }
diff --git a/tests/trace.rs b/tests/trace.rs
index 1c22f4665..db4d5a90e 100644
--- a/tests/trace.rs
+++ b/tests/trace.rs
@@ -19,7 +19,7 @@ fn get_trace() -> Spine<u64, u64, usize, i64, Rc<OrdValBatch<u64, u64, usize, i6
     let op_info = OperatorInfo::new(0, 0, &[]);
     let mut trace = IntegerTrace::new(op_info, None, None);
     {
-        let mut batcher = <<IntegerTrace as TraceReader>::Batch as Batch<u64, u64, usize, i64>>::Batcher::new();
+        let mut batcher = <<IntegerTrace as TraceReader>::Batch as Batch>::Batcher::new();
 
         batcher.push_batch(&mut vec![
             ((1, 2), 0, 1),