diff --git a/dogsdogsdogs/src/operators/count.rs b/dogsdogsdogs/src/operators/count.rs
index bae14c7b3..d86fb5089 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::TraceReader;
 
 /// Reports a number of extensions to a stream of prefixes.
 ///
@@ -23,8 +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,
     P: ExchangeData,
diff --git a/dogsdogsdogs/src/operators/half_join.rs b/dogsdogsdogs/src/operators/half_join.rs
index 8f6f4d0cf..338a994aa 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,8 +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,
     CF: Fn(&G::Timestamp, &G::Timestamp) -> bool + 'static,
@@ -137,8 +135,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,
     CF: Fn(&G::Timestamp, &G::Timestamp) -> bool + 'static,
diff --git a/dogsdogsdogs/src/operators/lookup_map.rs b/dogsdogsdogs/src/operators/lookup_map.rs
index 671e24921..029e1f942 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,8 +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,
     D: ExchangeData,
diff --git a/dogsdogsdogs/src/operators/propose.rs b/dogsdogsdogs/src/operators/propose.rs
index cf7e793c8..2a5e6747a 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::TraceReader;
 
 /// Proposes extensions to a prefix stream.
 ///
@@ -25,8 +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,
     P: ExchangeData,
@@ -58,8 +56,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,
     P: ExchangeData,
diff --git a/dogsdogsdogs/src/operators/validate.rs b/dogsdogsdogs/src/operators/validate.rs
index 7152f1876..41efa8df2 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::TraceReader;
 
 /// Proposes extensions to a stream of prefixes.
 ///
@@ -24,8 +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,
     P: ExchangeData,
diff --git a/examples/cursors.rs b/examples/cursors.rs
index 29e9ddc00..5ab55b5e6 100644
--- a/examples/cursors.rs
+++ b/examples/cursors.rs
@@ -43,7 +43,7 @@ use timely::progress::frontier::AntichainRef;
 use differential_dataflow::input::Input;
 use differential_dataflow::operators::arrange::ArrangeByKey;
 use differential_dataflow::operators::*;
-use differential_dataflow::trace::cursor::CursorDebug;
+use differential_dataflow::trace::cursor::Cursor;
 use differential_dataflow::trace::TraceReader;
 
 type Node = u32;
diff --git a/src/algorithms/graphs/bfs.rs b/src/algorithms/graphs/bfs.rs
index 2931922a8..6774f535f 100644
--- a/src/algorithms/graphs/bfs.rs
+++ b/src/algorithms/graphs/bfs.rs
@@ -30,8 +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
     let nodes = roots.map(|x| (x, 0));
diff --git a/src/algorithms/graphs/bijkstra.rs b/src/algorithms/graphs/bijkstra.rs
index 91e02dbde..eb803f160 100644
--- a/src/algorithms/graphs/bijkstra.rs
+++ b/src/algorithms/graphs/bijkstra.rs
@@ -46,8 +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
         .stream
diff --git a/src/algorithms/graphs/propagate.rs b/src/algorithms/graphs/propagate.rs
index c94e49814..62bd92283 100644
--- a/src/algorithms/graphs/propagate.rs
+++ b/src/algorithms/graphs/propagate.rs
@@ -65,8 +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,
 {
     // Morally the code performs the following iterative computation. However, in the interest of a simplified
diff --git a/src/operators/arrange/agent.rs b/src/operators/arrange/agent.rs
index 13c3b02cd..8016c12cc 100644
--- a/src/operators/arrange/agent.rs
+++ b/src/operators/arrange/agent.rs
@@ -77,7 +77,7 @@ where
     fn get_physical_compaction(&mut self) -> AntichainRef<Tr::Time> {
         self.physical_compaction.borrow()
     }
-    fn cursor_through(&mut self, frontier: AntichainRef<Tr::Time>) -> Option<(Tr::Cursor, <Tr::Cursor as Cursor<Tr::Key, Tr::Val, Tr::Time, Tr::R>>::Storage)> {
+    fn cursor_through(&mut self, frontier: AntichainRef<Tr::Time>) -> Option<(Tr::Cursor, <Tr::Cursor as Cursor>::Storage)> {
         self.trace.borrow_mut().trace.cursor_through(frontier)
     }
     fn map_batches<F: FnMut(&Self::Batch)>(&self, f: F) { self.trace.borrow().trace.map_batches(f) }
@@ -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..d452c7113 100644
--- a/src/operators/arrange/arrangement.rs
+++ b/src/operators/arrange/arrangement.rs
@@ -65,8 +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 {
         Arranged {
@@ -83,8 +81,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.
     ///
@@ -405,7 +401,7 @@ where
 
                 // Determine new frontier on queries that may be issued.
                 // TODO: This code looks very suspect; explain better or fix.
-                let frontier = std::array::IntoIter::new([
+                let frontier = IntoIterator::into_iter([
                     capability.as_ref().map(|c| c.time().clone()),
                     input1.frontier().frontier().get(0).cloned(),
                 ]).filter_map(|t| t).min();
@@ -425,8 +421,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,8 +456,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::Cursor: Cursor<K, V, G::Timestamp, R>,
+        Tr::Batch: Batch,
     {
         self.arrange_named("Arrange")
     }
@@ -479,8 +472,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::Cursor: Cursor<K, V, G::Timestamp, R>,
+        Tr::Batch: Batch,
     {
         let exchange = Exchange::new(move |update: &((K,V),G::Timestamp,R)| (update.0).0.hashed().into());
         self.arrange_core(exchange, name)
@@ -495,8 +487,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::Cursor: Cursor<K, V, G::Timestamp, R>,
+        Tr::Batch: Batch,
     ;
 }
 
@@ -512,8 +503,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::Cursor: Cursor<K, V, G::Timestamp, R>,
+        Tr::Batch: Batch,
     {
         // The `Arrange` operator is tasked with reacting to an advancing input
         // frontier by producing the sequence of batches whose lower and upper
@@ -547,7 +537,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,8 +674,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::Cursor: Cursor<K, (), G::Timestamp, R>,
+        Tr::Batch: Batch,
     {
         self.map(|k| (k, ()))
             .arrange_core(pact, name)
diff --git a/src/operators/arrange/upsert.rs b/src/operators/arrange/upsert.rs
index 978d9596f..468398ae6 100644
--- a/src/operators/arrange/upsert.rs
+++ b/src/operators/arrange/upsert.rs
@@ -145,8 +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::Cursor: Cursor<Tr::Key, Tr::Val, G::Timestamp, isize>,
+    Tr::Batch: Batch,
 {
     let mut reader: Option<TraceAgent<Tr>> = None;
 
@@ -252,7 +251,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..47864622b 100644
--- a/src/operators/count.rs
+++ b/src/operators/count.rs
@@ -74,8 +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..2db2560e1 100644
--- a/src/operators/join.rs
+++ b/src/operators/join.rs
@@ -190,8 +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>
     where Tr::Key: ExchangeData, Tr::R: Multiply<R2>, <Tr::R as Multiply<R2>>::Output: Semigroup, L: FnMut(&Tr::Key, &Tr::Val, &V2)->D+'static {
@@ -258,8 +256,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,
         R: Multiply<Tr2::R>,
@@ -311,8 +307,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,
         D: Data,
@@ -334,8 +328,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,
         R: Multiply<Tr2::R>,
@@ -351,8 +343,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,
         R: Semigroup,
@@ -374,15 +364,11 @@ 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>,
         <T1::R as Multiply<Tr2::R>>::Output: Semigroup,
@@ -401,8 +387,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,
         D: Data,
@@ -651,39 +635,39 @@ impl<G, T1> JoinCore<G, T1::Key, T1::Val, T1::R> for Arranged<G,T1>
 /// The structure wraps cursors which allow us to play out join computation at whatever rate we like.
 /// This allows us to avoid producing and buffering massive amounts of data, without giving the timely
 /// dataflow system a chance to run operators that can consume and aggregate the data.
-struct Deferred<K, V1, V2, T, R1, R2, R3, C1, C2, D>
+struct Deferred<K, T, R, C1, C2, D>
 where
-    V1: Ord+Clone,
-    V2: Ord+Clone,
     T: Timestamp+Lattice+Ord+Debug,
-    R1: Semigroup,
-    R2: Semigroup,
-    R3: Semigroup,
-    C1: Cursor<K, V1, T, R1>,
-    C2: Cursor<K, V2, T, R2>,
+    R: Semigroup,
+    C1: Cursor<Key=K, Time=T>,
+    C2: Cursor<Key=K, Time=T>,
+    C1::Val: Ord+Clone,
+    C2::Val: Ord+Clone,
+    C1::R: Semigroup,
+    C2::R: Semigroup,
     D: Ord+Clone+Data,
 {
-    phant: ::std::marker::PhantomData<(K, V1, V2, R1, R2)>,
+    phant: ::std::marker::PhantomData<K>,
     trace: C1,
     trace_storage: C1::Storage,
     batch: C2,
     batch_storage: C2::Storage,
     capability: Capability<T>,
     done: bool,
-    temp: Vec<((D, T), R3)>,
+    temp: Vec<((D, T), R)>,
 }
 
-impl<K, V1, V2, T, R1, R2, R3, C1, C2, D> Deferred<K, V1, V2, T, R1, R2, R3, C1, C2, D>
+impl<K, T, R, C1, C2, D> Deferred<K, T, R, C1, C2, D>
 where
     K: Ord+Debug+Eq,
-    V1: Ord+Clone+Debug,
-    V2: Ord+Clone+Debug,
+    C1: Cursor<Key=K, Time=T>,
+    C2: Cursor<Key=K, Time=T>,
+    C1::Val: Ord+Clone+Debug,
+    C2::Val: Ord+Clone+Debug,
+    C1::R: Semigroup,
+    C2::R: Semigroup,
     T: Timestamp+Lattice+Ord+Debug,
-    R1: Semigroup,
-    R2: Semigroup,
-    R3: Semigroup,
-    C1: Cursor<K, V1, T, R1>,
-    C2: Cursor<K, V2, T, R2>,
+    R: Semigroup,
     D: Clone+Data,
 {
     fn new(trace: C1, trace_storage: C1::Storage, batch: C2, batch_storage: C2::Storage, capability: Capability<T>) -> Self {
@@ -705,8 +689,8 @@ where
 
     /// Process keys until at least `fuel` output tuples produced, or the work is exhausted.
     #[inline(never)]
-    fn work<L, I>(&mut self, output: &mut OutputHandle<T, (D, T, R3), Tee<T, (D, T, R3)>>, mut logic: L, fuel: &mut usize)
-    where I: IntoIterator<Item=(D, T, R3)>, L: FnMut(&K, &V1, &V2, &T, &R1, &R2)->I {
+    fn work<L, I>(&mut self, output: &mut OutputHandle<T, (D, T, R), Tee<T, (D, T, R)>>, mut logic: L, fuel: &mut usize)
+    where I: IntoIterator<Item=(D, T, R)>, L: FnMut(&K, &C1::Val, &C2::Val, &T, &C1::R, &C2::R)->I {
 
         let meet = self.capability.time();
 
diff --git a/src/operators/mod.rs b/src/operators/mod.rs
index 967370e85..96f0acc93 100644
--- a/src/operators/mod.rs
+++ b/src/operators/mod.rs
@@ -39,8 +39,8 @@ impl<'a, V:'a, T, R> EditList<'a, V, T, R> where T: Ord+Clone, R: Semigroup {
         }
     }
     /// Loads the contents of a cursor.
-    fn load<K, C, L>(&mut self, cursor: &mut C, storage: &'a C::Storage, logic: L)
-    where K: Eq, V: Clone, C: Cursor<K, V, T, R>, L: Fn(&T)->T {
+    fn load<C, L>(&mut self, cursor: &mut C, storage: &'a C::Storage, logic: L)
+    where V: Clone, C: Cursor<Val=V, Time=T, R=R>, C::Key: Eq, L: Fn(&T)->T {
         self.clear();
         while cursor.val_valid(storage) {
             cursor.map_times(storage, |time1, diff1| self.push(logic(time1), diff1.clone()));
@@ -102,22 +102,22 @@ impl<'storage, V: Ord+Clone+'storage, T: Lattice+Ord+Clone, R: Semigroup> ValueH
         self.history.clear();
         self.buffer.clear();
     }
-    fn load<K, C, L>(&mut self, cursor: &mut C, storage: &'storage C::Storage, logic: L)
-    where K: Eq, C: Cursor<K, V, T, R>, L: Fn(&T)->T {
+    fn load<C, L>(&mut self, cursor: &mut C, storage: &'storage C::Storage, logic: L)
+    where C: Cursor<Val=V, Time=T, R=R>, C::Key: Eq, L: Fn(&T)->T {
         self.edits.load(cursor, storage, logic);
     }
 
     /// Loads and replays a specified key.
     ///
     /// If the key is absent, the replayed history will be empty.
-    fn replay_key<'history, K, C, L>(
+    fn replay_key<'history, C, L>(
         &'history mut self,
         cursor: &mut C,
         storage: &'storage C::Storage,
-        key: &K,
+        key: &C::Key,
         logic: L
     ) -> HistoryReplay<'storage, 'history, V, T, R>
-    where K: Eq, C: Cursor<K, V, T, R>, L: Fn(&T)->T
+    where C: Cursor<Val=V, Time=T, R=R>, C::Key: Eq, L: Fn(&T)->T
     {
         self.clear();
         cursor.seek_key(storage, key);
diff --git a/src/operators/reduce.rs b/src/operators/reduce.rs
index f8d9edeb1..2b5ea9aa2 100644
--- a/src/operators/reduce.rs
+++ b/src/operators/reduce.rs
@@ -90,8 +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>
         where L: FnMut(&K, &[(&V, R)], &mut Vec<(V2, R2)>)+'static {
@@ -179,8 +177,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> {
         self.reduce_abelian::<_,DefaultKeyTrace<_,_,_>>(name, move |k,s,t| t.push(((), thresh(k, &s[0].1))))
@@ -236,8 +232,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> {
         self.reduce_abelian::<_,DefaultValTrace<_,_,_,_>>("Count", |_k,s,t| t.push((s[0].1.clone(), R2::from(1i8))))
@@ -282,8 +276,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::Cursor: Cursor<K, T2::Val, G::Timestamp, T2::R>,
+            T2::Batch: Batch,
             L: FnMut(&K, &[(&V, R)], &mut Vec<(T2::Val, T2::R)>)+'static,
         {
             self.reduce_core::<_,T2>(name, move |key, input, output, change| {
@@ -305,8 +298,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::Cursor: Cursor<K, T2::Val, G::Timestamp, T2::R>,
+            T2::Batch: Batch,
             L: FnMut(&K, &[(&V, R)], &mut Vec<(T2::Val,T2::R)>, &mut Vec<(T2::Val,T2::R)>)+'static
             ;
 }
@@ -324,8 +316,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::Cursor: Cursor<K, T2::Val, G::Timestamp, T2::R>,
+            T2::Batch: Batch,
             L: FnMut(&K, &[(&V, R)], &mut Vec<(T2::Val,T2::R)>, &mut Vec<(T2::Val, T2::R)>)+'static
     {
         self.arrange_by_key_named(&format!("Arrange: {}", name))
@@ -337,16 +328,13 @@ 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>>
         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::Cursor: Cursor<K, T2::Val, G::Timestamp, T2::R>,
+            T2::Batch: Batch,
             L: FnMut(&K, &[(&V, R)], &mut Vec<(T2::Val,T2::R)>, &mut Vec<(T2::Val, T2::R)>)+'static {
 
         let mut result_trace = None;
@@ -488,7 +476,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.
@@ -682,9 +670,9 @@ where
         new_interesting: &mut Vec<T>) -> (usize, usize)
     where
         K: Eq+Clone,
-        C1: Cursor<K, V1, T, R1>,
-        C2: Cursor<K, V2, T, R2>,
-        C3: Cursor<K, V1, T, R1>,
+        C1: Cursor<Key = K, Val = V1, Time = T, R = R1>,
+        C2: Cursor<Key = K, Val = V2, Time = T, R = R2>,
+        C3: Cursor<Key = K, Val = V1, Time = T, R = R1>,
         L: FnMut(&K, &[(&V1, R1)], &mut Vec<(V2, R2)>, &mut Vec<(V2, R2)>);
 }
 
@@ -760,9 +748,9 @@ mod history_replay {
             new_interesting: &mut Vec<T>) -> (usize, usize)
         where
             K: Eq+Clone,
-            C1: Cursor<K, V1, T, R1>,
-            C2: Cursor<K, V2, T, R2>,
-            C3: Cursor<K, V1, T, R1>,
+            C1: Cursor<Key = K, Val = V1, Time = T, R = R1>,
+            C2: Cursor<Key = K, Val = V2, Time = T, R = R2>,
+            C3: Cursor<Key = K, Val = V1, Time = T, R = R1>,
             L: FnMut(&K, &[(&V1, R1)], &mut Vec<(V2, R2)>, &mut Vec<(V2, R2)>)
         {
 
diff --git a/src/operators/threshold.rs b/src/operators/threshold.rs
index 427093a04..cbe1b8d8f 100644
--- a/src/operators/threshold.rs
+++ b/src/operators/threshold.rs
@@ -108,8 +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>
     where
diff --git a/src/trace/cursor/cursor_list.rs b/src/trace/cursor/cursor_list.rs
index a7685c6f1..a7adf8cc1 100644
--- a/src/trace/cursor/cursor_list.rs
+++ b/src/trace/cursor/cursor_list.rs
@@ -7,19 +7,17 @@ use super::Cursor;
 /// The `CursorList` tracks the indices of cursors with the minimum key, and the the indices of cursors with
 /// the minimum key and minimum value. It performs no clever management of these sets otherwise.
 #[derive(Debug)]
-pub struct CursorList<K, V, T, R, C: Cursor<K, V, T, R>> {
-    _phantom: ::std::marker::PhantomData<(K, V, T, R)>,
+pub struct CursorList<C: Cursor> {
     cursors: Vec<C>,
     min_key: Vec<usize>,
     min_val: Vec<usize>,
 }
 
-impl<K, V, T, R, C: Cursor<K, V, T, R>> CursorList<K, V, T, R, C> where K: Ord, V: Ord {
+impl<C: Cursor> CursorList<C> where C::Key: Ord, C::Val: Ord {
     /// Creates a new cursor list from pre-existing cursors.
     pub fn new(cursors: Vec<C>, storage: &[C::Storage]) -> Self {
 
         let mut result = CursorList {
-            _phantom: ::std::marker::PhantomData,
             cursors,
             min_key: Vec::new(),
             min_val: Vec::new(),
@@ -43,7 +41,7 @@ impl<K, V, T, R, C: Cursor<K, V, T, R>> CursorList<K, V, T, R, C> where K: Ord,
         self.min_key.clear();
 
         // Determine the index of the cursor with minimum key.
-        let mut min_key_opt: Option<&K> = None;
+        let mut min_key_opt = None;
         for (index, cursor) in self.cursors.iter().enumerate() {
             let key = cursor.get_key(&storage[index]);
             if key.is_some() {
@@ -71,7 +69,7 @@ impl<K, V, T, R, C: Cursor<K, V, T, R>> CursorList<K, V, T, R, C> where K: Ord,
         self.min_val.clear();
 
         // Determine the index of the cursor with minimum value.
-        let mut min_val: Option<&V> = None;
+        let mut min_val = None;
         for &index in self.min_key.iter() {
             let val = self.cursors[index].get_val(&storage[index]);
             if val.is_some() {
@@ -87,10 +85,15 @@ impl<K, V, T, R, C: Cursor<K, V, T, R>> CursorList<K, V, T, R, C> where K: Ord,
     }
 }
 
-impl<K, V, T, R, C: Cursor<K, V, T, R>> Cursor<K, V, T, R> for CursorList<K, V, T, R, C>
+impl<C: Cursor> Cursor for CursorList<C>
 where
-    K: Ord,
-    V: Ord {
+    C::Key: Ord,
+    C::Val: Ord,
+{
+    type Key = C::Key;
+    type Val = C::Val;
+    type Time = C::Time;
+    type R = C::R;
 
     type Storage = Vec<C::Storage>;
 
@@ -102,20 +105,20 @@ where
 
     // accessors
     #[inline]
-    fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K {
+    fn key<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Key {
         debug_assert!(self.key_valid(storage));
         debug_assert!(self.cursors[self.min_key[0]].key_valid(&storage[self.min_key[0]]));
         self.cursors[self.min_key[0]].key(&storage[self.min_key[0]])
     }
     #[inline]
-    fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V {
+    fn val<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Val {
         debug_assert!(self.key_valid(storage));
         debug_assert!(self.val_valid(storage));
         debug_assert!(self.cursors[self.min_val[0]].val_valid(&storage[self.min_val[0]]));
         self.cursors[self.min_val[0]].val(&storage[self.min_val[0]])
     }
     #[inline]
-    fn map_times<L: FnMut(&T, &R)>(&mut self, storage: &Self::Storage, mut logic: L) {
+    fn map_times<L: FnMut(&Self::Time, &Self::R)>(&mut self, storage: &Self::Storage, mut logic: L) {
         for &index in self.min_val.iter() {
             self.cursors[index].map_times(&storage[index], |t,d| logic(t,d));
         }
@@ -130,7 +133,7 @@ where
         self.minimize_keys(storage);
     }
     #[inline]
-    fn seek_key(&mut self, storage: &Self::Storage, key: &K) {
+    fn seek_key(&mut self, storage: &Self::Storage, key: &Self::Key) {
         for index in 0 .. self.cursors.len() {
             self.cursors[index].seek_key(&storage[index], key);
         }
@@ -146,7 +149,7 @@ where
         self.minimize_vals(storage);
     }
     #[inline]
-    fn seek_val(&mut self, storage: &Self::Storage, val: &V) {
+    fn seek_val(&mut self, storage: &Self::Storage, val: &Self::Val) {
         for &index in self.min_key.iter() {
             self.cursors[index].seek_val(&storage[index], val);
         }
diff --git a/src/trace/cursor/cursor_pair.rs b/src/trace/cursor/cursor_pair.rs
index 1ae361c7f..c34f03abb 100644
--- a/src/trace/cursor/cursor_pair.rs
+++ b/src/trace/cursor/cursor_pair.rs
@@ -15,13 +15,18 @@ pub struct CursorPair<C1, C2> {
     val_order: Ordering,    // Invalid vals are `Greater` than all other vals. `Equal` implies both valid.
 }
 
-impl<K, V, T, R, C1, C2> Cursor<K, V, T, R> for CursorPair<C1, C2>
+impl<K, V, T, R, C1, C2> Cursor for CursorPair<C1, C2>
 where
     K: Ord,
     V: Ord,
-    C1: Cursor<K, V, T, R>,
-    C2: Cursor<K, V, T, R>,
+    C1: Cursor<Key = K, Val = V, Time = T, R = R>,
+    C2: Cursor<Key = K, Val = V, Time = T, R = R>,
 {
+    type Key = K;
+    type Val = V;
+    type Time = T;
+    type R = R;
+
     type Storage = (C1::Storage, C2::Storage);
 
     // validation methods
diff --git a/src/trace/cursor/mod.rs b/src/trace/cursor/mod.rs
index d76e7cab0..a71ca2dad 100644
--- a/src/trace/cursor/mod.rs
+++ b/src/trace/cursor/mod.rs
@@ -12,7 +12,16 @@ pub mod cursor_list;
 pub use self::cursor_list::CursorList;
 
 /// A cursor for navigating ordered `(key, val, time, diff)` updates.
-pub trait Cursor<K, V, T, R> {
+pub trait Cursor {
+
+    /// Key by which updates are indexed.
+    type Key;
+    /// Values associated with keys.
+    type Val;
+    /// Timestamps associated with updates
+    type Time;
+    /// Associated update.
+    type R;
 
     /// Type the cursor addresses data in.
     type Storage;
@@ -27,43 +36,46 @@ pub trait Cursor<K, V, T, R> {
     fn val_valid(&self, storage: &Self::Storage) -> bool;
 
     /// A reference to the current key. Asserts if invalid.
-    fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K;
+    fn key<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Key;
     /// A reference to the current value. Asserts if invalid.
-    fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V;
+    fn val<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Val;
 
     /// Returns a reference to the current key, if valid.
-    fn get_key<'a>(&self, storage: &'a Self::Storage) -> Option<&'a K> {
+    fn get_key<'a>(&self, storage: &'a Self::Storage) -> Option<&'a Self::Key> {
         if self.key_valid(storage) { Some(self.key(storage)) } else { None }
     }
     /// Returns a reference to the current value, if valid.
-    fn get_val<'a>(&self, storage: &'a Self::Storage) -> Option<&'a V> {
+    fn get_val<'a>(&self, storage: &'a Self::Storage) -> Option<&'a Self::Val> {
         if self.val_valid(storage) { Some(self.val(storage)) } else { None }
     }
 
     /// Applies `logic` to each pair of time and difference. Intended for mutation of the
     /// closure's scope.
-    fn map_times<L: FnMut(&T, &R)>(&mut self, storage: &Self::Storage, logic: L);
+    fn map_times<L: FnMut(&Self::Time, &Self::R)>(&mut self, storage: &Self::Storage, logic: L);
 
     /// Advances the cursor to the next key.
     fn step_key(&mut self, storage: &Self::Storage);
     /// Advances the cursor to the specified key.
-    fn seek_key(&mut self, storage: &Self::Storage, key: &K);
+    fn seek_key(&mut self, storage: &Self::Storage, key: &Self::Key);
 
     /// Advances the cursor to the next value.
     fn step_val(&mut self, storage: &Self::Storage);
     /// Advances the cursor to the specified value.
-    fn seek_val(&mut self, storage: &Self::Storage, val: &V);
+    fn seek_val(&mut self, storage: &Self::Storage, val: &Self::Val);
 
     /// Rewinds the cursor to the first key.
     fn rewind_keys(&mut self, storage: &Self::Storage);
     /// Rewinds the cursor to the first value for current key.
     fn rewind_vals(&mut self, storage: &Self::Storage);
-}
 
-/// Debugging and testing utilities for Cursor.
-pub trait CursorDebug<K: Clone, V: Clone, T: Clone, R: Clone> : Cursor<K, V, T, R> {
     /// Rewinds the cursor and outputs its contents to a Vec
-    fn to_vec(&mut self, storage: &Self::Storage) -> Vec<((K, V), Vec<(T, R)>)> {
+    fn to_vec(&mut self, storage: &Self::Storage) -> Vec<((Self::Key, Self::Val), Vec<(Self::Time, Self::R)>)>
+    where
+        Self::Key: Clone,
+        Self::Val: Clone,
+        Self::Time: Clone,
+        Self::R: Clone,
+    {
         let mut out = Vec::new();
         self.rewind_keys(storage);
         self.rewind_vals(storage);
@@ -81,5 +93,3 @@ pub trait CursorDebug<K: Clone, V: Clone, T: Clone, R: Clone> : Cursor<K, V, T,
         out
     }
 }
-
-impl<C, K: Clone, V: Clone, T: Clone, R: Clone> CursorDebug<K, V, T, R> for C where C: Cursor<K, V, T, R> { }
diff --git a/src/trace/implementations/merge_batcher.rs b/src/trace/implementations/merge_batcher.rs
index 14ccc0f3a..f1f2264ff 100644
--- a/src/trace/implementations/merge_batcher.rs
+++ b/src/trace/implementations/merge_batcher.rs
@@ -8,32 +8,32 @@ 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>> {
-    sorter: MergeSorter<(K, V), T, R>,
-    lower: Antichain<T>,
-    frontier: Antichain<T>,
+pub struct MergeBatcher<B: Batch> where B::Key: Ord, B::Val: Ord, B::Time: Ord, B::R: Semigroup {
+    sorter: MergeSorter<(B::Key, B::Val), B::Time, B::R>,
+    lower: Antichain<B::Time>,
+    frontier: Antichain<B::Time>,
     phantom: ::std::marker::PhantomData<B>,
 }
 
-impl<K, V, T, R, B> Batcher<K, V, T, R, B> for MergeBatcher<K, V, T, R, B>
+impl<B> Batcher<B> for MergeBatcher<B>
 where
-    K: Ord+Clone,
-    V: Ord+Clone,
-    T: Lattice+timely::progress::Timestamp+Ord+Clone,
-    R: Semigroup,
-    B: Batch<K, V, T, R>,
+    B: Batch,
+    B::Key: Ord+Clone,
+    B::Val: Ord+Clone,
+    B::Time: Lattice+timely::progress::Timestamp+Ord+Clone,
+    B::R: Semigroup,
 {
     fn new() -> Self {
         MergeBatcher {
             sorter: MergeSorter::new(),
             frontier: Antichain::new(),
-            lower: Antichain::from_elem(T::minimum()),
+            lower: Antichain::from_elem(<B::Time as timely::progress::Timestamp>::minimum()),
             phantom: ::std::marker::PhantomData,
         }
     }
 
     #[inline(never)]
-    fn push_batch(&mut self, batch: &mut Vec<((K,V),T,R)>) {
+    fn push_batch(&mut self, batch: &mut Vec<((B::Key,B::Val),B::Time,B::R)>) {
         self.sorter.push(batch);
     }
 
@@ -42,7 +42,7 @@ where
     // which we call `lower`, by assumption that after sealing a batcher we receive no more
     // updates with times not greater or equal to `upper`.
     #[inline(never)]
-    fn seal(&mut self, upper: Antichain<T>) -> B {
+    fn seal(&mut self, upper: Antichain<B::Time>) -> B {
 
         let mut builder = B::Builder::new();
 
@@ -92,18 +92,18 @@ where
         let mut buffer = Vec::new();
         self.sorter.push(&mut buffer);
         // We recycle buffers with allocations (capacity, and not zero-sized).
-        while buffer.capacity() > 0 && std::mem::size_of::<((K,V),T,R)>() > 0 {
+        while buffer.capacity() > 0 && std::mem::size_of::<((B::Key,B::Val),B::Time,B::R)>() > 0 {
             buffer = Vec::new();
             self.sorter.push(&mut buffer);
         }
 
-        let seal = builder.done(self.lower.clone(), upper.clone(), Antichain::from_elem(T::minimum()));
+        let seal = builder.done(self.lower.clone(), upper.clone(), Antichain::from_elem(<B::Time as timely::progress::Timestamp>::minimum()));
         self.lower = upper;
         seal
     }
 
     // the frontier of elements remaining after the most recent call to `self.seal`.
-    fn frontier(&mut self) -> timely::progress::frontier::AntichainRef<T> {
+    fn frontier(&mut self) -> timely::progress::frontier::AntichainRef<B::Time> {
         self.frontier.borrow()
     }
 }
diff --git a/src/trace/implementations/ord.rs b/src/trace/implementations/ord.rs
index f394d2365..a7c4fcae1 100644
--- a/src/trace/implementations/ord.rs
+++ b/src/trace/implementations/ord.rs
@@ -35,16 +35,16 @@ use super::merge_batcher::MergeBatcher;
 use abomonation::abomonated::Abomonated;
 
 /// A trace implementation using a spine of ordered lists.
-pub type OrdValSpine<K, V, T, R, O=usize> = Spine<K, V, T, R, Rc<OrdValBatch<K, V, T, R, O>>>;
+pub type OrdValSpine<K, V, T, R, O=usize> = Spine<Rc<OrdValBatch<K, V, T, R, O>>>;
 
 /// A trace implementation using a spine of abomonated ordered lists.
-pub type OrdValSpineAbom<K, V, T, R, O=usize> = Spine<K, V, T, R, Rc<Abomonated<OrdValBatch<K, V, T, R, O>, Vec<u8>>>>;
+pub type OrdValSpineAbom<K, V, T, R, O=usize> = Spine<Rc<Abomonated<OrdValBatch<K, V, T, R, O>, Vec<u8>>>>;
 
 /// A trace implementation for empty values using a spine of ordered lists.
-pub type OrdKeySpine<K, T, R, O=usize> = Spine<K, (), T, R, Rc<OrdKeyBatch<K, T, R, O>>>;
+pub type OrdKeySpine<K, T, R, O=usize> = Spine<Rc<OrdKeyBatch<K, T, R, O>>>;
 
 /// A trace implementation for empty values using a spine of abomonated ordered lists.
-pub type OrdKeySpineAbom<K, T, R, O=usize> = Spine<K, (), T, R, Rc<Abomonated<OrdKeyBatch<K, T, R, O>, Vec<u8>>>>;
+pub type OrdKeySpineAbom<K, T, R, O=usize> = Spine<Rc<Abomonated<OrdKeyBatch<K, T, R, O>, Vec<u8>>>>;
 
 
 /// An immutable collection of update tuples, from a contiguous interval of logical times.
@@ -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 Cursor = OrdValCursor<V, T, R, O>;
-    fn cursor(&self) -> Self::Cursor { OrdValCursor { cursor: self.layer.cursor() } }
+    type Key = K;
+    type Val = V;
+    type Time = T;
+    type R = R;
+
+    type Cursor = OrdValCursor<K, V, T, R, O>;
+    fn cursor(&self) -> Self::Cursor { OrdValCursor { cursor: self.layer.cursor(), phantom: std::marker::PhantomData } }
     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,
@@ -84,7 +89,7 @@ where
     R: Semigroup,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-    type Batcher = MergeBatcher<K, V, T, R, Self>;
+    type Batcher = MergeBatcher<Self>;
     type Builder = OrdValBuilder<K, V, T, R, O>;
     type Merger = OrdValMerger<K, V, T, R, O>;
 
@@ -215,7 +220,7 @@ where
     should_compact: bool,
 }
 
-impl<K, V, T, R, O> Merger<K, V, T, R, OrdValBatch<K, V, T, R, O>> for OrdValMerger<K, V, T, R, O>
+impl<K, V, T, R, O> Merger<OrdValBatch<K, V, T, R, O>> for OrdValMerger<K, V, T, R, O>
 where
     K: Ord+Clone+'static,
     V: Ord+Clone+'static,
@@ -306,17 +311,18 @@ where
 
 /// A cursor for navigating a single layer.
 #[derive(Debug)]
-pub struct OrdValCursor<V, T, R, O=usize>
+pub struct OrdValCursor<K, V, T, R, O=usize>
 where
     V: Ord+Clone,
     T: Lattice+Ord+Clone,
     R: Semigroup,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
+    phantom: std::marker::PhantomData<K>,
     cursor: OrderedCursor<OrderedLayer<V, OrderedLeaf<T, R>, O>>,
 }
 
-impl<K, V, T, R, O> Cursor<K, V, T, R> for OrdValCursor<V, T, R, O>
+impl<K, V, T, R, O> Cursor for OrdValCursor<K, V, T, R, O>
 where
     K: Ord+Clone,
     V: Ord+Clone,
@@ -324,6 +330,11 @@ 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 Storage = OrdValBatch<K, V, T, R, O>;
 
     fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K { &self.cursor.key(&storage.layer) }
@@ -358,7 +369,7 @@ where
     builder: OrderedBuilder<K, OrderedBuilder<V, OrderedLeafBuilder<T, R>, O>, O>,
 }
 
-impl<K, V, T, R, O> Builder<K, V, T, R, OrdValBatch<K, V, T, R, O>> for OrdValBuilder<K, V, T, R, O>
+impl<K, V, T, R, O> Builder<OrdValBatch<K, V, T, R, O>> for OrdValBuilder<K, V, T, R, O>
 where
     K: Ord+Clone+'static,
     V: Ord+Clone+'static,
@@ -409,17 +420,21 @@ 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 Cursor = OrdKeyCursor<T, R, O>;
+    type Key = K;
+    type Val = ();
+    type Time = T;
+    type R = R;
+
+    type Cursor = OrdKeyCursor<K, T, R, O>;
     fn cursor(&self) -> Self::Cursor {
         OrdKeyCursor {
-            empty: (),
             valid: true,
             cursor: self.layer.cursor(),
             phantom: PhantomData
@@ -429,14 +444,14 @@ where
     fn description(&self) -> &Description<T> { &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,
     R: Semigroup,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-    type Batcher = MergeBatcher<K, (), T, R, Self>;
+    type Batcher = MergeBatcher<Self>;
     type Builder = OrdKeyBuilder<K, T, R, O>;
     type Merger = OrdKeyMerger<K, T, R, O>;
 
@@ -535,7 +550,7 @@ where
     should_compact: bool,
 }
 
-impl<K, T, R, O> Merger<K, (), T, R, OrdKeyBatch<K, T, R, O>> for OrdKeyMerger<K, T, R, O>
+impl<K, T, R, O> Merger<OrdKeyBatch<K, T, R, O>> for OrdKeyMerger<K, T, R, O>
 where
     K: Ord+Clone+'static,
     T: Lattice+timely::progress::Timestamp+Ord+Clone+'static,
@@ -632,25 +647,28 @@ where
 
 /// A cursor for navigating a single layer.
 #[derive(Debug)]
-pub struct OrdKeyCursor<T: Lattice+Ord+Clone, R: Semigroup, O=usize> {
+pub struct OrdKeyCursor<K, T: Lattice+Ord+Clone, R: Semigroup, O=usize> {
     valid: bool,
-    empty: (),
     cursor: OrderedCursor<OrderedLeaf<T, R>>,
-    phantom: PhantomData<O>
+    phantom: PhantomData<(K, O)>
 }
 
-impl<K, T, R, O> Cursor<K, (), T, R> for OrdKeyCursor<T, R, O>
+impl<K, T, R, O> Cursor for OrdKeyCursor<K, T, R, O>
 where
     K: Ord+Clone,
     T: Lattice+Ord+Clone,
     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 Storage = OrdKeyBatch<K, T, R, O>;
 
     fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K { &self.cursor.key(&storage.layer) }
-    fn val<'a>(&self, _storage: &'a Self::Storage) -> &'a () { unsafe { ::std::mem::transmute(&self.empty) } }
+    fn val<'a>(&self, _storage: &'a Self::Storage) -> &'a () { &() }
     fn map_times<L: FnMut(&T, &R)>(&mut self, storage: &Self::Storage, mut logic: L) {
         self.cursor.child.rewind(&storage.layer.vals);
         while self.cursor.child.valid(&storage.layer.vals) {
@@ -680,7 +698,7 @@ where
     builder: OrderedBuilder<K, OrderedLeafBuilder<T, R>, O>,
 }
 
-impl<K, T, R, O> Builder<K, (), T, R, OrdKeyBatch<K, T, R, O>> for OrdKeyBuilder<K, T, R, O>
+impl<K, T, R, O> Builder<OrdKeyBatch<K, T, R, O>> for OrdKeyBuilder<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..ba737293b 100644
--- a/src/trace/implementations/spine_fueled.rs
+++ b/src/trace/implementations/spine_fueled.rs
@@ -87,41 +87,40 @@ 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<B: Batch> where B::Time: Lattice+Ord, B::R: Semigroup {
     operator: OperatorInfo,
     logger: Option<Logger>,
-    phantom: ::std::marker::PhantomData<(K, V, R)>,
-    logical_frontier: Antichain<T>,                   // Times after which the trace must accumulate correctly.
-    physical_frontier: Antichain<T>,                   // Times after which the trace must be able to subset its inputs.
-    merging: Vec<MergeState<K,V,T,R,B>>,// Several possibly shared collections of updates.
-    pending: Vec<B>,                       // Batches at times in advance of `frontier`.
-    upper: Antichain<T>,
+    logical_frontier: Antichain<B::Time>,   // Times after which the trace must accumulate correctly.
+    physical_frontier: Antichain<B::Time>,  // Times after which the trace must be able to subset its inputs.
+    merging: Vec<MergeState<B>>,            // Several possibly shared collections of updates.
+    pending: Vec<B>,                        // Batches at times in advance of `frontier`.
+    upper: Antichain<B::Time>,
     effort: usize,
     activator: Option<timely::scheduling::activate::Activator>,
 }
 
-impl<K, V, T, R, B> TraceReader for Spine<K, V, T, R, B>
+impl<B> TraceReader for Spine<B>
 where
-    K: Ord+Clone,           // Clone is required by `batch::advance_*` (in-place could remove).
-    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+Clone+'static,
+    B::Key: Ord+Clone,           // Clone is required by `batch::advance_*` (in-place could remove).
+    B::Val: Ord+Clone,           // Clone is required by `batch::advance_*` (in-place could remove).
+    B::Time: Lattice+timely::progress::Timestamp+Ord+Clone+Debug,
+    B::R: Semigroup,
 {
-    type Key = K;
-    type Val = V;
-    type Time = T;
-    type R = R;
+    type Key = B::Key;
+    type Val = B::Val;
+    type Time = B::Time;
+    type R = B::R;
 
     type Batch = B;
-    type Cursor = CursorList<K, V, T, R, <B as BatchReader<K, V, T, R>>::Cursor>;
+    type Cursor = CursorList<<B as BatchReader>::Cursor>;
 
-    fn cursor_through(&mut self, upper: AntichainRef<T>) -> Option<(Self::Cursor, <Self::Cursor as Cursor<K, V, T, R>>::Storage)> {
+    fn cursor_through(&mut self, upper: AntichainRef<Self::Time>) -> Option<(Self::Cursor, <Self::Cursor as Cursor>::Storage)> {
 
         // If `upper` is the minimum frontier, we can return an empty cursor.
         // This can happen with operators that are written to expect the ability to acquire cursors
         // for their prior frontiers, and which start at `[T::minimum()]`, such as `Reduce`, sadly.
-        if upper.less_equal(&T::minimum()) {
+        if upper.less_equal(&<Self::Time as timely::progress::Timestamp>::minimum()) {
             let cursors = Vec::new();
             let storage = Vec::new();
             return Some((CursorList::new(cursors, &storage), storage));
@@ -211,19 +210,19 @@ where
 
         Some((CursorList::new(cursors, &storage), storage))
     }
-    fn set_logical_compaction(&mut self, frontier: AntichainRef<T>) {
+    fn set_logical_compaction(&mut self, frontier: AntichainRef<B::Time>) {
         self.logical_frontier.clear();
         self.logical_frontier.extend(frontier.iter().cloned());
     }
-    fn get_logical_compaction(&mut self) -> AntichainRef<T> { self.logical_frontier.borrow() }
-    fn set_physical_compaction(&mut self, frontier: AntichainRef<T>) {
+    fn get_logical_compaction(&mut self) -> AntichainRef<B::Time> { self.logical_frontier.borrow() }
+    fn set_physical_compaction(&mut self, frontier: AntichainRef<B::Time>) {
         // We should never request to rewind the frontier.
         debug_assert!(PartialOrder::less_equal(&self.physical_frontier.borrow(), &frontier), "FAIL\tthrough frontier !<= new frontier {:?} {:?}\n", self.physical_frontier, frontier);
         self.physical_frontier.clear();
         self.physical_frontier.extend(frontier.iter().cloned());
         self.consider_merges();
     }
-    fn get_physical_compaction(&mut self) -> AntichainRef<T> { self.physical_frontier.borrow() }
+    fn get_physical_compaction(&mut self) -> AntichainRef<B::Time> { self.physical_frontier.borrow() }
 
     fn map_batches<F: FnMut(&Self::Batch)>(&self, mut f: F) {
         for batch in self.merging.iter().rev() {
@@ -242,13 +241,13 @@ where
 
 // A trace implementation for any key type that can be borrowed from or converted into `Key`.
 // TODO: Almost all this implementation seems to be generic with respect to the trace and batch types.
-impl<K, V, T, R, B> Trace for Spine<K, V, T, R, B>
+impl<B> Trace for Spine<B>
 where
-    K: Ord+Clone,
-    V: Ord+Clone,
-    T: Lattice+timely::progress::Timestamp+Ord+Clone+Debug,
-    R: Semigroup,
-    B: Batch<K, V, T, R>+Clone+'static,
+    B: Batch+Clone+'static,
+    B::Key: Ord+Clone,
+    B::Val: Ord+Clone,
+    B::Time: Lattice+timely::progress::Timestamp+Ord+Clone+Debug,
+    B::R: Semigroup,
 {
     fn new(
         info: ::timely::dataflow::operators::generic::OperatorInfo,
@@ -311,18 +310,18 @@ where
         if !self.upper.borrow().is_empty() {
             use trace::Builder;
             let builder = B::Builder::new();
-            let batch = builder.done(self.upper.clone(), Antichain::new(), Antichain::from_elem(T::minimum()));
+            let batch = builder.done(self.upper.clone(), Antichain::new(), Antichain::from_elem(<Self::Time as timely::progress::Timestamp>::minimum()));
             self.insert(batch);
         }
     }
 }
 
 // Drop implementation allows us to log batch drops, to zero out maintained totals.
-impl<K, V, T, R, B> Drop for Spine<K, V, T, R, B>
+impl<B> Drop for Spine<B>
 where
-    T: Lattice+Ord,
-    R: Semigroup,
-    B: Batch<K, V, T, R>,
+    B: Batch,
+    B::Time: Lattice+Ord,
+    B::R: Semigroup,
 {
     fn drop(&mut self) {
         self.drop_batches();
@@ -330,11 +329,11 @@ where
 }
 
 
-impl<K, V, T, R, B> Spine<K, V, T, R, B>
+impl<B> Spine<B>
 where
-    T: Lattice+Ord,
-    R: Semigroup,
-    B: Batch<K, V, T, R>,
+    B: Batch,
+    B::Time: Lattice+Ord,
+    B::R: Semigroup,
 {
     /// Drops and logs batches. Used in `set_logical_compaction` and drop.
     fn drop_batches(&mut self) {
@@ -376,13 +375,13 @@ where
     }
 }
 
-impl<K, V, T, R, B> Spine<K, V, T, R, B>
+impl<B> Spine<B>
 where
-    K: Ord+Clone,
-    V: Ord+Clone,
-    T: Lattice+timely::progress::Timestamp+Ord+Clone+Debug,
-    R: Semigroup,
-    B: Batch<K, V, T, R>,
+    B: Batch,
+    B::Key: Ord+Clone,
+    B::Val: Ord+Clone,
+    B::Time: Lattice+timely::progress::Timestamp+Ord+Clone+Debug,
+    B::R: Semigroup,
 {
     /// True iff there is at most one non-empty batch in `self.merging`.
     ///
@@ -432,12 +431,11 @@ where
         Spine {
             operator,
             logger,
-            phantom: ::std::marker::PhantomData,
-            logical_frontier: Antichain::from_elem(<T as timely::progress::Timestamp>::minimum()),
-            physical_frontier: Antichain::from_elem(<T as timely::progress::Timestamp>::minimum()),
+            logical_frontier: Antichain::from_elem(<B::Time as timely::progress::Timestamp>::minimum()),
+            physical_frontier: Antichain::from_elem(<B::Time as timely::progress::Timestamp>::minimum()),
             merging: Vec::new(),
             pending: Vec::new(),
-            upper: Antichain::from_elem(<T as timely::progress::Timestamp>::minimum()),
+            upper: Antichain::from_elem(<B::Time as timely::progress::Timestamp>::minimum()),
             effort,
             activator,
         }
@@ -766,7 +764,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<B: Batch> {
     /// An empty layer, containing no updates.
     Vacant,
     /// A layer containing a single batch.
@@ -775,10 +773,10 @@ enum MergeState<K, V, T, R, B: Batch<K, V, T, R>> {
     /// to ensure the progress of maintenance work.
     Single(Option<B>),
     /// A layer containing two batches, in the process of merging.
-    Double(MergeVariant<K, V, T, R, B>),
+    Double(MergeVariant<B>),
 }
 
-impl<K, V, T: Eq, R, B: Batch<K, V, T, R>> MergeState<K, V, T, R, B> {
+impl<B: Batch> MergeState<B> where B::Time: Eq {
 
     /// The number of actual updates contained in the level.
     fn len(&self) -> usize {
@@ -859,12 +857,12 @@ impl<K, V, T: Eq, R, B: Batch<K, V, T, R>> MergeState<K, V, T, R, B> {
     /// empty batch whose upper and lower froniers are equal. This
     /// option exists purely for bookkeeping purposes, and no computation
     /// is performed to merge the two batches.
-    fn begin_merge(batch1: Option<B>, batch2: Option<B>, compaction_frontier: Option<AntichainRef<T>>) -> MergeState<K, V, T, R, B> {
+    fn begin_merge(batch1: Option<B>, batch2: Option<B>, compaction_frontier: Option<AntichainRef<B::Time>>) -> MergeState<B> {
         let variant =
         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 +874,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<B: Batch> {
     /// 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<B: Batch> MergeVariant<B> {
 
     /// Completes and extracts the batch, unless structurally empty.
     ///
diff --git a/src/trace/mod.rs b/src/trace/mod.rs
index 45961491d..f1775050f 100644
--- a/src/trace/mod.rs
+++ b/src/trace/mod.rs
@@ -52,13 +52,13 @@ 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>;
+    type Cursor: Cursor<Key = Self::Key, Val = Self::Val, Time = Self::Time, R = Self::R>;
 
     /// Provides a cursor over updates contained in the trace.
-    fn cursor(&mut self) -> (Self::Cursor, <Self::Cursor as Cursor<Self::Key, Self::Val, Self::Time, Self::R>>::Storage) {
+    fn cursor(&mut self) -> (Self::Cursor, <Self::Cursor as Cursor>::Storage) {
         if let Some(cursor) = self.cursor_through(Antichain::new().borrow()) {
             cursor
         }
@@ -74,7 +74,7 @@ pub trait TraceReader {
     /// the trace, and (ii) the trace has not been advanced beyond `upper`. Practically, the implementation should
     /// be expected to look for a "clean cut" using `upper`, and if it finds such a cut can return a cursor. This
     /// should allow `upper` such as `&[]` as used by `self.cursor()`, though it is difficult to imagine other uses.
-    fn cursor_through(&mut self, upper: AntichainRef<Self::Time>) -> Option<(Self::Cursor, <Self::Cursor as Cursor<Self::Key, Self::Val, Self::Time, Self::R>>::Storage)>;
+    fn cursor_through(&mut self, upper: AntichainRef<Self::Time>) -> Option<(Self::Cursor, <Self::Cursor as Cursor>::Storage)>;
 
     /// Advances the frontier that constrains logical compaction.
     ///
@@ -197,7 +197,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> {
+where <Self as TraceReader>::Batch: Batch {
 
     /// Allocates a new empty trace.
     fn new(
@@ -232,12 +232,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<Key = Self::Key, Val = Self::Val, Time = Self::Time, R = 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,70 +254,70 @@ 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>;
     /// A type used to assemble batches from ordered update sequences.
-    type Builder: Builder<K, V, T, R, Self>;
+    type Builder: Builder<Self>;
     /// A type used to progressively merge batches.
-    type Merger: Merger<K, V, T, R, Self>;
+    type Merger: Merger<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<Output: Batch> {
     /// Allocates a new empty batcher.
     fn new() -> Self;
     /// Adds an unordered batch of elements to the batcher.
-    fn push_batch(&mut self, batch: &mut Vec<((K, V), T, R)>);
+    fn push_batch(&mut self, batch: &mut Vec<((Output::Key, Output::Val), Output::Time, Output::R)>);
     /// Returns all updates not greater or equal to an element of `upper`.
-    fn seal(&mut self, upper: Antichain<T>) -> Output;
+    fn seal(&mut self, upper: Antichain<Output::Time>) -> Output;
     /// Returns the lower envelope of contained update times.
-    fn frontier(&mut self) -> timely::progress::frontier::AntichainRef<T>;
+    fn frontier(&mut self) -> timely::progress::frontier::AntichainRef<Output::Time>;
 }
 
 /// Functionality for building batches from ordered update sequences.
-pub trait Builder<K, V, T, R, Output: Batch<K, V, T, R>> {
+pub trait Builder<Output: Batch> {
     /// Allocates an empty builder.
     fn new() -> Self;
     /// Allocates an empty builder with some capacity.
     fn with_capacity(cap: usize) -> Self;
     /// Adds an element to the batch.
-    fn push(&mut self, element: (K, V, T, R));
+    fn push(&mut self, element: (Output::Key, Output::Val, Output::Time, Output::R));
     /// Adds an ordered sequence of elements to the batch.
-    fn extend<I: Iterator<Item=(K,V,T,R)>>(&mut self, iter: I) {
+    fn extend<I: Iterator<Item=(Output::Key,Output::Val,Output::Time,Output::R)>>(&mut self, iter: I) {
         for item in iter { self.push(item); }
     }
     /// Completes building and returns the batch.
-    fn done(self, lower: Antichain<T>, upper: Antichain<T>, since: Antichain<T>) -> Output;
+    fn done(self, lower: Antichain<Output::Time>, upper: Antichain<Output::Time>, since: Antichain<Output::Time>) -> Output;
 }
 
 /// Represents a merge in progress.
-pub trait Merger<K, V, T, R, Output: Batch<K, V, T, R>> {
+pub trait Merger<Output: Batch> {
     /// 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;
+    fn new(source1: &Output, source2: &Output, compaction_frontier: Option<AntichainRef<Output::Time>>) -> Self;
     /// Perform some amount of work, decrementing `fuel`.
     ///
     /// If `fuel` is non-zero after the call, the merging is complete and
@@ -331,10 +340,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<B>;
         /// Acquires a cursor to the batch's contents.
         fn cursor(&self) -> Self::Cursor {
             RcBatchCursor::new((&**self).cursor())
@@ -343,84 +356,87 @@ 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>> {
-        phantom: ::std::marker::PhantomData<(K, V, T, R)>,
+    pub struct RcBatchCursor<B: BatchReader> {
         cursor: B::Cursor,
     }
 
-    impl<K, V, T, R, B: BatchReader<K, V, T, R>> RcBatchCursor<K, V, T, R, B> {
+    impl<B: BatchReader> RcBatchCursor<B> {
         fn new(cursor: B::Cursor) -> Self {
             RcBatchCursor {
                 cursor,
-                phantom: ::std::marker::PhantomData,
             }
         }
     }
 
-    impl<K, V, T, R, B: BatchReader<K, V, T, R>> Cursor<K, V, T, R> for RcBatchCursor<K, V, T, R, B> {
+    impl<B: BatchReader> Cursor for RcBatchCursor<B> {
+
+        type Key = B::Key;
+        type Val = B::Val;
+        type Time = B::Time;
+        type R = B::R;
 
         type Storage = Rc<B>;
 
         #[inline] fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.key_valid(storage) }
         #[inline] fn val_valid(&self, storage: &Self::Storage) -> bool { self.cursor.val_valid(storage) }
 
-        #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K { self.cursor.key(storage) }
-        #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V { self.cursor.val(storage) }
+        #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Key { self.cursor.key(storage) }
+        #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Val { self.cursor.val(storage) }
 
         #[inline]
-        fn map_times<L: FnMut(&T, &R)>(&mut self, storage: &Self::Storage, logic: L) {
+        fn map_times<L: FnMut(&Self::Time, &Self::R)>(&mut self, storage: &Self::Storage, logic: L) {
             self.cursor.map_times(storage, logic)
         }
 
         #[inline] fn step_key(&mut self, storage: &Self::Storage) { self.cursor.step_key(storage) }
-        #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &K) { self.cursor.seek_key(storage, key) }
+        #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &Self::Key) { self.cursor.seek_key(storage, key) }
 
         #[inline] fn step_val(&mut self, storage: &Self::Storage) { self.cursor.step_val(storage) }
-        #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &V) { self.cursor.seek_val(storage, val) }
+        #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &Self::Val) { self.cursor.seek_val(storage, val) }
 
         #[inline] fn rewind_keys(&mut self, storage: &Self::Storage) { self.cursor.rewind_keys(storage) }
         #[inline] fn rewind_vals(&mut self, storage: &Self::Storage) { self.cursor.rewind_vals(storage) }
     }
 
     /// 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>;
+        type Builder = RcBuilder<B>;
+        type Merger = RcMerger<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<B:Batch> { 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> {
-        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)) }
-        fn frontier(&mut self) -> timely::progress::frontier::AntichainRef<T> { self.batcher.frontier() }
+    impl<B:Batch> Batcher<Rc<B>> for RcBatcher<B> {
+        fn new() -> Self { RcBatcher { batcher: <B::Batcher as Batcher<B>>::new() } }
+        fn push_batch(&mut self, batch: &mut Vec<((B::Key, B::Val), B::Time, B::R)>) { self.batcher.push_batch(batch) }
+        fn seal(&mut self, upper: Antichain<B::Time>) -> Rc<B> { Rc::new(self.batcher.seal(upper)) }
+        fn frontier(&mut self) -> timely::progress::frontier::AntichainRef<B::Time> { self.batcher.frontier() }
     }
 
     /// 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<B:Batch> { 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> {
-        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) }
-        fn done(self, lower: Antichain<T>, upper: Antichain<T>, since: Antichain<T>) -> Rc<B> { Rc::new(self.builder.done(lower, upper, since)) }
+    impl<B:Batch> Builder<Rc<B>> for RcBuilder<B> {
+        fn new() -> Self { RcBuilder { builder: <B::Builder as Builder<B>>::new() } }
+        fn with_capacity(cap: usize) -> Self { RcBuilder { builder: <B::Builder as Builder<B>>::with_capacity(cap) } }
+        fn push(&mut self, element: (B::Key, B::Val, B::Time, B::R)) { self.builder.push(element) }
+        fn done(self, lower: Antichain<B::Time>, upper: Antichain<B::Time>, since: Antichain<B::Time>) -> Rc<B> { Rc::new(self.builder.done(lower, upper, since)) }
     }
 
     /// 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<B:Batch> { 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> {
-        fn new(source1: &Rc<B>, source2: &Rc<B>, compaction_frontier: Option<AntichainRef<T>>) -> Self { RcMerger { merger: B::begin_merge(source1, source2, compaction_frontier) } }
+    impl<B:Batch> Merger<Rc<B>> for RcMerger<B> {
+        fn new(source1: &Rc<B>, source2: &Rc<B>, compaction_frontier: Option<AntichainRef<B::Time>>) -> 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 +454,15 @@ 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<B>;
         /// Acquires a cursor to the batch's contents.
         fn cursor(&self) -> Self::Cursor {
             AbomonatedBatchCursor::new((&**self).cursor())
@@ -450,81 +471,84 @@ 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>> {
-        phantom: ::std::marker::PhantomData<(K, V, T, R)>,
+    pub struct AbomonatedBatchCursor<B: BatchReader> {
         cursor: B::Cursor,
     }
 
-    impl<K, V, T, R, B: BatchReader<K, V, T, R>> AbomonatedBatchCursor<K, V, T, R, B> {
+    impl<B: BatchReader> AbomonatedBatchCursor<B> {
         fn new(cursor: B::Cursor) -> Self {
             AbomonatedBatchCursor {
                 cursor,
-                phantom: ::std::marker::PhantomData,
             }
         }
     }
 
-    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<B: BatchReader+Abomonation> Cursor for AbomonatedBatchCursor<B> {
+
+        type Key = B::Key;
+        type Val = B::Val;
+        type Time = B::Time;
+        type R = B::R;
 
         type Storage = Abomonated<B, Vec<u8>>;
 
         #[inline] fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.key_valid(storage) }
         #[inline] fn val_valid(&self, storage: &Self::Storage) -> bool { self.cursor.val_valid(storage) }
 
-        #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K { self.cursor.key(storage) }
-        #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V { self.cursor.val(storage) }
+        #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Key { self.cursor.key(storage) }
+        #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Val { self.cursor.val(storage) }
 
         #[inline]
-        fn map_times<L: FnMut(&T, &R)>(&mut self, storage: &Self::Storage, logic: L) {
+        fn map_times<L: FnMut(&Self::Time, &Self::R)>(&mut self, storage: &Self::Storage, logic: L) {
             self.cursor.map_times(storage, logic)
         }
 
         #[inline] fn step_key(&mut self, storage: &Self::Storage) { self.cursor.step_key(storage) }
-        #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &K) { self.cursor.seek_key(storage, key) }
+        #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &Self::Key) { self.cursor.seek_key(storage, key) }
 
         #[inline] fn step_val(&mut self, storage: &Self::Storage) { self.cursor.step_val(storage) }
-        #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &V) { self.cursor.seek_val(storage, val) }
+        #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &Self::Val) { self.cursor.seek_val(storage, val) }
 
         #[inline] fn rewind_keys(&mut self, storage: &Self::Storage) { self.cursor.rewind_keys(storage) }
         #[inline] fn rewind_vals(&mut self, storage: &Self::Storage) { self.cursor.rewind_vals(storage) }
     }
 
     /// 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<B>;
+        type Builder = AbomonatedBuilder<B>;
+        type Merger = AbomonatedMerger<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<B:Batch> { 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> {
-        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>> {
+    impl<B:Batch+Abomonation> Batcher<Abomonated<B,Vec<u8>>> for AbomonatedBatcher<B> {
+        fn new() -> Self { AbomonatedBatcher { batcher: <B::Batcher as Batcher<B>>::new() } }
+        fn push_batch(&mut self, batch: &mut Vec<((B::Key, B::Val), B::Time, B::R)>) { self.batcher.push_batch(batch) }
+        fn seal(&mut self, upper: Antichain<B::Time>) -> Abomonated<B, Vec<u8>> {
             let batch = self.batcher.seal(upper);
             let mut bytes = Vec::with_capacity(measure(&batch));
             unsafe { abomonation::encode(&batch, &mut bytes).unwrap() };
             unsafe { Abomonated::<B,_>::new(bytes).unwrap() }
         }
-        fn frontier(&mut self) -> timely::progress::frontier::AntichainRef<T> { self.batcher.frontier() }
+        fn frontier(&mut self) -> timely::progress::frontier::AntichainRef<B::Time> { self.batcher.frontier() }
     }
 
     /// 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<B:Batch> { 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> {
-        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) }
-        fn done(self, lower: Antichain<T>, upper: Antichain<T>, since: Antichain<T>) -> Abomonated<B, Vec<u8>> {
+    impl<B:Batch+Abomonation> Builder<Abomonated<B,Vec<u8>>> for AbomonatedBuilder<B> {
+        fn new() -> Self { AbomonatedBuilder { builder: <B::Builder as Builder<B>>::new() } }
+        fn with_capacity(cap: usize) -> Self { AbomonatedBuilder { builder: <B::Builder as Builder<B>>::with_capacity(cap) } }
+        fn push(&mut self, element: (B::Key, B::Val, B::Time, B::R)) { self.builder.push(element) }
+        fn done(self, lower: Antichain<B::Time>, upper: Antichain<B::Time>, since: Antichain<B::Time>) -> Abomonated<B, Vec<u8>> {
             let batch = self.builder.done(lower, upper, since);
             let mut bytes = Vec::with_capacity(measure(&batch));
             unsafe { abomonation::encode(&batch, &mut bytes).unwrap() };
@@ -533,11 +557,11 @@ 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<B:Batch> { 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> {
-        fn new(source1: &Abomonated<B,Vec<u8>>, source2: &Abomonated<B,Vec<u8>>, compaction_frontier: Option<AntichainRef<T>>) -> Self {
+    impl<B:Batch+Abomonation> Merger<Abomonated<B,Vec<u8>>> for AbomonatedMerger<B> {
+        fn new(source1: &Abomonated<B,Vec<u8>>, source2: &Abomonated<B,Vec<u8>>, compaction_frontier: Option<AntichainRef<B::Time>>) -> Self {
             AbomonatedMerger { merger: B::begin_merge(source1, source2, compaction_frontier) }
         }
         fn work(&mut self, source1: &Abomonated<B,Vec<u8>>, source2: &Abomonated<B,Vec<u8>>, fuel: &mut isize) {
diff --git a/src/trace/wrappers/enter.rs b/src/trace/wrappers/enter.rs
index c1d28fd92..1b4316dc4 100644
--- a/src/trace/wrappers/enter.rs
+++ b/src/trace/wrappers/enter.rs
@@ -47,8 +47,8 @@ where
     type Time = TInner;
     type R = Tr::R;
 
-    type Batch = BatchEnter<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Batch, TInner>;
-    type Cursor = CursorEnter<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Cursor, TInner>;
+    type Batch = BatchEnter<Tr::Batch, TInner>;
+    type Cursor = CursorEnter<Tr::Cursor, TInner>;
 
     fn map_batches<F: FnMut(&Self::Batch)>(&self, mut f: F) {
         self.trace.map_batches(|batch| {
@@ -86,7 +86,7 @@ where
         self.stash2.borrow()
     }
 
-    fn cursor_through(&mut self, upper: AntichainRef<TInner>) -> Option<(Self::Cursor, <Self::Cursor as Cursor<Tr::Key, Tr::Val, TInner, Tr::R>>::Storage)> {
+    fn cursor_through(&mut self, upper: AntichainRef<TInner>) -> Option<(Self::Cursor, <Self::Cursor as Cursor>::Storage)> {
         self.stash1.clear();
         for time in upper.iter() {
             self.stash1.insert(time.clone().to_outer());
@@ -113,29 +113,24 @@ 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, TInner>;
 
     fn cursor(&self) -> Self::Cursor {
         BatchCursorEnter::new(self.batch.cursor())
@@ -144,11 +139,11 @@ where
     fn description(&self) -> &Description<TInner> { &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))
         }
@@ -165,12 +159,12 @@ where
 }
 
 /// Wrapper to provide cursor to nested scope.
-pub struct CursorEnter<K, V, T, R, C: Cursor<K, V, T, R>, TInner> {
-    phantom: ::std::marker::PhantomData<(K, V, T, R, TInner)>,
+pub struct CursorEnter<C: Cursor, TInner> {
+    phantom: ::std::marker::PhantomData<TInner>,
     cursor: C,
 }
 
-impl<K, V, T, R, C: Cursor<K, V, T, R>, TInner> CursorEnter<K, V, T, R, C, TInner> {
+impl<C: Cursor, TInner> CursorEnter<C, TInner> {
     fn new(cursor: C) -> Self {
         CursorEnter {
             phantom: ::std::marker::PhantomData,
@@ -179,32 +173,37 @@ impl<K, V, T, R, C: Cursor<K, V, T, R>, TInner> CursorEnter<K, V, T, R, C, TInne
     }
 }
 
-impl<K, V, T, R, C, TInner> Cursor<K, V, TInner, R> for CursorEnter<K, V, T, R, C, TInner>
+impl<C, TInner> Cursor for CursorEnter<C, TInner>
 where
-    C: Cursor<K, V, T, R>,
-    T: Timestamp,
-    TInner: Refines<T>+Lattice,
+    C: Cursor,
+    C::Time: Timestamp,
+    TInner: Refines<C::Time>+Lattice,
 {
+    type Key = C::Key;
+    type Val = C::Val;
+    type Time = TInner;
+    type R = C::R;
+
     type Storage = C::Storage;
 
     #[inline] fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.key_valid(storage) }
     #[inline] fn val_valid(&self, storage: &Self::Storage) -> bool { self.cursor.val_valid(storage) }
 
-    #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K { self.cursor.key(storage) }
-    #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V { self.cursor.val(storage) }
+    #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Key { self.cursor.key(storage) }
+    #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Val { self.cursor.val(storage) }
 
     #[inline]
-    fn map_times<L: FnMut(&TInner, &R)>(&mut self, storage: &Self::Storage, mut logic: L) {
+    fn map_times<L: FnMut(&TInner, &Self::R)>(&mut self, storage: &Self::Storage, mut logic: L) {
         self.cursor.map_times(storage, |time, diff| {
             logic(&TInner::to_inner(time.clone()), diff)
         })
     }
 
     #[inline] fn step_key(&mut self, storage: &Self::Storage) { self.cursor.step_key(storage) }
-    #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &K) { self.cursor.seek_key(storage, key) }
+    #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &Self::Key) { self.cursor.seek_key(storage, key) }
 
     #[inline] fn step_val(&mut self, storage: &Self::Storage) { self.cursor.step_val(storage) }
-    #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &V) { self.cursor.seek_val(storage, val) }
+    #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &Self::Val) { self.cursor.seek_val(storage, val) }
 
     #[inline] fn rewind_keys(&mut self, storage: &Self::Storage) { self.cursor.rewind_keys(storage) }
     #[inline] fn rewind_vals(&mut self, storage: &Self::Storage) { self.cursor.rewind_vals(storage) }
@@ -213,12 +212,12 @@ where
 
 
 /// Wrapper to provide cursor to nested scope.
-pub struct BatchCursorEnter<K, V, T, R, B: BatchReader<K, V, T, R>, TInner> {
-    phantom: ::std::marker::PhantomData<(K, V, R, TInner)>,
+pub struct BatchCursorEnter<B: BatchReader, TInner> {
+    phantom: ::std::marker::PhantomData<TInner>,
     cursor: B::Cursor,
 }
 
-impl<K, V, T, R, B: BatchReader<K, V, T, R>, TInner> BatchCursorEnter<K, V, T, R, B, TInner> {
+impl<B: BatchReader, TInner> BatchCursorEnter<B, TInner> {
     fn new(cursor: B::Cursor) -> Self {
         BatchCursorEnter {
             phantom: ::std::marker::PhantomData,
@@ -227,31 +226,36 @@ 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<TInner, B: BatchReader> Cursor for BatchCursorEnter<B, TInner>
 where
-    T: Timestamp,
-    TInner: Refines<T>+Lattice,
+    B::Time: Timestamp,
+    TInner: Refines<B::Time>+Lattice,
 {
-    type Storage = BatchEnter<K, V, T, R, B, TInner>;
+    type Key = B::Key;
+    type Val = B::Val;
+    type Time = TInner;
+    type R = B::R;
+
+    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) }
 
-    #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K { self.cursor.key(&storage.batch) }
-    #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V { self.cursor.val(&storage.batch) }
+    #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Key { self.cursor.key(&storage.batch) }
+    #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Val { self.cursor.val(&storage.batch) }
 
     #[inline]
-    fn map_times<L: FnMut(&TInner, &R)>(&mut self, storage: &Self::Storage, mut logic: L) {
+    fn map_times<L: FnMut(&TInner, &Self::R)>(&mut self, storage: &Self::Storage, mut logic: L) {
         self.cursor.map_times(&storage.batch, |time, diff| {
             logic(&TInner::to_inner(time.clone()), diff)
         })
     }
 
     #[inline] fn step_key(&mut self, storage: &Self::Storage) { self.cursor.step_key(&storage.batch) }
-    #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &K) { self.cursor.seek_key(&storage.batch, key) }
+    #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &Self::Key) { self.cursor.seek_key(&storage.batch, key) }
 
     #[inline] fn step_val(&mut self, storage: &Self::Storage) { self.cursor.step_val(&storage.batch) }
-    #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &V) { self.cursor.seek_val(&storage.batch, val) }
+    #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &Self::Val) { self.cursor.seek_val(&storage.batch, val) }
 
     #[inline] fn rewind_keys(&mut self, storage: &Self::Storage) { self.cursor.rewind_keys(&storage.batch) }
     #[inline] fn rewind_vals(&mut self, storage: &Self::Storage) { self.cursor.rewind_vals(&storage.batch) }
diff --git a/src/trace/wrappers/enter_at.rs b/src/trace/wrappers/enter_at.rs
index 9562fc90c..e5c5419ed 100644
--- a/src/trace/wrappers/enter_at.rs
+++ b/src/trace/wrappers/enter_at.rs
@@ -62,8 +62,8 @@ where
     type Time = TInner;
     type R = Tr::R;
 
-    type Batch = BatchEnter<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Batch, TInner,F>;
-    type Cursor = CursorEnter<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Cursor, TInner,F>;
+    type Batch = BatchEnter<Tr::Batch, TInner,F>;
+    type Cursor = CursorEnter<Tr::Cursor, TInner,F>;
 
     fn map_batches<F2: FnMut(&Self::Batch)>(&self, mut f: F2) {
         let logic = self.logic.clone();
@@ -102,7 +102,7 @@ where
         self.stash2.borrow()
     }
 
-    fn cursor_through(&mut self, upper: AntichainRef<TInner>) -> Option<(Self::Cursor, <Self::Cursor as Cursor<Tr::Key, Tr::Val, TInner, Tr::R>>::Storage)> {
+    fn cursor_through(&mut self, upper: AntichainRef<TInner>) -> Option<(Self::Cursor, <Self::Cursor as Cursor>::Storage)> {
         self.stash1.clear();
         for time in upper.iter() {
             self.stash1.insert(time.clone().to_outer());
@@ -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, 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,
@@ -187,13 +180,13 @@ where
 }
 
 /// Wrapper to provide cursor to nested scope.
-pub struct CursorEnter<K, V, T, R, C: Cursor<K, V, T, R>, TInner, F> {
-    phantom: ::std::marker::PhantomData<(K, V, T, R, TInner)>,
+pub struct CursorEnter<C: Cursor, TInner, F> {
+    phantom: ::std::marker::PhantomData<TInner>,
     cursor: C,
     logic: F,
 }
 
-impl<K, V, T, R, C: Cursor<K, V, T, R>, TInner, F> CursorEnter<K, V, T, R, C, TInner, F> {
+impl<C: Cursor, TInner, F> CursorEnter<C, TInner, F> {
     fn new(cursor: C, logic: F) -> Self {
         CursorEnter {
             phantom: ::std::marker::PhantomData,
@@ -203,23 +196,28 @@ impl<K, V, T, R, C: Cursor<K, V, T, R>, TInner, F> CursorEnter<K, V, T, R, C, TI
     }
 }
 
-impl<K, V, T, R, C, TInner, F> Cursor<K, V, TInner, R> for CursorEnter<K, V, T, R, C, TInner, F>
+impl<C, TInner, F> Cursor for CursorEnter<C, TInner, F>
 where
-    C: Cursor<K, V, T, R>,
-    T: Timestamp,
-    TInner: Refines<T>+Lattice,
-    F: FnMut(&K, &V, &T)->TInner,
+    C: Cursor,
+    C::Time: Timestamp,
+    TInner: Refines<C::Time>+Lattice,
+    F: FnMut(&C::Key, &C::Val, &C::Time)->TInner,
 {
+    type Key = C::Key;
+    type Val = C::Val;
+    type Time = TInner;
+    type R = C::R;
+
     type Storage = C::Storage;
 
     #[inline] fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.key_valid(storage) }
     #[inline] fn val_valid(&self, storage: &Self::Storage) -> bool { self.cursor.val_valid(storage) }
 
-    #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K { self.cursor.key(storage) }
-    #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V { self.cursor.val(storage) }
+    #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Key { self.cursor.key(storage) }
+    #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Val { self.cursor.val(storage) }
 
     #[inline]
-    fn map_times<L: FnMut(&TInner, &R)>(&mut self, storage: &Self::Storage, mut logic: L) {
+    fn map_times<L: FnMut(&TInner, &Self::R)>(&mut self, storage: &Self::Storage, mut logic: L) {
         let key = self.key(storage);
         let val = self.val(storage);
         let logic2 = &mut self.logic;
@@ -229,10 +227,10 @@ where
     }
 
     #[inline] fn step_key(&mut self, storage: &Self::Storage) { self.cursor.step_key(storage) }
-    #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &K) { self.cursor.seek_key(storage, key) }
+    #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &Self::Key) { self.cursor.seek_key(storage, key) }
 
     #[inline] fn step_val(&mut self, storage: &Self::Storage) { self.cursor.step_val(storage) }
-    #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &V) { self.cursor.seek_val(storage, val) }
+    #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &Self::Val) { self.cursor.seek_val(storage, val) }
 
     #[inline] fn rewind_keys(&mut self, storage: &Self::Storage) { self.cursor.rewind_keys(storage) }
     #[inline] fn rewind_vals(&mut self, storage: &Self::Storage) { self.cursor.rewind_vals(storage) }
@@ -241,13 +239,13 @@ where
 
 
 /// Wrapper to provide cursor to nested scope.
-pub struct BatchCursorEnter<K, V, T, R, B: BatchReader<K, V, T, R>, TInner, F> {
-    phantom: ::std::marker::PhantomData<(K, V, R, TInner)>,
+pub struct BatchCursorEnter<B: BatchReader, TInner, F> {
+    phantom: ::std::marker::PhantomData<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<B: BatchReader, TInner, F> BatchCursorEnter<B, TInner, F> {
     fn new(cursor: B::Cursor, logic: F) -> Self {
         BatchCursorEnter {
             phantom: ::std::marker::PhantomData,
@@ -257,22 +255,27 @@ 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<TInner, B: BatchReader, F> Cursor for BatchCursorEnter<B, TInner, F>
 where
-    T: Timestamp,
-    TInner: Refines<T>+Lattice,
-    F: FnMut(&K, &V, &T)->TInner,
+    B::Time: Timestamp,
+    TInner: Refines<B::Time>+Lattice,
+    F: FnMut(&B::Key, &B::Val, &B::Time)->TInner,
 {
-    type Storage = BatchEnter<K, V, T, R, B, TInner, F>;
+    type Key = B::Key;
+    type Val = B::Val;
+    type Time = TInner;
+    type R = B::R;
+
+    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) }
 
-    #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K { self.cursor.key(&storage.batch) }
-    #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V { self.cursor.val(&storage.batch) }
+    #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Key { self.cursor.key(&storage.batch) }
+    #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Val { self.cursor.val(&storage.batch) }
 
     #[inline]
-    fn map_times<L: FnMut(&TInner, &R)>(&mut self, storage: &Self::Storage, mut logic: L) {
+    fn map_times<L: FnMut(&TInner, &Self::R)>(&mut self, storage: &Self::Storage, mut logic: L) {
         let key = self.key(storage);
         let val = self.val(storage);
         let logic2 = &mut self.logic;
@@ -282,10 +285,10 @@ where
     }
 
     #[inline] fn step_key(&mut self, storage: &Self::Storage) { self.cursor.step_key(&storage.batch) }
-    #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &K) { self.cursor.seek_key(&storage.batch, key) }
+    #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &Self::Key) { self.cursor.seek_key(&storage.batch, key) }
 
     #[inline] fn step_val(&mut self, storage: &Self::Storage) { self.cursor.step_val(&storage.batch) }
-    #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &V) { self.cursor.seek_val(&storage.batch, val) }
+    #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &Self::Val) { self.cursor.seek_val(&storage.batch, val) }
 
     #[inline] fn rewind_keys(&mut self, storage: &Self::Storage) { self.cursor.rewind_keys(&storage.batch) }
     #[inline] fn rewind_vals(&mut self, storage: &Self::Storage) { self.cursor.rewind_vals(&storage.batch) }
diff --git a/src/trace/wrappers/filter.rs b/src/trace/wrappers/filter.rs
index 0f1a531ab..3fdf29603 100644
--- a/src/trace/wrappers/filter.rs
+++ b/src/trace/wrappers/filter.rs
@@ -40,8 +40,8 @@ where
     type Time = Tr::Time;
     type R = Tr::R;
 
-    type Batch = BatchFilter<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Batch, F>;
-    type Cursor = CursorFilter<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Cursor, F>;
+    type Batch = BatchFilter<Tr::Batch, F>;
+    type Cursor = CursorFilter<Tr::Cursor, F>;
 
     fn map_batches<F2: FnMut(&Self::Batch)>(&self, mut f: F2) {
         let logic = self.logic.clone();
@@ -55,7 +55,7 @@ where
     fn set_physical_compaction(&mut self, frontier: AntichainRef<Tr::Time>) { self.trace.set_physical_compaction(frontier) }
     fn get_physical_compaction(&mut self) -> AntichainRef<Tr::Time> { self.trace.get_physical_compaction() }
 
-    fn cursor_through(&mut self, upper: AntichainRef<Tr::Time>) -> Option<(Self::Cursor, <Self::Cursor as Cursor<Tr::Key, Tr::Val, Tr::Time, Tr::R>>::Storage)> {
+    fn cursor_through(&mut self, upper: AntichainRef<Tr::Time>) -> Option<(Self::Cursor, <Self::Cursor as Cursor>::Storage)> {
         self.trace.cursor_through(upper).map(|(x,y)| (CursorFilter::new(x, self.logic.clone()), y))
     }
 }
@@ -76,46 +76,40 @@ 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, 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<B::Time> { &self.batch.description() }
 }
 
-impl<K, V, T, R, B, F> BatchFilter<K, V, T, R, B, F>
+impl<B, F> BatchFilter<B, F>
 where
-    B: BatchReader<K, V, T, R>,
-    T: Timestamp,
+    B: BatchReader,
+    B::Time: Timestamp,
 {
     /// Makes a new batch wrapper
     pub fn make_from(batch: B, logic: F) -> Self {
         BatchFilter {
-            phantom: ::std::marker::PhantomData,
             batch,
             logic,
         }
@@ -123,38 +117,41 @@ where
 }
 
 /// Wrapper to provide cursor to nested scope.
-pub struct CursorFilter<K, V, T, R, C: Cursor<K, V, T, R>, F> {
-    phantom: ::std::marker::PhantomData<(K, V, T, R)>,
+pub struct CursorFilter<C: Cursor, F> {
     cursor: C,
     logic: F,
 }
 
-impl<K, V, T, R, C: Cursor<K, V, T, R>, F> CursorFilter<K, V, T, R, C, F> {
+impl<C: Cursor, F> CursorFilter<C, F> {
     fn new(cursor: C, logic: F) -> Self {
         CursorFilter {
-            phantom: ::std::marker::PhantomData,
             cursor,
             logic,
         }
     }
 }
 
-impl<K, V, T, R, C, F> Cursor<K, V, T, R> for CursorFilter<K, V, T, R, C, F>
+impl<C, F> Cursor for CursorFilter<C, F>
 where
-    C: Cursor<K, V, T, R>,
-    T: Timestamp,
-    F: FnMut(&K, &V)->bool+'static
+    C: Cursor,
+    C::Time: Timestamp,
+    F: FnMut(&C::Key, &C::Val)->bool+'static
 {
+    type Key = C::Key;
+    type Val = C::Val;
+    type Time = C::Time;
+    type R = C::R;
+
     type Storage = C::Storage;
 
     #[inline] fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.key_valid(storage) }
     #[inline] fn val_valid(&self, storage: &Self::Storage) -> bool { self.cursor.val_valid(storage) }
 
-    #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K { self.cursor.key(storage) }
-    #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V { self.cursor.val(storage) }
+    #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Key { self.cursor.key(storage) }
+    #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Val { self.cursor.val(storage) }
 
     #[inline]
-    fn map_times<L: FnMut(&T,&R)>(&mut self, storage: &Self::Storage, logic: L) {
+    fn map_times<L: FnMut(&Self::Time,&Self::R)>(&mut self, storage: &Self::Storage, logic: L) {
         let key = self.key(storage);
         let val = self.val(storage);
         if (self.logic)(key, val) {
@@ -163,10 +160,10 @@ where
     }
 
     #[inline] fn step_key(&mut self, storage: &Self::Storage) { self.cursor.step_key(storage) }
-    #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &K) { self.cursor.seek_key(storage, key) }
+    #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &Self::Key) { self.cursor.seek_key(storage, key) }
 
     #[inline] fn step_val(&mut self, storage: &Self::Storage) { self.cursor.step_val(storage) }
-    #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &V) { self.cursor.seek_val(storage, val) }
+    #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &Self::Val) { self.cursor.seek_val(storage, val) }
 
     #[inline] fn rewind_keys(&mut self, storage: &Self::Storage) { self.cursor.rewind_keys(storage) }
     #[inline] fn rewind_vals(&mut self, storage: &Self::Storage) { self.cursor.rewind_vals(storage) }
@@ -175,37 +172,40 @@ where
 
 
 /// Wrapper to provide cursor to nested scope.
-pub struct BatchCursorFilter<K, V, T, R, B: BatchReader<K, V, T, R>, F> {
-    phantom: ::std::marker::PhantomData<(K, V, R)>,
+pub struct BatchCursorFilter<B: BatchReader, F> {
     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<B: BatchReader, F> BatchCursorFilter<B, F> {
     fn new(cursor: B::Cursor, logic: F) -> Self {
         BatchCursorFilter {
-            phantom: ::std::marker::PhantomData,
             cursor,
             logic,
         }
     }
 }
 
-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<B: BatchReader, F> Cursor for BatchCursorFilter<B, F>
 where
-    T: Timestamp,
-    F: FnMut(&K, &V)->bool+'static,
+    B::Time: Timestamp,
+    F: FnMut(&B::Key, &B::Val)->bool+'static,
 {
-    type Storage = BatchFilter<K, V, T, R, B, F>;
+    type Key = B::Key;
+    type Val = B::Val;
+    type Time = B::Time;
+    type R = B::R;
+
+    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) }
 
-    #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K { self.cursor.key(&storage.batch) }
-    #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V { self.cursor.val(&storage.batch) }
+    #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Key { self.cursor.key(&storage.batch) }
+    #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Val { self.cursor.val(&storage.batch) }
 
     #[inline]
-    fn map_times<L: FnMut(&T,&R)>(&mut self, storage: &Self::Storage, logic: L) {
+    fn map_times<L: FnMut(&Self::Time,&Self::R)>(&mut self, storage: &Self::Storage, logic: L) {
         let key = self.key(storage);
         let val = self.val(storage);
         if (self.logic)(key, val) {
@@ -214,10 +214,10 @@ where
     }
 
     #[inline] fn step_key(&mut self, storage: &Self::Storage) { self.cursor.step_key(&storage.batch) }
-    #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &K) { self.cursor.seek_key(&storage.batch, key) }
+    #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &Self::Key) { self.cursor.seek_key(&storage.batch, key) }
 
     #[inline] fn step_val(&mut self, storage: &Self::Storage) { self.cursor.step_val(&storage.batch) }
-    #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &V) { self.cursor.seek_val(&storage.batch, val) }
+    #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &Self::Val) { self.cursor.seek_val(&storage.batch, val) }
 
     #[inline] fn rewind_keys(&mut self, storage: &Self::Storage) { self.cursor.rewind_keys(&storage.batch) }
     #[inline] fn rewind_vals(&mut self, storage: &Self::Storage) { self.cursor.rewind_vals(&storage.batch) }
diff --git a/src/trace/wrappers/freeze.rs b/src/trace/wrappers/freeze.rs
index fa24b91d7..ed5965266 100644
--- a/src/trace/wrappers/freeze.rs
+++ b/src/trace/wrappers/freeze.rs
@@ -41,8 +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,
 {
     let func1 = Rc::new(func);
@@ -93,8 +91,8 @@ where
     type Time = Tr::Time;
     type R = Tr::R;
 
-    type Batch = BatchFreeze<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Batch, F>;
-    type Cursor = CursorFreeze<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Cursor, F>;
+    type Batch = BatchFreeze<Tr::Batch, F>;
+    type Cursor = CursorFreeze<Tr::Cursor, F>;
 
     fn map_batches<F2: FnMut(&Self::Batch)>(&self, mut f: F2) {
         let func = &self.func;
@@ -109,7 +107,7 @@ where
     fn set_physical_compaction(&mut self, frontier: AntichainRef<Tr::Time>) { self.trace.set_physical_compaction(frontier) }
     fn get_physical_compaction(&mut self) -> AntichainRef<Tr::Time> { self.trace.get_physical_compaction() }
 
-    fn cursor_through(&mut self, upper: AntichainRef<Tr::Time>) -> Option<(Self::Cursor, <Self::Cursor as Cursor<Tr::Key, Tr::Val, Tr::Time, Tr::R>>::Storage)> {
+    fn cursor_through(&mut self, upper: AntichainRef<Tr::Time>) -> Option<(Self::Cursor, <Self::Cursor as Cursor>::Storage)> {
         let func = &self.func;
         self.trace.cursor_through(upper)
             .map(|(cursor, storage)| (CursorFreeze::new(cursor, func.clone()), storage))
@@ -137,47 +135,49 @@ 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>
+impl<B, F> BatchReader for BatchFreeze<B, F>
 where
-    B: BatchReader<K, V, T, R>,
-    T: Clone,
-    F: Fn(&T)->Option<T>,
+    B: BatchReader,
+    B::Time: Clone,
+    F: Fn(&B::Time)->Option<B::Time>,
 {
-    type Cursor = BatchCursorFreeze<K, V, T, R, B, F>;
+    type Key = B::Key;
+    type Val = B::Val;
+    type Time = B::Time;
+    type R = B::R;
+
+    type Cursor = BatchCursorFreeze<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<B::Time> { self.batch.description() }
 }
 
-impl<K, V, T, R, B, F> BatchFreeze<K, V, T, R, B, F>
+impl<B, F> BatchFreeze<B, F>
 where
-    B: BatchReader<K, V, T, R>,
-    T: Clone,
-    F: Fn(&T)->Option<T>
+    B: BatchReader,
+    B::Time: Clone,
+    F: Fn(&B::Time)->Option<B::Time>
 {
     /// Makes a new batch wrapper
     pub fn make_from(batch: B, func: Rc<F>) -> Self {
         BatchFreeze {
-            phantom: ::std::marker::PhantomData,
             batch: batch,
             func: func,
         }
@@ -185,37 +185,39 @@ where
 }
 
 /// Wrapper to provide cursor to nested scope.
-pub struct CursorFreeze<K, V, T, R, C: Cursor<K, V, T, R>, F> {
-    phantom: ::std::marker::PhantomData<(K, V, R, T)>,
+pub struct CursorFreeze<C: Cursor, F> {
     cursor: C,
     func: Rc<F>,
 }
 
-impl<K, V, T, R, C: Cursor<K, V, T, R>, F> CursorFreeze<K, V, T, R, C, F> {
+impl<C: Cursor, F> CursorFreeze<C, F> {
     fn new(cursor: C, func: Rc<F>) -> Self {
         CursorFreeze {
-            phantom: ::std::marker::PhantomData,
             cursor: cursor,
             func: func,
         }
     }
 }
 
-impl<K, V, T, R, C, F> Cursor<K, V, T, R> for CursorFreeze<K, V, T, R, C, F>
+impl<C, F> Cursor for CursorFreeze<C, F>
 where
-    C: Cursor<K, V, T, R>,
-    F: Fn(&T)->Option<T>,
+    C: Cursor,
+    F: Fn(&C::Time)->Option<C::Time>,
 {
+    type Key = C::Key;
+    type Val = C::Val;
+    type Time = C::Time;
+    type R = C::R;
 
     type Storage = C::Storage;
 
     #[inline] fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.key_valid(storage) }
     #[inline] fn val_valid(&self, storage: &Self::Storage) -> bool { self.cursor.val_valid(storage) }
 
-    #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K { self.cursor.key(storage) }
-    #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V { self.cursor.val(storage) }
+    #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Key { self.cursor.key(storage) }
+    #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Val { self.cursor.val(storage) }
 
-    #[inline] fn map_times<L: FnMut(&T, &R)>(&mut self, storage: &Self::Storage, mut logic: L) {
+    #[inline] fn map_times<L: FnMut(&Self::Time, &Self::R)>(&mut self, storage: &Self::Storage, mut logic: L) {
         let func = &self.func;
         self.cursor.map_times(storage, |time, diff| {
             if let Some(time) = func(time) {
@@ -225,10 +227,10 @@ where
     }
 
     #[inline] fn step_key(&mut self, storage: &Self::Storage) { self.cursor.step_key(storage) }
-    #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &K) { self.cursor.seek_key(storage, key) }
+    #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &Self::Key) { self.cursor.seek_key(storage, key) }
 
     #[inline] fn step_val(&mut self, storage: &Self::Storage) { self.cursor.step_val(storage) }
-    #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &V) { self.cursor.seek_val(storage, val) }
+    #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &Self::Val) { self.cursor.seek_val(storage, val) }
 
     #[inline] fn rewind_keys(&mut self, storage: &Self::Storage) { self.cursor.rewind_keys(storage) }
     #[inline] fn rewind_vals(&mut self, storage: &Self::Storage) { self.cursor.rewind_vals(storage) }
@@ -236,36 +238,38 @@ where
 
 
 /// Wrapper to provide cursor to nested scope.
-pub struct BatchCursorFreeze<K, V, T, R, B: BatchReader<K, V, T, R>, F> {
-    phantom: ::std::marker::PhantomData<(K, V, R, T)>,
+pub struct BatchCursorFreeze<B: BatchReader, F> {
     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<B: BatchReader, F> BatchCursorFreeze<B, F> {
     fn new(cursor: B::Cursor, func: Rc<F>) -> Self {
         BatchCursorFreeze {
-            phantom: ::std::marker::PhantomData,
             cursor: cursor,
             func: func,
         }
     }
 }
 
-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<B: BatchReader, F> Cursor for BatchCursorFreeze<B, F>
 where
-    F: Fn(&T)->Option<T>,
+    F: Fn(&B::Time)->Option<B::Time>,
 {
+    type Key = B::Key;
+    type Val = B::Val;
+    type Time = B::Time;
+    type R = B::R;
 
-    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) }
 
-    #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K { self.cursor.key(&storage.batch) }
-    #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V { self.cursor.val(&storage.batch) }
+    #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Key { self.cursor.key(&storage.batch) }
+    #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Val { self.cursor.val(&storage.batch) }
 
-    #[inline] fn map_times<L: FnMut(&T, &R)>(&mut self, storage: &Self::Storage, mut logic: L) {
+    #[inline] fn map_times<L: FnMut(&Self::Time, &Self::R)>(&mut self, storage: &Self::Storage, mut logic: L) {
         let func = &self.func;
         self.cursor.map_times(&storage.batch, |time, diff| {
             if let Some(time) = func(time) {
@@ -275,10 +279,10 @@ where
     }
 
     #[inline] fn step_key(&mut self, storage: &Self::Storage) { self.cursor.step_key(&storage.batch) }
-    #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &K) { self.cursor.seek_key(&storage.batch, key) }
+    #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &Self::Key) { self.cursor.seek_key(&storage.batch, key) }
 
     #[inline] fn step_val(&mut self, storage: &Self::Storage) { self.cursor.step_val(&storage.batch) }
-    #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &V) { self.cursor.seek_val(&storage.batch, val) }
+    #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &Self::Val) { self.cursor.seek_val(&storage.batch, val) }
 
     #[inline] fn rewind_keys(&mut self, storage: &Self::Storage) { self.cursor.rewind_keys(&storage.batch) }
     #[inline] fn rewind_vals(&mut self, storage: &Self::Storage) { self.cursor.rewind_vals(&storage.batch) }
diff --git a/src/trace/wrappers/frontier.rs b/src/trace/wrappers/frontier.rs
index 43ed2096b..ec321b71e 100644
--- a/src/trace/wrappers/frontier.rs
+++ b/src/trace/wrappers/frontier.rs
@@ -47,8 +47,8 @@ where
     type Time = Tr::Time;
     type R = Tr::R;
 
-    type Batch = BatchFrontier<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Batch>;
-    type Cursor = CursorFrontier<Tr::Key, Tr::Val, Tr::Time, Tr::R, Tr::Cursor>;
+    type Batch = BatchFrontier<Tr::Batch>;
+    type Cursor = CursorFrontier<Tr::Cursor>;
 
     fn map_batches<F: FnMut(&Self::Batch)>(&self, mut f: F) {
         let frontier = self.frontier.borrow();
@@ -61,7 +61,7 @@ where
     fn set_physical_compaction(&mut self, frontier: AntichainRef<Tr::Time>) { self.trace.set_physical_compaction(frontier) }
     fn get_physical_compaction(&mut self) -> AntichainRef<Tr::Time> { self.trace.get_physical_compaction() }
 
-    fn cursor_through(&mut self, upper: AntichainRef<Tr::Time>) -> Option<(Self::Cursor, <Self::Cursor as Cursor<Tr::Key, Tr::Val, Tr::Time, Tr::R>>::Storage)> {
+    fn cursor_through(&mut self, upper: AntichainRef<Tr::Time>) -> Option<(Self::Cursor, <Self::Cursor as Cursor>::Storage)> {
         let frontier = self.frontier.borrow();
         self.trace.cursor_through(upper).map(|(x,y)| (CursorFrontier::new(x, frontier), y))
     }
@@ -83,45 +83,39 @@ 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: BatchReader,
+    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<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<B::Time> { &self.batch.description() }
 }
 
-impl<K, V, T, R, B> BatchFrontier<K, V, T, R, B>
+impl<B> BatchFrontier<B>
 where
-    B: BatchReader<K, V, T, R>,
-    T: Timestamp+Lattice,
+    B: BatchReader,
+    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(),
         }
@@ -129,39 +123,42 @@ where
 }
 
 /// Wrapper to provide cursor to nested scope.
-pub struct CursorFrontier<K, V, T, R, C: Cursor<K, V, T, R>> {
-    phantom: ::std::marker::PhantomData<(K, V, T, R)>,
+pub struct CursorFrontier<C: Cursor> {
     cursor: C,
-    frontier: Antichain<T>,
+    frontier: Antichain<C::Time>,
 }
 
-impl<K, V, T: Clone, R, C: Cursor<K, V, T, R>> CursorFrontier<K, V, T, R, C> {
-    fn new(cursor: C, frontier: AntichainRef<T>) -> Self {
+impl<C: Cursor> CursorFrontier<C> where C::Time: Clone {
+    fn new(cursor: C, frontier: AntichainRef<C::Time>) -> Self {
         CursorFrontier {
-            phantom: ::std::marker::PhantomData,
             cursor,
             frontier: frontier.to_owned(),
         }
     }
 }
 
-impl<K, V, T, R, C> Cursor<K, V, T, R> for CursorFrontier<K, V, T, R, C>
+impl<C> Cursor for CursorFrontier<C>
 where
-    C: Cursor<K, V, T, R>,
-    T: Timestamp+Lattice,
+    C: Cursor,
+    C::Time: Timestamp+Lattice,
 {
+    type Key = C::Key;
+    type Val = C::Val;
+    type Time = C::Time;
+    type R = C::R;
+
     type Storage = C::Storage;
 
     #[inline] fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.key_valid(storage) }
     #[inline] fn val_valid(&self, storage: &Self::Storage) -> bool { self.cursor.val_valid(storage) }
 
-    #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K { self.cursor.key(storage) }
-    #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V { self.cursor.val(storage) }
+    #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Key { self.cursor.key(storage) }
+    #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Val { self.cursor.val(storage) }
 
     #[inline]
-    fn map_times<L: FnMut(&T,&R)>(&mut self, storage: &Self::Storage, mut logic: L) {
+    fn map_times<L: FnMut(&Self::Time,&Self::R)>(&mut self, storage: &Self::Storage, mut logic: L) {
         let frontier = self.frontier.borrow();
-        let mut temp: T = <T as timely::progress::Timestamp>::minimum();
+        let mut temp: C::Time = <C::Time as timely::progress::Timestamp>::minimum();
         self.cursor.map_times(storage, |time, diff| {
             temp.clone_from(time);
             temp.advance_by(frontier);
@@ -170,10 +167,10 @@ where
     }
 
     #[inline] fn step_key(&mut self, storage: &Self::Storage) { self.cursor.step_key(storage) }
-    #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &K) { self.cursor.seek_key(storage, key) }
+    #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &Self::Key) { self.cursor.seek_key(storage, key) }
 
     #[inline] fn step_val(&mut self, storage: &Self::Storage) { self.cursor.step_val(storage) }
-    #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &V) { self.cursor.seek_val(storage, val) }
+    #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &Self::Val) { self.cursor.seek_val(storage, val) }
 
     #[inline] fn rewind_keys(&mut self, storage: &Self::Storage) { self.cursor.rewind_keys(storage) }
     #[inline] fn rewind_vals(&mut self, storage: &Self::Storage) { self.cursor.rewind_vals(storage) }
@@ -182,38 +179,41 @@ where
 
 
 /// Wrapper to provide cursor to nested scope.
-pub struct BatchCursorFrontier<K, V, T, R, B: BatchReader<K, V, T, R>> {
-    phantom: ::std::marker::PhantomData<(K, V, R)>,
+pub struct BatchCursorFrontier<B: BatchReader> {
     cursor: B::Cursor,
-    frontier: Antichain<T>,
+    frontier: Antichain<B::Time>,
 }
 
-impl<K, V, T: Clone, R, B: BatchReader<K, V, T, R>> BatchCursorFrontier<K, V, T, R, B> {
-    fn new(cursor: B::Cursor, frontier: AntichainRef<T>) -> Self {
+impl<B: BatchReader> BatchCursorFrontier<B> where B::Time: Clone {
+    fn new(cursor: B::Cursor, frontier: AntichainRef<B::Time>) -> Self {
         BatchCursorFrontier {
-            phantom: ::std::marker::PhantomData,
             cursor,
             frontier: frontier.to_owned(),
         }
     }
 }
 
-impl<K, V, T, R, B: BatchReader<K, V, T, R>> Cursor<K, V, T, R> for BatchCursorFrontier<K, V, T, R, B>
+impl<B: BatchReader> Cursor for BatchCursorFrontier<B>
 where
-    T: Timestamp+Lattice,
+    B::Time: Timestamp+Lattice,
 {
-    type Storage = BatchFrontier<K, V, T, R, B>;
+    type Key = B::Key;
+    type Val = B::Val;
+    type Time = B::Time;
+    type R = B::R;
+
+    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) }
 
-    #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K { self.cursor.key(&storage.batch) }
-    #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V { self.cursor.val(&storage.batch) }
+    #[inline] fn key<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Key { self.cursor.key(&storage.batch) }
+    #[inline] fn val<'a>(&self, storage: &'a Self::Storage) -> &'a Self::Val { self.cursor.val(&storage.batch) }
 
     #[inline]
-    fn map_times<L: FnMut(&T,&R)>(&mut self, storage: &Self::Storage, mut logic: L) {
+    fn map_times<L: FnMut(&Self::Time,&Self::R)>(&mut self, storage: &Self::Storage, mut logic: L) {
         let frontier = self.frontier.borrow();
-        let mut temp: T = <T as timely::progress::Timestamp>::minimum();
+        let mut temp: B::Time = <B::Time as timely::progress::Timestamp>::minimum();
         self.cursor.map_times(&storage.batch, |time, diff| {
             temp.clone_from(time);
             temp.advance_by(frontier);
@@ -222,10 +222,10 @@ where
     }
 
     #[inline] fn step_key(&mut self, storage: &Self::Storage) { self.cursor.step_key(&storage.batch) }
-    #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &K) { self.cursor.seek_key(&storage.batch, key) }
+    #[inline] fn seek_key(&mut self, storage: &Self::Storage, key: &Self::Key) { self.cursor.seek_key(&storage.batch, key) }
 
     #[inline] fn step_val(&mut self, storage: &Self::Storage) { self.cursor.step_val(&storage.batch) }
-    #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &V) { self.cursor.seek_val(&storage.batch, val) }
+    #[inline] fn seek_val(&mut self, storage: &Self::Storage, val: &Self::Val) { self.cursor.seek_val(&storage.batch, val) }
 
     #[inline] fn rewind_keys(&mut self, storage: &Self::Storage) { self.cursor.rewind_keys(&storage.batch) }
     #[inline] fn rewind_vals(&mut self, storage: &Self::Storage) { self.cursor.rewind_vals(&storage.batch) }
diff --git a/src/trace/wrappers/rc.rs b/src/trace/wrappers/rc.rs
index 17796d12b..b31f8779e 100644
--- a/src/trace/wrappers/rc.rs
+++ b/src/trace/wrappers/rc.rs
@@ -120,7 +120,7 @@ where
     }
     fn get_physical_compaction(&mut self) -> AntichainRef<Tr::Time> { self.physical_compaction.borrow() }
     /// Creates a new cursor over the wrapped trace.
-    fn cursor_through(&mut self, frontier: AntichainRef<Tr::Time>) -> Option<(Tr::Cursor, <Tr::Cursor as Cursor<Tr::Key, Tr::Val, Tr::Time, Tr::R>>::Storage)> {
+    fn cursor_through(&mut self, frontier: AntichainRef<Tr::Time>) -> Option<(Tr::Cursor, <Tr::Cursor as Cursor>::Storage)> {
         ::std::cell::RefCell::borrow_mut(&self.wrapper).trace.cursor_through(frontier)
     }
 
diff --git a/tests/trace.rs b/tests/trace.rs
index 1c22f4665..f87ffa33e 100644
--- a/tests/trace.rs
+++ b/tests/trace.rs
@@ -8,18 +8,18 @@ use timely::progress::{Antichain, frontier::AntichainRef};
 
 use differential_dataflow::trace::implementations::ord::OrdValBatch;
 use differential_dataflow::trace::{Trace, TraceReader, Batch, Batcher};
-use differential_dataflow::trace::cursor::CursorDebug;
+use differential_dataflow::trace::cursor::Cursor;
 use differential_dataflow::trace::implementations::spine_fueled::Spine;
 
-pub type OrdValSpine<K, V, T, R> = Spine<K, V, T, R, Rc<OrdValBatch<K, V, T, R>>>;
+pub type OrdValSpine<K, V, T, R> = Spine<Rc<OrdValBatch<K, V, T, R>>>;
 
 type IntegerTrace = OrdValSpine<u64, u64, usize, i64>;
 
-fn get_trace() -> Spine<u64, u64, usize, i64, Rc<OrdValBatch<u64, u64, usize, i64>>> {
+fn get_trace() -> Spine<Rc<OrdValBatch<u64, u64, usize, i64>>> {
     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),