diff --git a/examples/arrange.rs b/examples/arrange.rs
index d7905907e..8fbda1cba 100644
--- a/examples/arrange.rs
+++ b/examples/arrange.rs
@@ -36,7 +36,7 @@ fn main() {
         let mut probe = timely::dataflow::operators::probe::Handle::new();
 
         // create a dataflow managing an ever-changing edge collection.
-    	let mut graph = worker.dataflow::<Product<(),usize>,_,_>(|scope| {
+        let mut graph = worker.dataflow::<Product<(),usize>,_,_>(|scope| {
 
             // create a source operator which will produce random edges and delete them.
             timely::dataflow::operators::generic::source(scope, "RandomGraph", |mut capability, info| {
diff --git a/examples/compact.rs b/examples/compact.rs
index 665af2d42..dc90d88ae 100644
--- a/examples/compact.rs
+++ b/examples/compact.rs
@@ -19,7 +19,7 @@ fn main() {
         let mut probe = timely::dataflow::operators::probe::Handle::new();
 
         // create a dataflow managing an ever-changing edge collection.
-    	let mut handle = worker.dataflow(|scope| {
+        let mut handle = worker.dataflow(|scope| {
             let (handle, input) = scope.new_collection();
             input.distinct().probe_with(&mut probe);
             handle
diff --git a/src/difference.rs b/src/difference.rs
index c3010f461..16c6b5fb8 100644
--- a/src/difference.rs
+++ b/src/difference.rs
@@ -25,70 +25,70 @@ pub use self::Abelian as Diff;
 /// in order of timestamps, for many types of timestamps there is no total order and consequently no
 /// obvious order to respect. Non-commutative semigroups should be used with care.
 pub trait Semigroup : for<'a> AddAssign<&'a Self> + ::std::marker::Sized + Data + Clone {
-	/// Returns true if the element is the additive identity.
-	///
-	/// This is primarily used by differential dataflow to know when it is safe to delete an update.
-	/// When a difference accumulates to zero, the difference has no effect on any accumulation and can
-	/// be removed.
-	///
-	/// A semigroup is not obligated to have a zero element, and this method could always return
-	/// false in such a setting.
-	fn is_zero(&self) -> bool;
+    /// Returns true if the element is the additive identity.
+    ///
+    /// This is primarily used by differential dataflow to know when it is safe to delete an update.
+    /// When a difference accumulates to zero, the difference has no effect on any accumulation and can
+    /// be removed.
+    ///
+    /// A semigroup is not obligated to have a zero element, and this method could always return
+    /// false in such a setting.
+    fn is_zero(&self) -> bool;
 }
 
 impl Semigroup for isize {
-	#[inline] fn is_zero(&self) -> bool { self == &0 }
+    #[inline] fn is_zero(&self) -> bool { self == &0 }
 }
 
 impl Semigroup for i128 {
-	#[inline] fn is_zero(&self) -> bool { self == &0 }
+    #[inline] fn is_zero(&self) -> bool { self == &0 }
 }
 
 impl Semigroup for i64 {
-	#[inline] fn is_zero(&self) -> bool { self == &0 }
+    #[inline] fn is_zero(&self) -> bool { self == &0 }
 }
 
 impl Semigroup for i32 {
-	#[inline] fn is_zero(&self) -> bool { self == &0 }
+    #[inline] fn is_zero(&self) -> bool { self == &0 }
 }
 
 impl Semigroup for i16 {
-	#[inline] fn is_zero(&self) -> bool { self == &0 }
+    #[inline] fn is_zero(&self) -> bool { self == &0 }
 }
 
 impl Semigroup for i8 {
-	#[inline] fn is_zero(&self) -> bool { self == &0 }
+    #[inline] fn is_zero(&self) -> bool { self == &0 }
 }
 
 
 /// A semigroup with an explicit zero element.
 pub trait Monoid : Semigroup {
-	/// A zero element under the semigroup addition operator.
-	fn zero() -> Self;
+    /// A zero element under the semigroup addition operator.
+    fn zero() -> Self;
 }
 
 impl Monoid for isize {
-	#[inline] fn zero() -> Self { 0 }
+    #[inline] fn zero() -> Self { 0 }
 }
 
 impl Monoid for i128 {
-	#[inline] fn zero() -> Self { 0 }
+    #[inline] fn zero() -> Self { 0 }
 }
 
 impl Monoid for i64 {
-	#[inline] fn zero() -> Self { 0 }
+    #[inline] fn zero() -> Self { 0 }
 }
 
 impl Monoid for i32 {
-	#[inline] fn zero() -> Self { 0 }
+    #[inline] fn zero() -> Self { 0 }
 }
 
 impl Monoid for i16 {
-	#[inline] fn zero() -> Self { 0 }
+    #[inline] fn zero() -> Self { 0 }
 }
 
 impl Monoid for i8 {
-	#[inline] fn zero() -> Self { 0 }
+    #[inline] fn zero() -> Self { 0 }
 }
 
 
@@ -104,209 +104,209 @@ impl<T: Monoid + Neg<Output=Self>> Abelian for T { }
 pub use self::present::Present;
 mod present {
 
-	/// A zero-sized difference that indicates the presence of a record.
-	///
-	/// This difference type has no negation, and present records cannot be retracted.
-	/// Addition and multiplication maintain presence, and zero does not inhabit the type.
-	///
-	/// The primary feature of this type is that it has zero size, which reduces the overhead
-	/// of differential dataflow's representations for settings where collections either do
-	/// not change, or for which records are only added (for example, derived facts in Datalog).
-	#[derive(Abomonation, Copy, Ord, PartialOrd, Eq, PartialEq, Debug, Clone, Serialize, Deserialize, Hash)]
-	pub struct Present;
-
-	impl<'a> std::ops::AddAssign<&'a Self> for Present {
-		fn add_assign(&mut self, _rhs: &'a Self) { }
-	}
-
-	impl<T> std::ops::Mul<T> for Present {
-		type Output = T;
-		fn mul(self, rhs: T) -> T {
-			rhs
-		}
-	}
-
-	impl super::Semigroup for Present {
-		fn is_zero(&self) -> bool { false }
-	}
+    /// A zero-sized difference that indicates the presence of a record.
+    ///
+    /// This difference type has no negation, and present records cannot be retracted.
+    /// Addition and multiplication maintain presence, and zero does not inhabit the type.
+    ///
+    /// The primary feature of this type is that it has zero size, which reduces the overhead
+    /// of differential dataflow's representations for settings where collections either do
+    /// not change, or for which records are only added (for example, derived facts in Datalog).
+    #[derive(Abomonation, Copy, Ord, PartialOrd, Eq, PartialEq, Debug, Clone, Serialize, Deserialize, Hash)]
+    pub struct Present;
+
+    impl<'a> std::ops::AddAssign<&'a Self> for Present {
+        fn add_assign(&mut self, _rhs: &'a Self) { }
+    }
+
+    impl<T> std::ops::Mul<T> for Present {
+        type Output = T;
+        fn mul(self, rhs: T) -> T {
+            rhs
+        }
+    }
+
+    impl super::Semigroup for Present {
+        fn is_zero(&self) -> bool { false }
+    }
 }
 
 pub use self::pair::DiffPair;
 mod pair {
 
-	use std::ops::{AddAssign, Neg, Mul};
-	use super::{Semigroup, Monoid};
-
-	/// The difference defined by a pair of difference elements.
-	///
-	/// This type is essentially a "pair", though in Rust the tuple types do not derive the numeric
-	/// traits we require, and so we need to emulate the types ourselves. In the interest of ergonomics,
-	/// we may eventually replace the numeric traits with our own, so that we can implement them for
-	/// tuples and allow users to ignore details like these.
-	#[derive(Abomonation, Copy, Ord, PartialOrd, Eq, PartialEq, Debug, Clone, Serialize, Deserialize)]
-	pub struct DiffPair<R1, R2> {
-		/// The first element in the pair.
-		pub element1: R1,
-		/// The second element in the pair.
-		pub element2: R2,
-	}
-
-	impl<R1, R2> DiffPair<R1, R2> {
-		/// Creates a new Diff pair from two elements.
-		#[inline] pub fn new(elt1: R1, elt2: R2) -> Self {
-			DiffPair {
-				element1: elt1,
-				element2: elt2,
-			}
-		}
-	}
-
-	impl<R1: Semigroup, R2: Semigroup> Semigroup for DiffPair<R1, R2> {
-		#[inline] fn is_zero(&self) -> bool {
-			self.element1.is_zero() && self.element2.is_zero()
-		}
-	}
-
-	impl<'a, R1: AddAssign<&'a R1>, R2: AddAssign<&'a R2>> AddAssign<&'a DiffPair<R1, R2>> for DiffPair<R1, R2> {
-		#[inline] fn add_assign(&mut self, rhs: &'a Self) {
-			self.element1 += &rhs.element1;
-			self.element2 += &rhs.element2;
-		}
-	}
-
-	impl<R1: Neg, R2: Neg> Neg for DiffPair<R1, R2> {
-		type Output = DiffPair<<R1 as Neg>::Output, <R2 as Neg>::Output>;
-		#[inline] fn neg(self) -> Self::Output {
-			DiffPair {
-				element1: -self.element1,
-				element2: -self.element2,
-			}
-		}
-	}
-
-	impl<T: Copy, R1: Mul<T>, R2: Mul<T>> Mul<T> for DiffPair<R1,R2> {
-		type Output = DiffPair<<R1 as Mul<T>>::Output, <R2 as Mul<T>>::Output>;
-		fn mul(self, other: T) -> Self::Output {
-			DiffPair::new(
-				self.element1 * other,
-				self.element2 * other,
-			)
-		}
-	}
-
-	impl<R1: Monoid, R2: Monoid> Monoid for DiffPair<R1, R2> {
-		fn zero() -> Self {
-			Self {
-				element1: R1::zero(),
-				element2: R2::zero(),
-			}
-		}
-	}
-
-	// // TODO: This currently causes rustc to trip a recursion limit, because who knows why.
-	// impl<R1: Diff, R2: Diff> Mul<DiffPair<R1,R2>> for isize
-	// where isize: Mul<R1>, isize: Mul<R2>, <isize as Mul<R1>>::Output: Diff, <isize as Mul<R2>>::Output: Diff {
-	// 	type Output = DiffPair<<isize as Mul<R1>>::Output, <isize as Mul<R2>>::Output>;
-	// 	fn mul(self, other: DiffPair<R1,R2>) -> Self::Output {
-	// 		DiffPair::new(
-	// 			self * other.element1,
-	// 			self * other.element2,
-	// 		)
-	// 	}
-	// }
+    use std::ops::{AddAssign, Neg, Mul};
+    use super::{Semigroup, Monoid};
+
+    /// The difference defined by a pair of difference elements.
+    ///
+    /// This type is essentially a "pair", though in Rust the tuple types do not derive the numeric
+    /// traits we require, and so we need to emulate the types ourselves. In the interest of ergonomics,
+    /// we may eventually replace the numeric traits with our own, so that we can implement them for
+    /// tuples and allow users to ignore details like these.
+    #[derive(Abomonation, Copy, Ord, PartialOrd, Eq, PartialEq, Debug, Clone, Serialize, Deserialize)]
+    pub struct DiffPair<R1, R2> {
+        /// The first element in the pair.
+        pub element1: R1,
+        /// The second element in the pair.
+        pub element2: R2,
+    }
+
+    impl<R1, R2> DiffPair<R1, R2> {
+        /// Creates a new Diff pair from two elements.
+        #[inline] pub fn new(elt1: R1, elt2: R2) -> Self {
+            DiffPair {
+                element1: elt1,
+                element2: elt2,
+            }
+        }
+    }
+
+    impl<R1: Semigroup, R2: Semigroup> Semigroup for DiffPair<R1, R2> {
+        #[inline] fn is_zero(&self) -> bool {
+            self.element1.is_zero() && self.element2.is_zero()
+        }
+    }
+
+    impl<'a, R1: AddAssign<&'a R1>, R2: AddAssign<&'a R2>> AddAssign<&'a DiffPair<R1, R2>> for DiffPair<R1, R2> {
+        #[inline] fn add_assign(&mut self, rhs: &'a Self) {
+            self.element1 += &rhs.element1;
+            self.element2 += &rhs.element2;
+        }
+    }
+
+    impl<R1: Neg, R2: Neg> Neg for DiffPair<R1, R2> {
+        type Output = DiffPair<<R1 as Neg>::Output, <R2 as Neg>::Output>;
+        #[inline] fn neg(self) -> Self::Output {
+            DiffPair {
+                element1: -self.element1,
+                element2: -self.element2,
+            }
+        }
+    }
+
+    impl<T: Copy, R1: Mul<T>, R2: Mul<T>> Mul<T> for DiffPair<R1,R2> {
+        type Output = DiffPair<<R1 as Mul<T>>::Output, <R2 as Mul<T>>::Output>;
+        fn mul(self, other: T) -> Self::Output {
+            DiffPair::new(
+                self.element1 * other,
+                self.element2 * other,
+            )
+        }
+    }
+
+    impl<R1: Monoid, R2: Monoid> Monoid for DiffPair<R1, R2> {
+        fn zero() -> Self {
+            Self {
+                element1: R1::zero(),
+                element2: R2::zero(),
+            }
+        }
+    }
+
+    // // TODO: This currently causes rustc to trip a recursion limit, because who knows why.
+    // impl<R1: Diff, R2: Diff> Mul<DiffPair<R1,R2>> for isize
+    // where isize: Mul<R1>, isize: Mul<R2>, <isize as Mul<R1>>::Output: Diff, <isize as Mul<R2>>::Output: Diff {
+    //     type Output = DiffPair<<isize as Mul<R1>>::Output, <isize as Mul<R2>>::Output>;
+    //     fn mul(self, other: DiffPair<R1,R2>) -> Self::Output {
+    //         DiffPair::new(
+    //             self * other.element1,
+    //             self * other.element2,
+    //         )
+    //     }
+    // }
 }
 
 pub use self::vector::DiffVector;
 mod vector {
 
-	use std::ops::{AddAssign, Neg, Mul};
-	use super::{Semigroup, Monoid};
-
-	/// A variable number of accumulable updates.
-	#[derive(Abomonation, Ord, PartialOrd, Eq, PartialEq, Debug, Clone, Serialize, Deserialize)]
-	pub struct DiffVector<R> {
-		buffer: Vec<R>,
-	}
-
-	impl<R> DiffVector<R> {
-		/// Create new DiffVector from Vec
-		#[inline(always)]
-		pub fn new(vec: Vec<R>) -> DiffVector<R> {
-			DiffVector { buffer: vec }
-		}
-	}
-
-	impl<R> IntoIterator for DiffVector<R> {
-		type Item = R;
-		type IntoIter = ::std::vec::IntoIter<R>;
-		fn into_iter(self) -> Self::IntoIter {
-			self.buffer.into_iter()
-		}
-	}
-
-	impl<R> std::ops::Deref for DiffVector<R> {
-		type Target = [R];
-		fn deref(&self) -> &Self::Target {
-			&self.buffer[..]
-		}
-	}
-
-	impl<R> std::ops::DerefMut for DiffVector<R> {
-		fn deref_mut(&mut self) -> &mut Self::Target {
-			&mut self.buffer[..]
-		}
-	}
-
-	impl<R: Semigroup> Semigroup for DiffVector<R> {
-		#[inline] fn is_zero(&self) -> bool {
-			self.buffer.iter().all(|x| x.is_zero())
-		}
-	}
-
-	impl<'a, R: AddAssign<&'a R>+Clone> AddAssign<&'a DiffVector<R>> for DiffVector<R> {
-		#[inline]
-		fn add_assign(&mut self, rhs: &'a Self) {
-
-			// Ensure sufficient length to receive addition.
-			while self.buffer.len() < rhs.buffer.len() {
-				let element = &rhs.buffer[self.buffer.len()];
-				self.buffer.push(element.clone());
-			}
-
-			// As other is not longer, apply updates without tests.
-			for (index, update) in rhs.buffer.iter().enumerate() {
-				self.buffer[index] += update;
-			}
-		}
-	}
-
-	impl<R: Neg<Output=R>+Clone> Neg for DiffVector<R> {
-		type Output = DiffVector<<R as Neg>::Output>;
-		#[inline]
-		fn neg(mut self) -> Self::Output {
-			for update in self.buffer.iter_mut() {
-				*update = -update.clone();
-			}
-			self
-		}
-	}
-
-	impl<T: Copy, R: Mul<T>> Mul<T> for DiffVector<R> {
-		type Output = DiffVector<<R as Mul<T>>::Output>;
-		fn mul(self, other: T) -> Self::Output {
-			let buffer =
-			self.buffer
-				.into_iter()
-				.map(|x| x * other)
-				.collect();
-
-			DiffVector { buffer }
-		}
-	}
-
-	impl<R: Semigroup> Monoid for DiffVector<R> {
-		fn zero() -> Self {
-			Self { buffer: Vec::new() }
-		}
-	}
+    use std::ops::{AddAssign, Neg, Mul};
+    use super::{Semigroup, Monoid};
+
+    /// A variable number of accumulable updates.
+    #[derive(Abomonation, Ord, PartialOrd, Eq, PartialEq, Debug, Clone, Serialize, Deserialize)]
+    pub struct DiffVector<R> {
+        buffer: Vec<R>,
+    }
+
+    impl<R> DiffVector<R> {
+        /// Create new DiffVector from Vec
+        #[inline(always)]
+        pub fn new(vec: Vec<R>) -> DiffVector<R> {
+            DiffVector { buffer: vec }
+        }
+    }
+
+    impl<R> IntoIterator for DiffVector<R> {
+        type Item = R;
+        type IntoIter = ::std::vec::IntoIter<R>;
+        fn into_iter(self) -> Self::IntoIter {
+            self.buffer.into_iter()
+        }
+    }
+
+    impl<R> std::ops::Deref for DiffVector<R> {
+        type Target = [R];
+        fn deref(&self) -> &Self::Target {
+            &self.buffer[..]
+        }
+    }
+
+    impl<R> std::ops::DerefMut for DiffVector<R> {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            &mut self.buffer[..]
+        }
+    }
+
+    impl<R: Semigroup> Semigroup for DiffVector<R> {
+        #[inline] fn is_zero(&self) -> bool {
+            self.buffer.iter().all(|x| x.is_zero())
+        }
+    }
+
+    impl<'a, R: AddAssign<&'a R>+Clone> AddAssign<&'a DiffVector<R>> for DiffVector<R> {
+        #[inline]
+        fn add_assign(&mut self, rhs: &'a Self) {
+
+            // Ensure sufficient length to receive addition.
+            while self.buffer.len() < rhs.buffer.len() {
+                let element = &rhs.buffer[self.buffer.len()];
+                self.buffer.push(element.clone());
+            }
+
+            // As other is not longer, apply updates without tests.
+            for (index, update) in rhs.buffer.iter().enumerate() {
+                self.buffer[index] += update;
+            }
+        }
+    }
+
+    impl<R: Neg<Output=R>+Clone> Neg for DiffVector<R> {
+        type Output = DiffVector<<R as Neg>::Output>;
+        #[inline]
+        fn neg(mut self) -> Self::Output {
+            for update in self.buffer.iter_mut() {
+                *update = -update.clone();
+            }
+            self
+        }
+    }
+
+    impl<T: Copy, R: Mul<T>> Mul<T> for DiffVector<R> {
+        type Output = DiffVector<<R as Mul<T>>::Output>;
+        fn mul(self, other: T) -> Self::Output {
+            let buffer =
+            self.buffer
+                .into_iter()
+                .map(|x| x * other)
+                .collect();
+
+            DiffVector { buffer }
+        }
+    }
+
+    impl<R: Semigroup> Monoid for DiffVector<R> {
+        fn zero() -> Self {
+            Self { buffer: Vec::new() }
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/input.rs b/src/input.rs
index 1bb182c6c..d3cdff34f 100644
--- a/src/input.rs
+++ b/src/input.rs
@@ -31,19 +31,19 @@ pub trait Input : TimelyInput {
     /// fn main() {
     ///     ::timely::execute(Config::thread(), |worker| {
     ///
-    ///			let (mut handle, probe) = worker.dataflow::<(),_,_>(|scope| {
-    ///				// create input handle and collection.
-    ///				let (handle, data) = scope.new_collection();
-    ///         	let probe = data.map(|x| x * 2)
-    ///				            	.inspect(|x| println!("{:?}", x))
-    ///				            	.probe();
-    ///				(handle, probe)
-    ///     	});
+    ///            let (mut handle, probe) = worker.dataflow::<(),_,_>(|scope| {
+    ///                // create input handle and collection.
+    ///                let (handle, data) = scope.new_collection();
+    ///             let probe = data.map(|x| x * 2)
+    ///                                .inspect(|x| println!("{:?}", x))
+    ///                                .probe();
+    ///                (handle, probe)
+    ///         });
     ///
-    ///			handle.insert(1);
-    ///			handle.insert(5);
+    ///            handle.insert(1);
+    ///            handle.insert(5);
     ///
-    ///		}).unwrap();
+    ///        }).unwrap();
     /// }
     /// ```
     fn new_collection<D, R>(&mut self) -> (InputSession<<Self as ScopeParent>::Timestamp, D, R>, Collection<Self, D, R>)
@@ -62,19 +62,19 @@ pub trait Input : TimelyInput {
     /// fn main() {
     ///     ::timely::execute(Config::thread(), |worker| {
     ///
-    ///			let (mut handle, probe) = worker.dataflow::<(),_,_>(|scope| {
-    ///				// create input handle and collection.
-    ///				let (handle, data) = scope.new_collection_from(0 .. 10);
-    ///         	let probe = data.map(|x| x * 2)
-    ///				            	.inspect(|x| println!("{:?}", x))
-    ///				            	.probe();
-    ///				(handle, probe)
-    ///     	});
+    ///            let (mut handle, probe) = worker.dataflow::<(),_,_>(|scope| {
+    ///                // create input handle and collection.
+    ///                let (handle, data) = scope.new_collection_from(0 .. 10);
+    ///             let probe = data.map(|x| x * 2)
+    ///                                .inspect(|x| println!("{:?}", x))
+    ///                                .probe();
+    ///                (handle, probe)
+    ///         });
     ///
-    ///			handle.insert(1);
-    ///			handle.insert(5);
+    ///            handle.insert(1);
+    ///            handle.insert(5);
     ///
-    ///		}).unwrap();
+    ///        }).unwrap();
     /// }
     /// ```
     fn new_collection_from<I>(&mut self, data: I) -> (InputSession<<Self as ScopeParent>::Timestamp, I::Item, isize>, Collection<Self, I::Item, isize>)
@@ -116,8 +116,8 @@ use lattice::Lattice;
 impl<G: TimelyInput> Input for G where <G as ScopeParent>::Timestamp: Lattice {
     fn new_collection<D, R>(&mut self) -> (InputSession<<G as ScopeParent>::Timestamp, D, R>, Collection<G, D, R>)
     where D: Data, R: Semigroup{
-		let (handle, stream) = self.new_input();
-		(InputSession::from(handle), stream.as_collection())
+        let (handle, stream) = self.new_input();
+        (InputSession::from(handle), stream.as_collection())
     }
     fn new_collection_from<I>(&mut self, data: I) -> (InputSession<<G as ScopeParent>::Timestamp, I::Item, isize>, Collection<G, I::Item, isize>)
     where I: IntoIterator+'static, I::Item: Data {
@@ -156,47 +156,47 @@ impl<G: TimelyInput> Input for G where <G as ScopeParent>::Timestamp: Lattice {
 /// fn main() {
 ///     ::timely::execute(Config::thread(), |worker| {
 ///
-///			let (mut handle, probe) = worker.dataflow(|scope| {
-///				// create input handle and collection.
-///				let (handle, data) = scope.new_collection_from(0 .. 10);
-///         	let probe = data.map(|x| x * 2)
-///				            	.inspect(|x| println!("{:?}", x))
-///				            	.probe();
-///				(handle, probe)
-///     	});
+///            let (mut handle, probe) = worker.dataflow(|scope| {
+///                // create input handle and collection.
+///                let (handle, data) = scope.new_collection_from(0 .. 10);
+///             let probe = data.map(|x| x * 2)
+///                                .inspect(|x| println!("{:?}", x))
+///                                .probe();
+///                (handle, probe)
+///         });
 ///
-///			handle.insert(3);
-///			handle.advance_to(1);
-///			handle.insert(5);
-///			handle.advance_to(2);
-///			handle.flush();
+///            handle.insert(3);
+///            handle.advance_to(1);
+///            handle.insert(5);
+///            handle.advance_to(2);
+///            handle.flush();
 ///
-///			while probe.less_than(handle.time()) {
-///				worker.step();
-///			}
+///            while probe.less_than(handle.time()) {
+///                worker.step();
+///            }
 ///
-///			handle.remove(5);
-///			handle.advance_to(3);
-///			handle.flush();
+///            handle.remove(5);
+///            handle.advance_to(3);
+///            handle.flush();
 ///
-///			while probe.less_than(handle.time()) {
-///				worker.step();
-///			}
+///            while probe.less_than(handle.time()) {
+///                worker.step();
+///            }
 ///
-///		}).unwrap();
+///        }).unwrap();
 /// }
 /// ```
 pub struct InputSession<T: Timestamp+Clone, D: Data, R: Semigroup> {
-	time: T,
-	buffer: Vec<(D, T, R)>,
-	handle: Handle<T,(D,T,R)>,
+    time: T,
+    buffer: Vec<(D, T, R)>,
+    handle: Handle<T,(D,T,R)>,
 }
 
 impl<T: Timestamp+Clone, D: Data> InputSession<T, D, isize> {
-	/// Adds an element to the collection.
-	pub fn insert(&mut self, element: D) { self.update(element, 1); }
-	/// Removes an element from the collection.
-	pub fn remove(&mut self, element: D) { self.update(element,-1); }
+    /// Adds an element to the collection.
+    pub fn insert(&mut self, element: D) { self.update(element, 1); }
+    /// Removes an element from the collection.
+    pub fn remove(&mut self, element: D) { self.update(element,-1); }
 }
 
 // impl<T: Timestamp+Clone, D: Data> InputSession<T, D, i64> {
@@ -235,17 +235,17 @@ impl<T: Timestamp+Clone, D: Data, R: Semigroup> InputSession<T, D, R> {
         }
     }
 
-	/// Creates a new session from a reference to an input handle.
-	pub fn from(handle: Handle<T,(D,T,R)>) -> Self {
-		InputSession {
-			time: handle.time().clone(),
-			buffer: Vec::new(),
-			handle,
-		}
-	}
+    /// Creates a new session from a reference to an input handle.
+    pub fn from(handle: Handle<T,(D,T,R)>) -> Self {
+        InputSession {
+            time: handle.time().clone(),
+            buffer: Vec::new(),
+            handle,
+        }
+    }
 
-	/// Adds to the weight of an element in the collection.
-	pub fn update(&mut self, element: D, change: R) {
+    /// Adds to the weight of an element in the collection.
+    pub fn update(&mut self, element: D, change: R) {
         if self.buffer.len() == self.buffer.capacity() {
             if self.buffer.len() > 0 {
                 self.handle.send_batch(&mut self.buffer);
@@ -253,8 +253,8 @@ impl<T: Timestamp+Clone, D: Data, R: Semigroup> InputSession<T, D, R> {
             // TODO : This is a fairly arbitrary choice; should probably use `Context::default_size()` or such.
             self.buffer.reserve(1024);
         }
-		self.buffer.push((element, self.time.clone(), change));
-	}
+        self.buffer.push((element, self.time.clone(), change));
+    }
 
     /// Adds to the weight of an element in the collection at a future time.
     pub fn update_at(&mut self, element: D, time: T, change: R) {
@@ -269,40 +269,40 @@ impl<T: Timestamp+Clone, D: Data, R: Semigroup> InputSession<T, D, R> {
         self.buffer.push((element, time, change));
     }
 
-	/// Forces buffered data into the timely dataflow input, and advances its time to match that of the session.
-	///
-	/// It is important to call `flush` before expecting timely dataflow to report progress. Until this method is
-	/// called, all updates may still be in internal buffers and not exposed to timely dataflow. Once the method is
-	/// called, all buffers are flushed and timely dataflow is advised that some logical times are no longer possible.
-	pub fn flush(&mut self) {
-		self.handle.send_batch(&mut self.buffer);
-		if self.handle.epoch().less_than(&self.time) {
-			self.handle.advance_to(self.time.clone());
-		}
-	}
+    /// Forces buffered data into the timely dataflow input, and advances its time to match that of the session.
+    ///
+    /// It is important to call `flush` before expecting timely dataflow to report progress. Until this method is
+    /// called, all updates may still be in internal buffers and not exposed to timely dataflow. Once the method is
+    /// called, all buffers are flushed and timely dataflow is advised that some logical times are no longer possible.
+    pub fn flush(&mut self) {
+        self.handle.send_batch(&mut self.buffer);
+        if self.handle.epoch().less_than(&self.time) {
+            self.handle.advance_to(self.time.clone());
+        }
+    }
 
-	/// Advances the logical time for future records.
-	///
-	/// Importantly, this method does **not** immediately inform timely dataflow of the change. This happens only when
-	/// the session is dropped or flushed. It is not correct to use this time as a basis for a computation's `step_while`
-	/// method unless the session has just been flushed.
-	pub fn advance_to(&mut self, time: T) {
-		assert!(self.handle.epoch().less_equal(&time));
-		assert!(&self.time.less_equal(&time));
-		self.time = time;
-	}
+    /// Advances the logical time for future records.
+    ///
+    /// Importantly, this method does **not** immediately inform timely dataflow of the change. This happens only when
+    /// the session is dropped or flushed. It is not correct to use this time as a basis for a computation's `step_while`
+    /// method unless the session has just been flushed.
+    pub fn advance_to(&mut self, time: T) {
+        assert!(self.handle.epoch().less_equal(&time));
+        assert!(&self.time.less_equal(&time));
+        self.time = time;
+    }
 
-	/// Reveals the current time of the session.
-	pub fn epoch(&self) -> &T { &self.time }
-	/// Reveals the current time of the session.
-	pub fn time(&self) -> &T { &self.time }
+    /// Reveals the current time of the session.
+    pub fn epoch(&self) -> &T { &self.time }
+    /// Reveals the current time of the session.
+    pub fn time(&self) -> &T { &self.time }
 
-	/// Closes the input, flushing and sealing the wrapped timely input.
-	pub fn close(self) { }
+    /// Closes the input, flushing and sealing the wrapped timely input.
+    pub fn close(self) { }
 }
 
 impl<T: Timestamp+Clone, D: Data, R: Semigroup> Drop for InputSession<T, D, R> {
-	fn drop(&mut self) {
-		self.flush();
-	}
+    fn drop(&mut self) {
+        self.flush();
+    }
 }
diff --git a/src/trace/cursor/mod.rs b/src/trace/cursor/mod.rs
index c02268bc6..d76e7cab0 100644
--- a/src/trace/cursor/mod.rs
+++ b/src/trace/cursor/mod.rs
@@ -14,72 +14,72 @@ pub use self::cursor_list::CursorList;
 /// A cursor for navigating ordered `(key, val, time, diff)` updates.
 pub trait Cursor<K, V, T, R> {
 
-	/// Type the cursor addresses data in.
-	type Storage;
+    /// Type the cursor addresses data in.
+    type Storage;
 
-	/// Indicates if the current key is valid.
-	///
-	/// A value of `false` indicates that the cursor has exhausted all keys.
-	fn key_valid(&self, storage: &Self::Storage) -> bool;
-	/// Indicates if the current value is valid.
-	///
-	/// A value of `false` indicates that the cursor has exhausted all values for this key.
-	fn val_valid(&self, storage: &Self::Storage) -> bool;
+    /// Indicates if the current key is valid.
+    ///
+    /// A value of `false` indicates that the cursor has exhausted all keys.
+    fn key_valid(&self, storage: &Self::Storage) -> bool;
+    /// Indicates if the current value is valid.
+    ///
+    /// A value of `false` indicates that the cursor has exhausted all values for this key.
+    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;
-	/// A reference to the current value. Asserts if invalid.
-	fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V;
+    /// A reference to the current key. Asserts if invalid.
+    fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K;
+    /// A reference to the current value. Asserts if invalid.
+    fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V;
 
-	/// Returns a reference to the current key, if valid.
-	fn get_key<'a>(&self, storage: &'a Self::Storage) -> Option<&'a K> {
-		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> {
-		if self.val_valid(storage) { Some(self.val(storage)) } else { None }
-	}
+    /// Returns a reference to the current key, if valid.
+    fn get_key<'a>(&self, storage: &'a Self::Storage) -> Option<&'a K> {
+        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> {
+        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);
+    /// 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);
 
-	/// 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);
+    /// 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);
 
-	/// 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);
+    /// 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);
 
-	/// 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);
+    /// 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)>)> {
-		let mut out = Vec::new();
-		self.rewind_keys(storage);
-		self.rewind_vals(storage);
-		while self.key_valid(storage) {
-			while self.val_valid(storage) {
-				let mut kv_out = Vec::new();
-				self.map_times(storage, |ts, r| {
-					kv_out.push((ts.clone(), r.clone()));
-				});
-				out.push(((self.key(storage).clone(), self.val(storage).clone()), kv_out));
-				self.step_val(storage);
-			}
-			self.step_key(storage);
-		}
-		out
-	}
+    /// Rewinds the cursor and outputs its contents to a Vec
+    fn to_vec(&mut self, storage: &Self::Storage) -> Vec<((K, V), Vec<(T, R)>)> {
+        let mut out = Vec::new();
+        self.rewind_keys(storage);
+        self.rewind_vals(storage);
+        while self.key_valid(storage) {
+            while self.val_valid(storage) {
+                let mut kv_out = Vec::new();
+                self.map_times(storage, |ts, r| {
+                    kv_out.push((ts.clone(), r.clone()));
+                });
+                out.push(((self.key(storage).clone(), self.val(storage).clone()), kv_out));
+                self.step_val(storage);
+            }
+            self.step_key(storage);
+        }
+        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/description.rs b/src/trace/description.rs
index 573887751..e11355808 100644
--- a/src/trace/description.rs
+++ b/src/trace/description.rs
@@ -66,32 +66,32 @@ use timely::{PartialOrder, progress::Antichain};
 /// any time after `since`.
 #[derive(Clone, Debug, Abomonation)]
 pub struct Description<Time> {
-	/// lower frontier of contained updates.
-	lower: Antichain<Time>,
-	/// upper frontier of contained updates.
-	upper: Antichain<Time>,
-	/// frontier used for update compaction.
-	since: Antichain<Time>,
+    /// lower frontier of contained updates.
+    lower: Antichain<Time>,
+    /// upper frontier of contained updates.
+    upper: Antichain<Time>,
+    /// frontier used for update compaction.
+    since: Antichain<Time>,
 }
 
 impl<Time: PartialOrder+Clone> Description<Time> {
-	/// Returns a new description from its component parts.
-	pub fn new(lower: Antichain<Time>, upper: Antichain<Time>, since: Antichain<Time>) -> Self {
-		assert!(lower.elements().len() > 0);	// this should always be true.
-		// assert!(upper.len() > 0);			// this may not always be true.
-		Description {
-			lower,
-			upper,
-			since,
-		}
-	}
+    /// Returns a new description from its component parts.
+    pub fn new(lower: Antichain<Time>, upper: Antichain<Time>, since: Antichain<Time>) -> Self {
+        assert!(lower.elements().len() > 0);    // this should always be true.
+        // assert!(upper.len() > 0);            // this may not always be true.
+        Description {
+            lower,
+            upper,
+            since,
+        }
+    }
 }
 
 impl<Time> Description<Time> {
-	/// The lower envelope for times in the interval.
-	pub fn lower(&self) -> &Antichain<Time> { &self.lower }
-	/// The upper envelope for times in the interval.
-	pub fn upper(&self) -> &Antichain<Time> { &self.upper }
-	/// Times from whose future the interval may be observed.
-	pub fn since(&self) -> &Antichain<Time> { &self.since }
+    /// The lower envelope for times in the interval.
+    pub fn lower(&self) -> &Antichain<Time> { &self.lower }
+    /// The upper envelope for times in the interval.
+    pub fn upper(&self) -> &Antichain<Time> { &self.upper }
+    /// Times from whose future the interval may be observed.
+    pub fn since(&self) -> &Antichain<Time> { &self.since }
 }
\ No newline at end of file
diff --git a/src/trace/implementations/hash.rs b/src/trace/implementations/hash.rs
index c70ae8711..0f245cb36 100644
--- a/src/trace/implementations/hash.rs
+++ b/src/trace/implementations/hash.rs
@@ -36,111 +36,111 @@ pub type HashKeySpine<K, T, R> = Spine<K, (), T, R, Rc<HashKeyBatch<K, T, R>>>;
 /// An immutable collection of update tuples, from a contiguous interval of logical times.
 #[derive(Debug)]
 pub struct HashValBatch<K: HashOrdered, V: Ord, T: Lattice, R: Diff> {
-	/// Where all the dataz is.
-	pub layer: HashedLayer<K, OrderedLayer<V, OrderedLeaf<T, R>>>,
-	/// Description of the update times this layer represents.
-	pub desc: Description<T>,
+    /// Where all the dataz is.
+    pub layer: HashedLayer<K, OrderedLayer<V, OrderedLeaf<T, R>>>,
+    /// Description of the update times this layer represents.
+    pub desc: Description<T>,
 }
 
 impl<K, V, T, R> BatchReader<K, V, T, R> for Rc<HashValBatch<K, V, T, R>>
 where K: Clone+Default+HashOrdered+'static, V: Clone+Ord+'static, T: Lattice+Ord+Clone+Default+'static, R: Diff {
-	type Cursor = HashValCursor<V, T, R>;
-	fn cursor(&self) -> (Self::Cursor, <Self::Cursor as Cursor<K, V, T, R>>::Storage) { 
-		let cursor = HashValCursor {
-			cursor: self.layer.cursor()
-		};
-
-		(cursor, self.clone())
-	}
-	fn len(&self) -> usize { <HashedLayer<K, OrderedLayer<V, OrderedLeaf<T, R>>> as Trie>::tuples(&self.layer) }
-	fn description(&self) -> &Description<T> { &self.desc }
+    type Cursor = HashValCursor<V, T, R>;
+    fn cursor(&self) -> (Self::Cursor, <Self::Cursor as Cursor<K, V, T, R>>::Storage) { 
+        let cursor = HashValCursor {
+            cursor: self.layer.cursor()
+        };
+
+        (cursor, self.clone())
+    }
+    fn len(&self) -> usize { <HashedLayer<K, OrderedLayer<V, OrderedLeaf<T, R>>> as Trie>::tuples(&self.layer) }
+    fn description(&self) -> &Description<T> { &self.desc }
 }
 
 impl<K, V, T, R> Batch<K, V, T, R> for Rc<HashValBatch<K, V, T, R>>
 where K: Clone+Default+HashOrdered+'static, V: Clone+Ord+'static, T: Lattice+Ord+Clone+Default+'static, R: Diff {
-	type Batcher = RadixBatcher<K, V, T, R, Self>;
-	type Builder = HashValBuilder<K, V, T, R>;
-	fn merge(&self, other: &Self) -> Self {
-
-		// Things are horribly wrong if this is not true.
-		assert!(self.desc.upper() == other.desc.lower());
-
-		// one of self.desc.since or other.desc.since needs to be not behind the other...
-		let since = if self.desc.since().iter().all(|t1| other.desc.since().iter().any(|t2| t2.less_equal(t1))) {
-			other.desc.since()
-		}
-		else {
-			self.desc.since()
-		};
-		
-		Rc::new(HashValBatch {
-			layer: <HashedLayer<K, OrderedLayer<V, OrderedLeaf<T, R>>> as Trie>::merge(&self.layer, &other.layer),
-			desc: Description::new(self.desc.lower(), other.desc.upper(), since),
-		})
-	}
+    type Batcher = RadixBatcher<K, V, T, R, Self>;
+    type Builder = HashValBuilder<K, V, T, R>;
+    fn merge(&self, other: &Self) -> Self {
+
+        // Things are horribly wrong if this is not true.
+        assert!(self.desc.upper() == other.desc.lower());
+
+        // one of self.desc.since or other.desc.since needs to be not behind the other...
+        let since = if self.desc.since().iter().all(|t1| other.desc.since().iter().any(|t2| t2.less_equal(t1))) {
+            other.desc.since()
+        }
+        else {
+            self.desc.since()
+        };
+        
+        Rc::new(HashValBatch {
+            layer: <HashedLayer<K, OrderedLayer<V, OrderedLeaf<T, R>>> as Trie>::merge(&self.layer, &other.layer),
+            desc: Description::new(self.desc.lower(), other.desc.upper(), since),
+        })
+    }
 }
 
 /// A cursor for navigating a single layer.
 #[derive(Debug)]
 pub struct HashValCursor<V: Ord+Clone, T: Lattice+Ord+Clone, R: Diff> {
-	cursor: HashedCursor<OrderedLayer<V, OrderedLeaf<T, R>>>,
+    cursor: HashedCursor<OrderedLayer<V, OrderedLeaf<T, R>>>,
 }
 
 impl<K, V, T, R> Cursor<K, V, T, R> for HashValCursor<V, T, R> 
 where K: Clone+HashOrdered, V: Ord+Clone, T: Lattice+Ord+Clone, R: Diff {
 
-	type Storage = Rc<HashValBatch<K, V, T, R>>;//OrderedLayer<K, OrderedLayer<V, OrderedLeaf<T, R>>>;
-
-	fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K { &self.cursor.key(&storage.layer) }
-	fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V { &self.cursor.child.key(&storage.layer.vals) }
-	fn map_times<L: FnMut(&T, R)>(&mut self, storage: &Self::Storage, mut logic: L) {
-		self.cursor.child.child.rewind(&storage.layer.vals.vals);
-		while self.cursor.child.child.valid(&storage.layer.vals.vals) {
-			logic(&self.cursor.child.child.key(&storage.layer.vals.vals).0, self.cursor.child.child.key(&storage.layer.vals.vals).1);
-			self.cursor.child.child.step(&storage.layer.vals.vals);
-		}
-	}
-	fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.valid(&storage.layer) }
-	fn val_valid(&self, storage: &Self::Storage) -> bool { self.cursor.child.valid(&storage.layer.vals) }
-	fn step_key(&mut self, storage: &Self::Storage){ self.cursor.step(&storage.layer); }
-	fn seek_key(&mut self, storage: &Self::Storage, key: &K) { self.cursor.seek(&storage.layer, key); }
-	fn step_val(&mut self, storage: &Self::Storage) { self.cursor.child.step(&storage.layer.vals); }
-	fn seek_val(&mut self, storage: &Self::Storage, val: &V) { self.cursor.child.seek(&storage.layer.vals, val); }
-	fn rewind_keys(&mut self, storage: &Self::Storage) { self.cursor.rewind(&storage.layer); }
-	fn rewind_vals(&mut self, storage: &Self::Storage) { self.cursor.child.rewind(&storage.layer.vals); }
+    type Storage = Rc<HashValBatch<K, V, T, R>>;//OrderedLayer<K, OrderedLayer<V, OrderedLeaf<T, R>>>;
+
+    fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K { &self.cursor.key(&storage.layer) }
+    fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V { &self.cursor.child.key(&storage.layer.vals) }
+    fn map_times<L: FnMut(&T, R)>(&mut self, storage: &Self::Storage, mut logic: L) {
+        self.cursor.child.child.rewind(&storage.layer.vals.vals);
+        while self.cursor.child.child.valid(&storage.layer.vals.vals) {
+            logic(&self.cursor.child.child.key(&storage.layer.vals.vals).0, self.cursor.child.child.key(&storage.layer.vals.vals).1);
+            self.cursor.child.child.step(&storage.layer.vals.vals);
+        }
+    }
+    fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.valid(&storage.layer) }
+    fn val_valid(&self, storage: &Self::Storage) -> bool { self.cursor.child.valid(&storage.layer.vals) }
+    fn step_key(&mut self, storage: &Self::Storage){ self.cursor.step(&storage.layer); }
+    fn seek_key(&mut self, storage: &Self::Storage, key: &K) { self.cursor.seek(&storage.layer, key); }
+    fn step_val(&mut self, storage: &Self::Storage) { self.cursor.child.step(&storage.layer.vals); }
+    fn seek_val(&mut self, storage: &Self::Storage, val: &V) { self.cursor.child.seek(&storage.layer.vals, val); }
+    fn rewind_keys(&mut self, storage: &Self::Storage) { self.cursor.rewind(&storage.layer); }
+    fn rewind_vals(&mut self, storage: &Self::Storage) { self.cursor.child.rewind(&storage.layer.vals); }
 }
 
 /// A builder for creating layers from unsorted update tuples.
 pub struct HashValBuilder<K: HashOrdered, V: Ord, T: Ord+Lattice, R: Diff> {
-	builder: HashedBuilder<K, OrderedBuilder<V, OrderedLeafBuilder<T, R>>>,
+    builder: HashedBuilder<K, OrderedBuilder<V, OrderedLeafBuilder<T, R>>>,
 }
 
 impl<K, V, T, R> Builder<K, V, T, R, Rc<HashValBatch<K, V, T, R>>> for HashValBuilder<K, V, T, R> 
 where K: Clone+Default+HashOrdered+'static, V: Ord+Clone+'static, T: Lattice+Ord+Clone+Default+'static, R: Diff {
 
-	fn new() -> Self { 
-		HashValBuilder { 
-			builder: HashedBuilder::<K, OrderedBuilder<V, OrderedLeafBuilder<T, R>>>::new() 
-		} 
-	}
-	fn with_capacity(cap: usize) -> Self { 
-		HashValBuilder { 
-			builder: HashedBuilder::<K, OrderedBuilder<V, OrderedLeafBuilder<T, R>>>::with_capacity(cap) 
-		} 
-	}
-
-	#[inline]
-	fn push(&mut self, (key, val, time, diff): (K, V, T, R)) {
-		self.builder.push_tuple((key, (val, (time, diff))));
-	}
-
-	#[inline(never)]
-	fn done(self, lower: &[T], upper: &[T], since: &[T]) -> Rc<HashValBatch<K, V, T, R>> {
-		Rc::new(HashValBatch {
-			layer: self.builder.done(),
-			desc: Description::new(lower, upper, since)
-		})
-	}
+    fn new() -> Self { 
+        HashValBuilder { 
+            builder: HashedBuilder::<K, OrderedBuilder<V, OrderedLeafBuilder<T, R>>>::new() 
+        } 
+    }
+    fn with_capacity(cap: usize) -> Self { 
+        HashValBuilder { 
+            builder: HashedBuilder::<K, OrderedBuilder<V, OrderedLeafBuilder<T, R>>>::with_capacity(cap) 
+        } 
+    }
+
+    #[inline]
+    fn push(&mut self, (key, val, time, diff): (K, V, T, R)) {
+        self.builder.push_tuple((key, (val, (time, diff))));
+    }
+
+    #[inline(never)]
+    fn done(self, lower: &[T], upper: &[T], since: &[T]) -> Rc<HashValBatch<K, V, T, R>> {
+        Rc::new(HashValBatch {
+            layer: self.builder.done(),
+            desc: Description::new(lower, upper, since)
+        })
+    }
 }
 
 
@@ -149,120 +149,120 @@ where K: Clone+Default+HashOrdered+'static, V: Ord+Clone+'static, T: Lattice+Ord
 /// An immutable collection of update tuples, from a contiguous interval of logical times.
 #[derive(Debug)]
 pub struct HashKeyBatch<K: HashOrdered, T: Lattice, R> {
-	/// Where all the dataz is.
-	pub layer: HashedLayer<K, OrderedLeaf<T, R>>,
-	/// Description of the update times this layer represents.
-	pub desc: Description<T>,
+    /// Where all the dataz is.
+    pub layer: HashedLayer<K, OrderedLeaf<T, R>>,
+    /// Description of the update times this layer represents.
+    pub desc: Description<T>,
 }
 
 impl<K, T, R> BatchReader<K, (), T, R> for Rc<HashKeyBatch<K, T, R>>
 where K: Clone+Default+HashOrdered+'static, T: Lattice+Ord+Clone+Default+'static, R: Diff {
-	type Cursor = HashKeyCursor<T, R>;
-	// fn cursor(&self) -> (Self::Cursor, <Self::Cursor as Cursor<K, V, T, R>>::Storage) { 
-
-	fn cursor(&self) -> (Self::Cursor, <Self::Cursor as Cursor<K, (), T, R>>::Storage) { 
-		let cursor = HashKeyCursor {
-			empty: (),
-			valid: true,
-			cursor: self.layer.cursor(),
-		};
-		(cursor, self.clone())
-
-		// HashKeyCursor {
-		// 	empty: (),
-		// 	valid: true,
-		// 	cursor: self.layer.cursor(OwningRef::new(self.clone()).map(|x| &x.layer).erase_owner()),
-		// } 
-	}
-	fn len(&self) -> usize { <HashedLayer<K, OrderedLeaf<T, R>> as Trie>::tuples(&self.layer) }
-	fn description(&self) -> &Description<T> { &self.desc }
+    type Cursor = HashKeyCursor<T, R>;
+    // fn cursor(&self) -> (Self::Cursor, <Self::Cursor as Cursor<K, V, T, R>>::Storage) { 
+
+    fn cursor(&self) -> (Self::Cursor, <Self::Cursor as Cursor<K, (), T, R>>::Storage) { 
+        let cursor = HashKeyCursor {
+            empty: (),
+            valid: true,
+            cursor: self.layer.cursor(),
+        };
+        (cursor, self.clone())
+
+        // HashKeyCursor {
+        //     empty: (),
+        //     valid: true,
+        //     cursor: self.layer.cursor(OwningRef::new(self.clone()).map(|x| &x.layer).erase_owner()),
+        // } 
+    }
+    fn len(&self) -> usize { <HashedLayer<K, OrderedLeaf<T, R>> as Trie>::tuples(&self.layer) }
+    fn description(&self) -> &Description<T> { &self.desc }
 }
 
 impl<K, T, R> Batch<K, (), T, R> for Rc<HashKeyBatch<K, T, R>>
 where K: Clone+Default+HashOrdered+'static, T: Lattice+Ord+Clone+Default+'static, R: Diff {
-	type Batcher = RadixBatcher<K, (), T, R, Self>;
-	type Builder = HashKeyBuilder<K, T, R>;
-	fn merge(&self, other: &Self) -> Self {
-
-		// Things are horribly wrong if this is not true.
-		assert!(self.desc.upper() == other.desc.lower());
-
-		// one of self.desc.since or other.desc.since needs to be not behind the other...
-		let since = if self.desc.since().iter().all(|t1| other.desc.since().iter().any(|t2| t2.less_equal(t1))) {
-			other.desc.since()
-		}
-		else {
-			self.desc.since()
-		};
-		
-		Rc::new(HashKeyBatch {
-			layer: <HashedLayer<K, OrderedLeaf<T, R>> as Trie>::merge(&self.layer, &other.layer),
-			desc: Description::new(self.desc.lower(), other.desc.upper(), since),
-		})
-	}
+    type Batcher = RadixBatcher<K, (), T, R, Self>;
+    type Builder = HashKeyBuilder<K, T, R>;
+    fn merge(&self, other: &Self) -> Self {
+
+        // Things are horribly wrong if this is not true.
+        assert!(self.desc.upper() == other.desc.lower());
+
+        // one of self.desc.since or other.desc.since needs to be not behind the other...
+        let since = if self.desc.since().iter().all(|t1| other.desc.since().iter().any(|t2| t2.less_equal(t1))) {
+            other.desc.since()
+        }
+        else {
+            self.desc.since()
+        };
+        
+        Rc::new(HashKeyBatch {
+            layer: <HashedLayer<K, OrderedLeaf<T, R>> as Trie>::merge(&self.layer, &other.layer),
+            desc: Description::new(self.desc.lower(), other.desc.upper(), since),
+        })
+    }
 }
 
 /// A cursor for navigating a single layer.
 #[derive(Debug)]
 pub struct HashKeyCursor<T: Lattice+Ord+Clone, R: Diff> {
-	valid: bool,
-	empty: (),
-	cursor: HashedCursor<OrderedLeaf<T, R>>,
+    valid: bool,
+    empty: (),
+    cursor: HashedCursor<OrderedLeaf<T, R>>,
 }
 
 impl<K: Clone+HashOrdered, T: Lattice+Ord+Clone, R: Diff> Cursor<K, (), T, R> for HashKeyCursor<T, R> {
 
-	type Storage = Rc<HashKeyBatch<K, T, R>>;
-
-	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 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) {
-			logic(&self.cursor.child.key(&storage.layer.vals).0, self.cursor.child.key(&storage.layer.vals).1);
-			self.cursor.child.step(&storage.layer.vals);
-		}
-	}
-	fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.valid(&storage.layer) }
-	fn val_valid(&self, _storage: &Self::Storage) -> bool { self.valid }
-	fn step_key(&mut self, storage: &Self::Storage){ self.cursor.step(&storage.layer); self.valid = true; }
-	fn seek_key(&mut self, storage: &Self::Storage, key: &K) { self.cursor.seek(&storage.layer, key); self.valid = true; }
-	fn step_val(&mut self, _storage: &Self::Storage) { self.valid = false; }
-	fn seek_val(&mut self, _storage: &Self::Storage, _val: &()) { }
-	fn rewind_keys(&mut self, storage: &Self::Storage) { self.cursor.rewind(&storage.layer); self.valid = true; }
-	fn rewind_vals(&mut self, _storage: &Self::Storage) { self.valid = true; }
+    type Storage = Rc<HashKeyBatch<K, T, R>>;
+
+    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 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) {
+            logic(&self.cursor.child.key(&storage.layer.vals).0, self.cursor.child.key(&storage.layer.vals).1);
+            self.cursor.child.step(&storage.layer.vals);
+        }
+    }
+    fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.valid(&storage.layer) }
+    fn val_valid(&self, _storage: &Self::Storage) -> bool { self.valid }
+    fn step_key(&mut self, storage: &Self::Storage){ self.cursor.step(&storage.layer); self.valid = true; }
+    fn seek_key(&mut self, storage: &Self::Storage, key: &K) { self.cursor.seek(&storage.layer, key); self.valid = true; }
+    fn step_val(&mut self, _storage: &Self::Storage) { self.valid = false; }
+    fn seek_val(&mut self, _storage: &Self::Storage, _val: &()) { }
+    fn rewind_keys(&mut self, storage: &Self::Storage) { self.cursor.rewind(&storage.layer); self.valid = true; }
+    fn rewind_vals(&mut self, _storage: &Self::Storage) { self.valid = true; }
 }
 
 /// A builder for creating layers from unsorted update tuples.
 pub struct HashKeyBuilder<K: HashOrdered, T: Ord+Lattice, R: Diff> {
-	builder: HashedBuilder<K, OrderedLeafBuilder<T, R>>,
+    builder: HashedBuilder<K, OrderedLeafBuilder<T, R>>,
 }
 
 impl<K, T, R> Builder<K, (), T, R, Rc<HashKeyBatch<K, T, R>>> for HashKeyBuilder<K, T, R> 
 where K: Clone+Default+HashOrdered+'static, T: Lattice+Ord+Clone+Default+'static, R: Diff {
 
-	fn new() -> Self { 
-		HashKeyBuilder { 
-			builder: HashedBuilder::<K, OrderedLeafBuilder<T, R>>::new() 
-		} 
-	}
-	fn with_capacity(cap: usize) -> Self { 
-		HashKeyBuilder { 
-			builder: HashedBuilder::<K, OrderedLeafBuilder<T, R>>::with_capacity(cap) 
-		} 
-	}
-
-	#[inline]
-	fn push(&mut self, (key, _, time, diff): (K, (), T, R)) {
-		self.builder.push_tuple((key, (time, diff)));
-	}
-
-	#[inline(never)]
-	fn done(self, lower: &[T], upper: &[T], since: &[T]) -> Rc<HashKeyBatch<K, T, R>> {
-		Rc::new(HashKeyBatch {
-			layer: self.builder.done(),
-			desc: Description::new(lower, upper, since)
-		})
-	}
+    fn new() -> Self { 
+        HashKeyBuilder { 
+            builder: HashedBuilder::<K, OrderedLeafBuilder<T, R>>::new() 
+        } 
+    }
+    fn with_capacity(cap: usize) -> Self { 
+        HashKeyBuilder { 
+            builder: HashedBuilder::<K, OrderedLeafBuilder<T, R>>::with_capacity(cap) 
+        } 
+    }
+
+    #[inline]
+    fn push(&mut self, (key, _, time, diff): (K, (), T, R)) {
+        self.builder.push_tuple((key, (time, diff)));
+    }
+
+    #[inline(never)]
+    fn done(self, lower: &[T], upper: &[T], since: &[T]) -> Rc<HashKeyBatch<K, T, R>> {
+        Rc::new(HashKeyBatch {
+            layer: self.builder.done(),
+            desc: Description::new(lower, upper, since)
+        })
+    }
 }
 
diff --git a/src/trace/implementations/merge_batcher.rs b/src/trace/implementations/merge_batcher.rs
index 49aefd30a..83e7d4d88 100644
--- a/src/trace/implementations/merge_batcher.rs
+++ b/src/trace/implementations/merge_batcher.rs
@@ -334,28 +334,28 @@ impl<D: Ord, T: Ord, R: Semigroup> MergeSorter<D, T, R> {
 #[inline]
 pub fn _advance<T, F: Fn(&T)->bool>(slice: &[T], function: F) -> usize {
 
-	// start with no advance
-	let mut index = 0;
-	if index < slice.len() && function(&slice[index]) {
-
-		// advance in exponentially growing steps.
-		let mut step = 1;
-		while index + step < slice.len() && function(&slice[index + step]) {
-			index += step;
-			step = step << 1;
-		}
-
-		// advance in exponentially shrinking steps.
-		step = step >> 1;
-		while step > 0 {
-			if index + step < slice.len() && function(&slice[index + step]) {
-				index += step;
-			}
-			step = step >> 1;
-		}
-
-		index += 1;
-	}
-
-	index
+    // start with no advance
+    let mut index = 0;
+    if index < slice.len() && function(&slice[index]) {
+
+        // advance in exponentially growing steps.
+        let mut step = 1;
+        while index + step < slice.len() && function(&slice[index + step]) {
+            index += step;
+            step = step << 1;
+        }
+
+        // advance in exponentially shrinking steps.
+        step = step >> 1;
+        while step > 0 {
+            if index + step < slice.len() && function(&slice[index + step]) {
+                index += step;
+            }
+            step = step >> 1;
+        }
+
+        index += 1;
+    }
+
+    index
 }
diff --git a/src/trace/implementations/ord.rs b/src/trace/implementations/ord.rs
index c0d6542e1..f394d2365 100644
--- a/src/trace/implementations/ord.rs
+++ b/src/trace/implementations/ord.rs
@@ -56,10 +56,10 @@ where
     T: Lattice,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	/// Where all the dataz is.
-	pub layer: OrderedLayer<K, OrderedLayer<V, OrderedLeaf<T, R>, O>, O>,
-	/// Description of the update times this layer represents.
-	pub desc: Description<T>,
+    /// Where all the dataz is.
+    pub layer: OrderedLayer<K, OrderedLayer<V, OrderedLeaf<T, R>, O>, O>,
+    /// Description of the update times this layer represents.
+    pub desc: Description<T>,
 }
 
 impl<K, V, T, R, O> BatchReader<K, V, T, R> for OrdValBatch<K, V, T, R, O>
@@ -70,10 +70,10 @@ 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() } }
-	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 }
+    type Cursor = OrdValCursor<V, T, R, O>;
+    fn cursor(&self) -> Self::Cursor { OrdValCursor { cursor: self.layer.cursor() } }
+    fn len(&self) -> usize { <OrderedLayer<K, OrderedLayer<V, OrderedLeaf<T, R>, O>, O> as Trie>::tuples(&self.layer) }
+    fn description(&self) -> &Description<T> { &self.desc }
 }
 
 impl<K, V, T, R, O> Batch<K, V, T, R> for OrdValBatch<K, V, T, R, O>
@@ -84,13 +84,13 @@ 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 Builder = OrdValBuilder<K, V, T, R, O>;
-	type Merger = OrdValMerger<K, V, T, R, O>;
+    type Batcher = MergeBatcher<K, V, T, R, Self>;
+    type Builder = OrdValBuilder<K, V, T, R, O>;
+    type Merger = OrdValMerger<K, V, T, R, O>;
 
-	fn begin_merge(&self, other: &Self, compaction_frontier: Option<AntichainRef<T>>) -> Self::Merger {
-		OrdValMerger::new(self, other, compaction_frontier)
-	}
+    fn begin_merge(&self, other: &Self, compaction_frontier: Option<AntichainRef<T>>) -> Self::Merger {
+        OrdValMerger::new(self, other, compaction_frontier)
+    }
 }
 
 impl<K, V, T, R, O> OrdValBatch<K, V, T, R, O>
@@ -101,97 +101,97 @@ where
     R: Semigroup,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	fn advance_builder_from(layer: &mut OrderedBuilder<K, OrderedBuilder<V, OrderedLeafBuilder<T, R>, O>, O>, frontier: AntichainRef<T>, key_pos: usize) {
-
-		let key_start = key_pos;
-		let val_start: usize = layer.offs[key_pos].try_into().unwrap();
-		let time_start: usize = layer.vals.offs[val_start].try_into().unwrap();
-
-		// We have unique ownership of the batch, and can advance times in place.
-		// We must still sort, collapse, and remove empty updates.
-
-		// We will zip throught the time leaves, calling advance on each,
-		//    then zip through the value layer, sorting and collapsing each,
-		//    then zip through the key layer, collapsing each .. ?
-
-		// 1. For each (time, diff) pair, advance the time.
-		for i in time_start .. layer.vals.vals.vals.len() {
-			layer.vals.vals.vals[i].0.advance_by(frontier);
-		}
-
-		// 2. For each `(val, off)` pair, sort the range, compact, and rewrite `off`.
-		//    This may leave `val` with an empty range; filtering happens in step 3.
-		let mut write_position = time_start;
-		for i in val_start .. layer.vals.keys.len() {
-
-			// NB: batch.layer.vals.offs[i+1] will be used next iteration, and should not be changed.
-			//     we will change batch.layer.vals.offs[i] in this iteration, from `write_position`'s
-			//     initial value.
-
-			let lower: usize = layer.vals.offs[i].try_into().unwrap();
-			let upper: usize = layer.vals.offs[i+1].try_into().unwrap();
-
-			layer.vals.offs[i] = O::try_from(write_position).unwrap();
-
-			let updates = &mut layer.vals.vals.vals[..];
-
-			// sort the range by the times (ignore the diffs; they will collapse).
-			let count = crate::consolidation::consolidate_slice(&mut updates[lower .. upper]);
-
-			for index in lower .. (lower + count) {
-				updates.swap(write_position, index);
-				write_position += 1;
-			}
-		}
-		layer.vals.vals.vals.truncate(write_position);
-		layer.vals.offs[layer.vals.keys.len()] = O::try_from(write_position).unwrap();
-
-		// 3. For each `(key, off)` pair, (values already sorted), filter vals, and rewrite `off`.
-		//    This may leave `key` with an empty range. Filtering happens in step 4.
-		let mut write_position = val_start;
-		for i in key_start .. layer.keys.len() {
-
-			// NB: batch.layer.offs[i+1] must remain as is for the next iteration.
-			//     instead, we update batch.layer.offs[i]
-
-			let lower: usize = layer.offs[i].try_into().unwrap();
-			let upper: usize = layer.offs[i+1].try_into().unwrap();
-
-			layer.offs[i] = O::try_from(write_position).unwrap();
-
-			// values should already be sorted, but some might now be empty.
-			for index in lower .. upper {
-				let val_lower: usize = layer.vals.offs[index].try_into().unwrap();
-				let val_upper: usize = layer.vals.offs[index+1].try_into().unwrap();
-				if val_lower < val_upper {
-					layer.vals.keys.swap(write_position, index);
-					layer.vals.offs[write_position+1] = layer.vals.offs[index+1];
-					write_position += 1;
-				}
-			}
-			// batch.layer.offs[i+1] = write_position;
-		}
-		layer.vals.keys.truncate(write_position);
-		layer.vals.offs.truncate(write_position + 1);
-		layer.offs[layer.keys.len()] = O::try_from(write_position).unwrap();
-
-		// 4. Remove empty keys.
-		let mut write_position = key_start;
-		for i in key_start .. layer.keys.len() {
-
-			let lower: usize = layer.offs[i].try_into().unwrap();
-			let upper: usize = layer.offs[i+1].try_into().unwrap();
-
-			if lower < upper {
-				layer.keys.swap(write_position, i);
-				// batch.layer.offs updated via `dedup` below; keeps me sane.
-				write_position += 1;
-			}
-		}
-		layer.offs.dedup();
-		layer.keys.truncate(write_position);
-		layer.offs.truncate(write_position+1);
-	}
+    fn advance_builder_from(layer: &mut OrderedBuilder<K, OrderedBuilder<V, OrderedLeafBuilder<T, R>, O>, O>, frontier: AntichainRef<T>, key_pos: usize) {
+
+        let key_start = key_pos;
+        let val_start: usize = layer.offs[key_pos].try_into().unwrap();
+        let time_start: usize = layer.vals.offs[val_start].try_into().unwrap();
+
+        // We have unique ownership of the batch, and can advance times in place.
+        // We must still sort, collapse, and remove empty updates.
+
+        // We will zip throught the time leaves, calling advance on each,
+        //    then zip through the value layer, sorting and collapsing each,
+        //    then zip through the key layer, collapsing each .. ?
+
+        // 1. For each (time, diff) pair, advance the time.
+        for i in time_start .. layer.vals.vals.vals.len() {
+            layer.vals.vals.vals[i].0.advance_by(frontier);
+        }
+
+        // 2. For each `(val, off)` pair, sort the range, compact, and rewrite `off`.
+        //    This may leave `val` with an empty range; filtering happens in step 3.
+        let mut write_position = time_start;
+        for i in val_start .. layer.vals.keys.len() {
+
+            // NB: batch.layer.vals.offs[i+1] will be used next iteration, and should not be changed.
+            //     we will change batch.layer.vals.offs[i] in this iteration, from `write_position`'s
+            //     initial value.
+
+            let lower: usize = layer.vals.offs[i].try_into().unwrap();
+            let upper: usize = layer.vals.offs[i+1].try_into().unwrap();
+
+            layer.vals.offs[i] = O::try_from(write_position).unwrap();
+
+            let updates = &mut layer.vals.vals.vals[..];
+
+            // sort the range by the times (ignore the diffs; they will collapse).
+            let count = crate::consolidation::consolidate_slice(&mut updates[lower .. upper]);
+
+            for index in lower .. (lower + count) {
+                updates.swap(write_position, index);
+                write_position += 1;
+            }
+        }
+        layer.vals.vals.vals.truncate(write_position);
+        layer.vals.offs[layer.vals.keys.len()] = O::try_from(write_position).unwrap();
+
+        // 3. For each `(key, off)` pair, (values already sorted), filter vals, and rewrite `off`.
+        //    This may leave `key` with an empty range. Filtering happens in step 4.
+        let mut write_position = val_start;
+        for i in key_start .. layer.keys.len() {
+
+            // NB: batch.layer.offs[i+1] must remain as is for the next iteration.
+            //     instead, we update batch.layer.offs[i]
+
+            let lower: usize = layer.offs[i].try_into().unwrap();
+            let upper: usize = layer.offs[i+1].try_into().unwrap();
+
+            layer.offs[i] = O::try_from(write_position).unwrap();
+
+            // values should already be sorted, but some might now be empty.
+            for index in lower .. upper {
+                let val_lower: usize = layer.vals.offs[index].try_into().unwrap();
+                let val_upper: usize = layer.vals.offs[index+1].try_into().unwrap();
+                if val_lower < val_upper {
+                    layer.vals.keys.swap(write_position, index);
+                    layer.vals.offs[write_position+1] = layer.vals.offs[index+1];
+                    write_position += 1;
+                }
+            }
+            // batch.layer.offs[i+1] = write_position;
+        }
+        layer.vals.keys.truncate(write_position);
+        layer.vals.offs.truncate(write_position + 1);
+        layer.offs[layer.keys.len()] = O::try_from(write_position).unwrap();
+
+        // 4. Remove empty keys.
+        let mut write_position = key_start;
+        for i in key_start .. layer.keys.len() {
+
+            let lower: usize = layer.offs[i].try_into().unwrap();
+            let upper: usize = layer.offs[i+1].try_into().unwrap();
+
+            if lower < upper {
+                layer.keys.swap(write_position, i);
+                // batch.layer.offs updated via `dedup` below; keeps me sane.
+                write_position += 1;
+            }
+        }
+        layer.offs.dedup();
+        layer.keys.truncate(write_position);
+        layer.offs.truncate(write_position+1);
+    }
 }
 
 /// State for an in-progress merge.
@@ -203,16 +203,16 @@ where
     R: Semigroup,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	// first batch, and position therein.
-	lower1: usize,
-	upper1: usize,
-	// second batch, and position therein.
-	lower2: usize,
-	upper2: usize,
-	// result that we are currently assembling.
-	result: <OrderedLayer<K, OrderedLayer<V, OrderedLeaf<T, R>, O>, O> as Trie>::MergeBuilder,
-	description: Description<T>,
-	should_compact: bool,
+    // first batch, and position therein.
+    lower1: usize,
+    upper1: usize,
+    // second batch, and position therein.
+    lower2: usize,
+    upper2: usize,
+    // result that we are currently assembling.
+    result: <OrderedLayer<K, OrderedLayer<V, OrderedLeaf<T, R>, O>, O> as Trie>::MergeBuilder,
+    description: Description<T>,
+    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>
@@ -223,52 +223,52 @@ where
     R: Semigroup,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	fn new(batch1: &OrdValBatch<K, V, T, R, O>, batch2: &OrdValBatch<K, V, T, R, O>, compaction_frontier: Option<AntichainRef<T>>) -> Self {
-
-		assert!(batch1.upper() == batch2.lower());
-
-		let mut since = batch1.description().since().join(batch2.description().since());
-		if let Some(compaction_frontier) = compaction_frontier {
-			since = since.join(&compaction_frontier.to_owned());
-		}
-
-		let description = Description::new(batch1.lower().clone(), batch2.upper().clone(), since);
-
-		OrdValMerger {
-			lower1: 0,
-			upper1: batch1.layer.keys(),
-			lower2: 0,
-			upper2: batch2.layer.keys(),
-			result: <<OrderedLayer<K, OrderedLayer<V, OrderedLeaf<T, R>, O>, O> as Trie>::MergeBuilder as MergeBuilder>::with_capacity(&batch1.layer, &batch2.layer),
-			description: description,
-			should_compact: compaction_frontier.is_some(),
-		}
-	}
-	fn done(self) -> OrdValBatch<K, V, T, R, O> {
-
-		assert!(self.lower1 == self.upper1);
-		assert!(self.lower2 == self.upper2);
-
-		OrdValBatch {
-			layer: self.result.done(),
-			desc: self.description,
-		}
-	}
-	fn work(&mut self, source1: &OrdValBatch<K,V,T,R,O>, source2: &OrdValBatch<K,V,T,R,O>, fuel: &mut isize) {
-
-		let starting_updates = self.result.vals.vals.vals.len();
-		let mut effort = 0isize;
-
-		let initial_key_pos = self.result.keys.len();
-
-		// while both mergees are still active
-		while self.lower1 < self.upper1 && self.lower2 < self.upper2 && effort < *fuel {
-			self.result.merge_step((&source1.layer, &mut self.lower1, self.upper1), (&source2.layer, &mut self.lower2, self.upper2));
-			effort = (self.result.vals.vals.vals.len() - starting_updates) as isize;
-		}
+    fn new(batch1: &OrdValBatch<K, V, T, R, O>, batch2: &OrdValBatch<K, V, T, R, O>, compaction_frontier: Option<AntichainRef<T>>) -> Self {
+
+        assert!(batch1.upper() == batch2.lower());
+
+        let mut since = batch1.description().since().join(batch2.description().since());
+        if let Some(compaction_frontier) = compaction_frontier {
+            since = since.join(&compaction_frontier.to_owned());
+        }
+
+        let description = Description::new(batch1.lower().clone(), batch2.upper().clone(), since);
+
+        OrdValMerger {
+            lower1: 0,
+            upper1: batch1.layer.keys(),
+            lower2: 0,
+            upper2: batch2.layer.keys(),
+            result: <<OrderedLayer<K, OrderedLayer<V, OrderedLeaf<T, R>, O>, O> as Trie>::MergeBuilder as MergeBuilder>::with_capacity(&batch1.layer, &batch2.layer),
+            description: description,
+            should_compact: compaction_frontier.is_some(),
+        }
+    }
+    fn done(self) -> OrdValBatch<K, V, T, R, O> {
+
+        assert!(self.lower1 == self.upper1);
+        assert!(self.lower2 == self.upper2);
+
+        OrdValBatch {
+            layer: self.result.done(),
+            desc: self.description,
+        }
+    }
+    fn work(&mut self, source1: &OrdValBatch<K,V,T,R,O>, source2: &OrdValBatch<K,V,T,R,O>, fuel: &mut isize) {
+
+        let starting_updates = self.result.vals.vals.vals.len();
+        let mut effort = 0isize;
+
+        let initial_key_pos = self.result.keys.len();
+
+        // while both mergees are still active
+        while self.lower1 < self.upper1 && self.lower2 < self.upper2 && effort < *fuel {
+            self.result.merge_step((&source1.layer, &mut self.lower1, self.upper1), (&source2.layer, &mut self.lower2, self.upper2));
+            effort = (self.result.vals.vals.vals.len() - starting_updates) as isize;
+        }
 
         // Merging is complete; only copying remains. Copying is probably faster than merging, so could take some liberties here.
-		if self.lower1 == self.upper1 || self.lower2 == self.upper2 {
+        if self.lower1 == self.upper1 || self.lower2 == self.upper2 {
             // Limit merging by remaining fuel.
             let remaining_fuel = *fuel - effort;
             if remaining_fuel > 0 {
@@ -287,21 +287,21 @@ where
                     self.lower2 += to_copy;
                 }
             }
-		}
+        }
 
-		effort = (self.result.vals.vals.vals.len() - starting_updates) as isize;
+        effort = (self.result.vals.vals.vals.len() - starting_updates) as isize;
 
-		// if we are supplied a frontier, we should compact.
-		if self.should_compact {
-			OrdValBatch::advance_builder_from(&mut self.result, self.description.since().borrow(), initial_key_pos);
-		}
+        // if we are supplied a frontier, we should compact.
+        if self.should_compact {
+            OrdValBatch::advance_builder_from(&mut self.result, self.description.since().borrow(), initial_key_pos);
+        }
 
         *fuel -= effort;
 
         // if *fuel < -1_000_000 {
         //     eprintln!("Massive deficit OrdVal::work: {}", fuel);
         // }
-	}
+    }
 }
 
 /// A cursor for navigating a single layer.
@@ -313,7 +313,7 @@ where
     R: Semigroup,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	cursor: OrderedCursor<OrderedLayer<V, OrderedLeaf<T, R>, O>>,
+    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>
@@ -324,25 +324,25 @@ where
     R: Semigroup,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	type Storage = OrdValBatch<K, V, 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 V { &self.cursor.child.key(&storage.layer.vals) }
-	fn map_times<L: FnMut(&T, &R)>(&mut self, storage: &Self::Storage, mut logic: L) {
-		self.cursor.child.child.rewind(&storage.layer.vals.vals);
-		while self.cursor.child.child.valid(&storage.layer.vals.vals) {
-			logic(&self.cursor.child.child.key(&storage.layer.vals.vals).0, &self.cursor.child.child.key(&storage.layer.vals.vals).1);
-			self.cursor.child.child.step(&storage.layer.vals.vals);
-		}
-	}
-	fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.valid(&storage.layer) }
-	fn val_valid(&self, storage: &Self::Storage) -> bool { self.cursor.child.valid(&storage.layer.vals) }
-	fn step_key(&mut self, storage: &Self::Storage){ self.cursor.step(&storage.layer); }
-	fn seek_key(&mut self, storage: &Self::Storage, key: &K) { self.cursor.seek(&storage.layer, key); }
-	fn step_val(&mut self, storage: &Self::Storage) { self.cursor.child.step(&storage.layer.vals); }
-	fn seek_val(&mut self, storage: &Self::Storage, val: &V) { self.cursor.child.seek(&storage.layer.vals, val); }
-	fn rewind_keys(&mut self, storage: &Self::Storage) { self.cursor.rewind(&storage.layer); }
-	fn rewind_vals(&mut self, storage: &Self::Storage) { self.cursor.child.rewind(&storage.layer.vals); }
+    type Storage = OrdValBatch<K, V, 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 V { &self.cursor.child.key(&storage.layer.vals) }
+    fn map_times<L: FnMut(&T, &R)>(&mut self, storage: &Self::Storage, mut logic: L) {
+        self.cursor.child.child.rewind(&storage.layer.vals.vals);
+        while self.cursor.child.child.valid(&storage.layer.vals.vals) {
+            logic(&self.cursor.child.child.key(&storage.layer.vals.vals).0, &self.cursor.child.child.key(&storage.layer.vals.vals).1);
+            self.cursor.child.child.step(&storage.layer.vals.vals);
+        }
+    }
+    fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.valid(&storage.layer) }
+    fn val_valid(&self, storage: &Self::Storage) -> bool { self.cursor.child.valid(&storage.layer.vals) }
+    fn step_key(&mut self, storage: &Self::Storage){ self.cursor.step(&storage.layer); }
+    fn seek_key(&mut self, storage: &Self::Storage, key: &K) { self.cursor.seek(&storage.layer, key); }
+    fn step_val(&mut self, storage: &Self::Storage) { self.cursor.child.step(&storage.layer.vals); }
+    fn seek_val(&mut self, storage: &Self::Storage, val: &V) { self.cursor.child.seek(&storage.layer.vals, val); }
+    fn rewind_keys(&mut self, storage: &Self::Storage) { self.cursor.rewind(&storage.layer); }
+    fn rewind_vals(&mut self, storage: &Self::Storage) { self.cursor.child.rewind(&storage.layer.vals); }
 }
 
 
@@ -355,7 +355,7 @@ where
     R: Semigroup,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	builder: OrderedBuilder<K, OrderedBuilder<V, OrderedLeafBuilder<T, R>, O>, O>,
+    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>
@@ -367,29 +367,29 @@ where
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
 
-	fn new() -> Self {
-		OrdValBuilder {
-			builder: OrderedBuilder::<K, OrderedBuilder<V, OrderedLeafBuilder<T, R>, O>, O>::new()
-		}
-	}
-	fn with_capacity(cap: usize) -> Self {
-		OrdValBuilder {
-			builder: <OrderedBuilder<K, OrderedBuilder<V, OrderedLeafBuilder<T, R>, O>, O> as TupleBuilder>::with_capacity(cap)
-		}
-	}
-
-	#[inline]
-	fn push(&mut self, (key, val, time, diff): (K, V, T, R)) {
-		self.builder.push_tuple((key, (val, (time, diff))));
-	}
-
-	#[inline(never)]
-	fn done(self, lower: Antichain<T>, upper: Antichain<T>, since: Antichain<T>) -> OrdValBatch<K, V, T, R, O> {
-		OrdValBatch {
-			layer: self.builder.done(),
-			desc: Description::new(lower, upper, since)
-		}
-	}
+    fn new() -> Self {
+        OrdValBuilder {
+            builder: OrderedBuilder::<K, OrderedBuilder<V, OrderedLeafBuilder<T, R>, O>, O>::new()
+        }
+    }
+    fn with_capacity(cap: usize) -> Self {
+        OrdValBuilder {
+            builder: <OrderedBuilder<K, OrderedBuilder<V, OrderedLeafBuilder<T, R>, O>, O> as TupleBuilder>::with_capacity(cap)
+        }
+    }
+
+    #[inline]
+    fn push(&mut self, (key, val, time, diff): (K, V, T, R)) {
+        self.builder.push_tuple((key, (val, (time, diff))));
+    }
+
+    #[inline(never)]
+    fn done(self, lower: Antichain<T>, upper: Antichain<T>, since: Antichain<T>) -> OrdValBatch<K, V, T, R, O> {
+        OrdValBatch {
+            layer: self.builder.done(),
+            desc: Description::new(lower, upper, since)
+        }
+    }
 }
 
 
@@ -403,10 +403,10 @@ where
     T: Lattice,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	/// Where all the dataz is.
-	pub layer: OrderedLayer<K, OrderedLeaf<T, R>, O>,
-	/// Description of the update times this layer represents.
-	pub desc: Description<T>,
+    /// Where all the dataz is.
+    pub layer: OrderedLayer<K, OrderedLeaf<T, R>, O>,
+    /// Description of the update times this layer represents.
+    pub desc: Description<T>,
 }
 
 impl<K, T, R, O> BatchReader<K, (), T, R> for OrdKeyBatch<K, T, R, O>
@@ -416,17 +416,17 @@ where
     R: Semigroup,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	type Cursor = OrdKeyCursor<T, R, O>;
-	fn cursor(&self) -> Self::Cursor {
-		OrdKeyCursor {
-			empty: (),
-			valid: true,
-			cursor: self.layer.cursor(),
+    type Cursor = OrdKeyCursor<T, R, O>;
+    fn cursor(&self) -> Self::Cursor {
+        OrdKeyCursor {
+            empty: (),
+            valid: true,
+            cursor: self.layer.cursor(),
             phantom: PhantomData
-		}
-	}
-	fn len(&self) -> usize { <OrderedLayer<K, OrderedLeaf<T, R>, O> as Trie>::tuples(&self.layer) }
-	fn description(&self) -> &Description<T> { &self.desc }
+        }
+    }
+    fn len(&self) -> usize { <OrderedLayer<K, OrderedLeaf<T, R>, O> as Trie>::tuples(&self.layer) }
+    fn description(&self) -> &Description<T> { &self.desc }
 }
 
 impl<K, T, R, O> Batch<K, (), T, R> for OrdKeyBatch<K, T, R, O>
@@ -436,13 +436,13 @@ where
     R: Semigroup,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	type Batcher = MergeBatcher<K, (), T, R, Self>;
-	type Builder = OrdKeyBuilder<K, T, R, O>;
-	type Merger = OrdKeyMerger<K, T, R, O>;
+    type Batcher = MergeBatcher<K, (), T, R, Self>;
+    type Builder = OrdKeyBuilder<K, T, R, O>;
+    type Merger = OrdKeyMerger<K, T, R, O>;
 
-	fn begin_merge(&self, other: &Self, compaction_frontier: Option<AntichainRef<T>>) -> Self::Merger {
-		OrdKeyMerger::new(self, other, compaction_frontier)
-	}
+    fn begin_merge(&self, other: &Self, compaction_frontier: Option<AntichainRef<T>>) -> Self::Merger {
+        OrdKeyMerger::new(self, other, compaction_frontier)
+    }
 }
 
 impl<K, T, R, O> OrdKeyBatch<K, T, R, O>
@@ -452,67 +452,67 @@ where
     R: Semigroup,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	fn advance_builder_from(layer: &mut OrderedBuilder<K, OrderedLeafBuilder<T, R>, O>, frontier: AntichainRef<T>, key_pos: usize) {
-
-		let key_start = key_pos;
-		let time_start: usize = layer.offs[key_pos].try_into().unwrap();
-
-		// We will zip through the time leaves, calling advance on each,
-		//    then zip through the value layer, sorting and collapsing each,
-		//    then zip through the key layer, collapsing each .. ?
-
-		// 1. For each (time, diff) pair, advance the time.
-		for i in time_start .. layer.vals.vals.len() {
-			layer.vals.vals[i].0.advance_by(frontier);
-		}
-		// for time_diff in self.layer.vals.vals.iter_mut() {
-		// 	time_diff.0 = time_diff.0.advance_by(frontier);
-		// }
-
-		// 2. For each `(val, off)` pair, sort the range, compact, and rewrite `off`.
-		//    This may leave `val` with an empty range; filtering happens in step 3.
-		let mut write_position = time_start;
-		for i in key_start .. layer.keys.len() {
-
-			// NB: batch.layer.vals.offs[i+1] will be used next iteration, and should not be changed.
-			//     we will change batch.layer.vals.offs[i] in this iteration, from `write_position`'s
-			//     initial value.
-
-			let lower: usize = layer.offs[i].try_into().unwrap();
-			let upper: usize = layer.offs[i+1].try_into().unwrap();
-
-			layer.offs[i] = O::try_from(write_position).unwrap();
-
-			let updates = &mut layer.vals.vals[..];
-
-			// sort the range by the times (ignore the diffs; they will collapse).
-		 	let count = crate::consolidation::consolidate_slice(&mut updates[lower .. upper]);
-
-			for index in lower .. (lower + count) {
-				updates.swap(write_position, index);
-				write_position += 1;
-			}
-		}
-		layer.vals.vals.truncate(write_position);
-		layer.offs[layer.keys.len()] = O::try_from(write_position).unwrap();
-
-		// 4. Remove empty keys.
-		let mut write_position = key_start;
-		for i in key_start .. layer.keys.len() {
-
-			let lower: usize = layer.offs[i].try_into().unwrap();
-			let upper: usize = layer.offs[i+1].try_into().unwrap();
-
-			if lower < upper {
-				layer.keys.swap(write_position, i);
-				// batch.layer.offs updated via `dedup` below; keeps me sane.
-				write_position += 1;
-			}
-		}
-		layer.offs.dedup();
-		layer.keys.truncate(write_position);
-		layer.offs.truncate(write_position+1);
-	}
+    fn advance_builder_from(layer: &mut OrderedBuilder<K, OrderedLeafBuilder<T, R>, O>, frontier: AntichainRef<T>, key_pos: usize) {
+
+        let key_start = key_pos;
+        let time_start: usize = layer.offs[key_pos].try_into().unwrap();
+
+        // We will zip through the time leaves, calling advance on each,
+        //    then zip through the value layer, sorting and collapsing each,
+        //    then zip through the key layer, collapsing each .. ?
+
+        // 1. For each (time, diff) pair, advance the time.
+        for i in time_start .. layer.vals.vals.len() {
+            layer.vals.vals[i].0.advance_by(frontier);
+        }
+        // for time_diff in self.layer.vals.vals.iter_mut() {
+        //     time_diff.0 = time_diff.0.advance_by(frontier);
+        // }
+
+        // 2. For each `(val, off)` pair, sort the range, compact, and rewrite `off`.
+        //    This may leave `val` with an empty range; filtering happens in step 3.
+        let mut write_position = time_start;
+        for i in key_start .. layer.keys.len() {
+
+            // NB: batch.layer.vals.offs[i+1] will be used next iteration, and should not be changed.
+            //     we will change batch.layer.vals.offs[i] in this iteration, from `write_position`'s
+            //     initial value.
+
+            let lower: usize = layer.offs[i].try_into().unwrap();
+            let upper: usize = layer.offs[i+1].try_into().unwrap();
+
+            layer.offs[i] = O::try_from(write_position).unwrap();
+
+            let updates = &mut layer.vals.vals[..];
+
+            // sort the range by the times (ignore the diffs; they will collapse).
+             let count = crate::consolidation::consolidate_slice(&mut updates[lower .. upper]);
+
+            for index in lower .. (lower + count) {
+                updates.swap(write_position, index);
+                write_position += 1;
+            }
+        }
+        layer.vals.vals.truncate(write_position);
+        layer.offs[layer.keys.len()] = O::try_from(write_position).unwrap();
+
+        // 4. Remove empty keys.
+        let mut write_position = key_start;
+        for i in key_start .. layer.keys.len() {
+
+            let lower: usize = layer.offs[i].try_into().unwrap();
+            let upper: usize = layer.offs[i+1].try_into().unwrap();
+
+            if lower < upper {
+                layer.keys.swap(write_position, i);
+                // batch.layer.offs updated via `dedup` below; keeps me sane.
+                write_position += 1;
+            }
+        }
+        layer.offs.dedup();
+        layer.keys.truncate(write_position);
+        layer.offs.truncate(write_position+1);
+    }
 }
 
 /// State for an in-progress merge.
@@ -523,16 +523,16 @@ where
     R: Semigroup,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	// first batch, and position therein.
-	lower1: usize,
-	upper1: usize,
-	// second batch, and position therein.
-	lower2: usize,
-	upper2: usize,
-	// result that we are currently assembling.
-	result: <OrderedLayer<K, OrderedLeaf<T, R>, O> as Trie>::MergeBuilder,
-	description: Description<T>,
-	should_compact: bool,
+    // first batch, and position therein.
+    lower1: usize,
+    upper1: usize,
+    // second batch, and position therein.
+    lower2: usize,
+    upper2: usize,
+    // result that we are currently assembling.
+    result: <OrderedLayer<K, OrderedLeaf<T, R>, O> as Trie>::MergeBuilder,
+    description: Description<T>,
+    should_compact: bool,
 }
 
 impl<K, T, R, O> Merger<K, (), T, R, OrdKeyBatch<K, T, R, O>> for OrdKeyMerger<K, T, R, O>
@@ -542,57 +542,57 @@ where
     R: Semigroup,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	fn new(batch1: &OrdKeyBatch<K, T, R, O>, batch2: &OrdKeyBatch<K, T, R, O>, compaction_frontier: Option<AntichainRef<T>>) -> Self {
-
-		assert!(batch1.upper() == batch2.lower());
-
-		let mut since = batch1.description().since().join(batch2.description().since());
-		if let Some(compaction_frontier) = compaction_frontier {
-			since = since.join(&compaction_frontier.to_owned());
-		}
-
-		let description = Description::new(batch1.lower().clone(), batch2.upper().clone(), since);
-
-		OrdKeyMerger {
-			lower1: 0,
-			upper1: batch1.layer.keys(),
-			lower2: 0,
-			upper2: batch2.layer.keys(),
-			result: <<OrderedLayer<K, OrderedLeaf<T, R>, O> as Trie>::MergeBuilder as MergeBuilder>::with_capacity(&batch1.layer, &batch2.layer),
-			description: description,
-			should_compact: compaction_frontier.is_some(),
-		}
-	}
-	fn done(self) -> OrdKeyBatch<K, T, R, O> {
-
-		assert!(self.lower1 == self.upper1);
-		assert!(self.lower2 == self.upper2);
-
-		OrdKeyBatch {
-			layer: self.result.done(),
-			desc: self.description,
-		}
-	}
-	fn work(&mut self, source1: &OrdKeyBatch<K,T,R,O>, source2: &OrdKeyBatch<K,T,R,O>, fuel: &mut isize) {
-
-		let starting_updates = self.result.vals.vals.len();
-		let mut effort = 0isize;
-
-		let initial_key_pos = self.result.keys.len();
-
-		// while both mergees are still active
-		while self.lower1 < self.upper1 && self.lower2 < self.upper2 && effort < *fuel {
-			self.result.merge_step((&source1.layer, &mut self.lower1, self.upper1), (&source2.layer, &mut self.lower2, self.upper2));
-			effort = (self.result.vals.vals.len() - starting_updates) as isize;
-		}
-
-		// if self.lower1 == self.upper1 || self.lower2 == self.upper2 {
-		// 	// these are just copies, so let's bite the bullet and just do them.
-		// 	if self.lower1 < self.upper1 { self.result.copy_range(&source1.layer, self.lower1, self.upper1); self.lower1 = self.upper1; }
-		// 	if self.lower2 < self.upper2 { self.result.copy_range(&source2.layer, self.lower2, self.upper2); self.lower2 = self.upper2; }
-		// }
+    fn new(batch1: &OrdKeyBatch<K, T, R, O>, batch2: &OrdKeyBatch<K, T, R, O>, compaction_frontier: Option<AntichainRef<T>>) -> Self {
+
+        assert!(batch1.upper() == batch2.lower());
+
+        let mut since = batch1.description().since().join(batch2.description().since());
+        if let Some(compaction_frontier) = compaction_frontier {
+            since = since.join(&compaction_frontier.to_owned());
+        }
+
+        let description = Description::new(batch1.lower().clone(), batch2.upper().clone(), since);
+
+        OrdKeyMerger {
+            lower1: 0,
+            upper1: batch1.layer.keys(),
+            lower2: 0,
+            upper2: batch2.layer.keys(),
+            result: <<OrderedLayer<K, OrderedLeaf<T, R>, O> as Trie>::MergeBuilder as MergeBuilder>::with_capacity(&batch1.layer, &batch2.layer),
+            description: description,
+            should_compact: compaction_frontier.is_some(),
+        }
+    }
+    fn done(self) -> OrdKeyBatch<K, T, R, O> {
+
+        assert!(self.lower1 == self.upper1);
+        assert!(self.lower2 == self.upper2);
+
+        OrdKeyBatch {
+            layer: self.result.done(),
+            desc: self.description,
+        }
+    }
+    fn work(&mut self, source1: &OrdKeyBatch<K,T,R,O>, source2: &OrdKeyBatch<K,T,R,O>, fuel: &mut isize) {
+
+        let starting_updates = self.result.vals.vals.len();
+        let mut effort = 0isize;
+
+        let initial_key_pos = self.result.keys.len();
+
+        // while both mergees are still active
+        while self.lower1 < self.upper1 && self.lower2 < self.upper2 && effort < *fuel {
+            self.result.merge_step((&source1.layer, &mut self.lower1, self.upper1), (&source2.layer, &mut self.lower2, self.upper2));
+            effort = (self.result.vals.vals.len() - starting_updates) as isize;
+        }
+
+        // if self.lower1 == self.upper1 || self.lower2 == self.upper2 {
+        //     // these are just copies, so let's bite the bullet and just do them.
+        //     if self.lower1 < self.upper1 { self.result.copy_range(&source1.layer, self.lower1, self.upper1); self.lower1 = self.upper1; }
+        //     if self.lower2 < self.upper2 { self.result.copy_range(&source2.layer, self.lower2, self.upper2); self.lower2 = self.upper2; }
+        // }
         // Merging is complete; only copying remains. Copying is probably faster than merging, so could take some liberties here.
-		if self.lower1 == self.upper1 || self.lower2 == self.upper2 {
+        if self.lower1 == self.upper1 || self.lower2 == self.upper2 {
             // Limit merging by remaining fuel.
             let remaining_fuel = *fuel - effort;
             if remaining_fuel > 0 {
@@ -611,31 +611,31 @@ where
                     self.lower2 += to_copy;
                 }
             }
-		}
+        }
 
 
         effort = (self.result.vals.vals.len() - starting_updates) as isize;
 
-		// if we are supplied a frontier, we should compact.
-		if self.should_compact {
-			OrdKeyBatch::advance_builder_from(&mut self.result, self.description.since().borrow(), initial_key_pos);
-		}
+        // if we are supplied a frontier, we should compact.
+        if self.should_compact {
+            OrdKeyBatch::advance_builder_from(&mut self.result, self.description.since().borrow(), initial_key_pos);
+        }
 
         *fuel -= effort;
 
         // if *fuel < -1_000_000 {
         //     eprintln!("Massive deficit OrdKey::work: {}", fuel);
         // }
-	}
+    }
 }
 
 
 /// A cursor for navigating a single layer.
 #[derive(Debug)]
 pub struct OrdKeyCursor<T: Lattice+Ord+Clone, R: Semigroup, O=usize> {
-	valid: bool,
-	empty: (),
-	cursor: OrderedCursor<OrderedLeaf<T, R>>,
+    valid: bool,
+    empty: (),
+    cursor: OrderedCursor<OrderedLeaf<T, R>>,
     phantom: PhantomData<O>
 }
 
@@ -647,25 +647,25 @@ where
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
 
-	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 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) {
-			logic(&self.cursor.child.key(&storage.layer.vals).0, &self.cursor.child.key(&storage.layer.vals).1);
-			self.cursor.child.step(&storage.layer.vals);
-		}
-	}
-	fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.valid(&storage.layer) }
-	fn val_valid(&self, _storage: &Self::Storage) -> bool { self.valid }
-	fn step_key(&mut self, storage: &Self::Storage){ self.cursor.step(&storage.layer); self.valid = true; }
-	fn seek_key(&mut self, storage: &Self::Storage, key: &K) { self.cursor.seek(&storage.layer, key); self.valid = true; }
-	fn step_val(&mut self, _storage: &Self::Storage) { self.valid = false; }
-	fn seek_val(&mut self, _storage: &Self::Storage, _val: &()) { }
-	fn rewind_keys(&mut self, storage: &Self::Storage) { self.cursor.rewind(&storage.layer); self.valid = true; }
-	fn rewind_vals(&mut self, _storage: &Self::Storage) { self.valid = true; }
+    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 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) {
+            logic(&self.cursor.child.key(&storage.layer.vals).0, &self.cursor.child.key(&storage.layer.vals).1);
+            self.cursor.child.step(&storage.layer.vals);
+        }
+    }
+    fn key_valid(&self, storage: &Self::Storage) -> bool { self.cursor.valid(&storage.layer) }
+    fn val_valid(&self, _storage: &Self::Storage) -> bool { self.valid }
+    fn step_key(&mut self, storage: &Self::Storage){ self.cursor.step(&storage.layer); self.valid = true; }
+    fn seek_key(&mut self, storage: &Self::Storage, key: &K) { self.cursor.seek(&storage.layer, key); self.valid = true; }
+    fn step_val(&mut self, _storage: &Self::Storage) { self.valid = false; }
+    fn seek_val(&mut self, _storage: &Self::Storage, _val: &()) { }
+    fn rewind_keys(&mut self, storage: &Self::Storage) { self.cursor.rewind(&storage.layer); self.valid = true; }
+    fn rewind_vals(&mut self, _storage: &Self::Storage) { self.valid = true; }
 }
 
 
@@ -677,7 +677,7 @@ where
     R: Semigroup,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	builder: OrderedBuilder<K, OrderedLeafBuilder<T, R>, O>,
+    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>
@@ -688,28 +688,28 @@ where
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
 
-	fn new() -> Self {
-		OrdKeyBuilder {
-			builder: OrderedBuilder::<K, OrderedLeafBuilder<T, R>, O>::new()
-		}
-	}
-
-	fn with_capacity(cap: usize) -> Self {
-		OrdKeyBuilder {
-			builder: <OrderedBuilder<K, OrderedLeafBuilder<T, R>, O> as TupleBuilder>::with_capacity(cap)
-		}
-	}
-
-	#[inline]
-	fn push(&mut self, (key, _, time, diff): (K, (), T, R)) {
-		self.builder.push_tuple((key, (time, diff)));
-	}
-
-	#[inline(never)]
-	fn done(self, lower: Antichain<T>, upper: Antichain<T>, since: Antichain<T>) -> OrdKeyBatch<K, T, R, O> {
-		OrdKeyBatch {
-			layer: self.builder.done(),
-			desc: Description::new(lower, upper, since)
-		}
-	}
+    fn new() -> Self {
+        OrdKeyBuilder {
+            builder: OrderedBuilder::<K, OrderedLeafBuilder<T, R>, O>::new()
+        }
+    }
+
+    fn with_capacity(cap: usize) -> Self {
+        OrdKeyBuilder {
+            builder: <OrderedBuilder<K, OrderedLeafBuilder<T, R>, O> as TupleBuilder>::with_capacity(cap)
+        }
+    }
+
+    #[inline]
+    fn push(&mut self, (key, _, time, diff): (K, (), T, R)) {
+        self.builder.push_tuple((key, (time, diff)));
+    }
+
+    #[inline(never)]
+    fn done(self, lower: Antichain<T>, upper: Antichain<T>, since: Antichain<T>) -> OrdKeyBatch<K, T, R, O> {
+        OrdKeyBatch {
+            layer: self.builder.done(),
+            desc: Description::new(lower, upper, since)
+        }
+    }
 }
diff --git a/src/trace/implementations/vec.rs b/src/trace/implementations/vec.rs
index 0b3bdc770..f9ccfc284 100644
--- a/src/trace/implementations/vec.rs
+++ b/src/trace/implementations/vec.rs
@@ -23,244 +23,244 @@ use super::merge_batcher::MergeBatcher;
 
 #[derive(Debug, Abomonation)]
 pub struct VecBatch<K: Ord, V: Ord, T: Lattice, R> {
-	pub list: Vec<(K, V, T, R)>,
-	pub desc: Description<T>,
+    pub list: Vec<(K, V, T, R)>,
+    pub desc: Description<T>,
 }
 
 impl<K, V, T, R> BatchReader<K, V, T, R> for VecBatch<K, V, T, R>
 where K: Ord+Clone+'static, V: Ord+Clone+'static, T: Lattice+Ord+Clone+'static, R: Diff {
-	type Cursor = VecCursor;
-	fn cursor(&self) -> Self::Cursor { VecCursor { key_pos: 0, val_pos: 0 } }
-	fn len(&self) -> usize { self.list.len() }
-	fn description(&self) -> &Description<T> { &self.desc }
+    type Cursor = VecCursor;
+    fn cursor(&self) -> Self::Cursor { VecCursor { key_pos: 0, val_pos: 0 } }
+    fn len(&self) -> usize { self.list.len() }
+    fn description(&self) -> &Description<T> { &self.desc }
 }
 
 impl<K, V, T, R> Batch<K, V, T, R> for VecBatch<K, V, T, R>
 where K: Ord+Clone+'static, V: Ord+Clone+'static, T: Lattice+Ord+Clone+::std::fmt::Debug+'static, R: Diff {
-	type Batcher = MergeBatcher<K, V, T, R, Self>;
-	type Builder = VecBuilder<K, V, T, R>;
-	type Merger = VecMerger<K, V, T, R>;
+    type Batcher = MergeBatcher<K, V, T, R, Self>;
+    type Builder = VecBuilder<K, V, T, R>;
+    type Merger = VecMerger<K, V, T, R>;
 
-	fn begin_merge(&self, other: &Self) -> Self::Merger {
-		VecMerger::new(self, other)
-	}
+    fn begin_merge(&self, other: &Self) -> Self::Merger {
+        VecMerger::new(self, other)
+    }
 }
 
 impl<K, V, T, R> VecBatch<K, V, T, R>
 where K: Ord+Clone+'static, V: Ord+Clone+'static, T: Lattice+Ord+Clone+::std::fmt::Debug+'static, R: Diff {
-	fn advance_builder_from(list: &mut Vec<(K,V,T,R)>, frontier: &[T], key_pos: usize) {
-
-		for index in key_pos .. list.len() {
-			list[index].2 = list[index].2.advance_by(frontier);
-		}
-
-		// TODO: Already sorted by key, val; could sort restricted ranges.
-		list[key_pos ..].sort();
-
-		for index in key_pos .. (list.len() - 1) {
-			if list[index].0 == list[index+1].0 && list[index].1 == list[index+1].1 && list[index].2 == list[index+1].2 {
-				list[index+1].3 = list[index+1].3 + list[index].3;
-				list[index].3 = R::zero();
-			}
-		}
-
-		let mut write_position = key_pos;
-		for index in key_pos .. list.len() {
-			if !list[index].3.is_zero() {
-				list.swap(write_position, index);
-				write_position += 1;
-			}
-		}
-
-		list.truncate(write_position);
-	}
+    fn advance_builder_from(list: &mut Vec<(K,V,T,R)>, frontier: &[T], key_pos: usize) {
+
+        for index in key_pos .. list.len() {
+            list[index].2 = list[index].2.advance_by(frontier);
+        }
+
+        // TODO: Already sorted by key, val; could sort restricted ranges.
+        list[key_pos ..].sort();
+
+        for index in key_pos .. (list.len() - 1) {
+            if list[index].0 == list[index+1].0 && list[index].1 == list[index+1].1 && list[index].2 == list[index+1].2 {
+                list[index+1].3 = list[index+1].3 + list[index].3;
+                list[index].3 = R::zero();
+            }
+        }
+
+        let mut write_position = key_pos;
+        for index in key_pos .. list.len() {
+            if !list[index].3.is_zero() {
+                list.swap(write_position, index);
+                write_position += 1;
+            }
+        }
+
+        list.truncate(write_position);
+    }
 }
 
 /// State for an in-progress merge.
 pub struct VecMerger<K: Ord+Clone+'static, V: Ord+Clone+'static, T: Lattice+Ord+Clone+::std::fmt::Debug+'static, R: Diff> {
-	// first batch, and position therein.
-	lower1: usize,
-	upper1: usize,
-	// second batch, and position therein.
-	lower2: usize,
-	upper2: usize,
-	// result that we are currently assembling.
-	result: Vec<(K,V,T,R)>,
-	description: Description<T>,
+    // first batch, and position therein.
+    lower1: usize,
+    upper1: usize,
+    // second batch, and position therein.
+    lower2: usize,
+    upper2: usize,
+    // result that we are currently assembling.
+    result: Vec<(K,V,T,R)>,
+    description: Description<T>,
 }
 
 impl<K, V, T, R> Merger<K, V, T, R, VecBatch<K, V, T, R>> for VecMerger<K, V, T, R>
 where K: Ord+Clone+'static, V: Ord+Clone+'static, T: Lattice+Ord+Clone+::std::fmt::Debug+'static, R: Diff {
-	fn new(batch1: &VecBatch<K, V, T, R>, batch2: &VecBatch<K, V, T, R>) -> Self {
-
-		assert!(batch1.upper() == batch2.lower());
-
-		let since = if batch1.description().since().iter().all(|t1| batch2.description().since().iter().any(|t2| t2.less_equal(t1))) {
-			batch2.description().since()
-		}
-		else {
-			batch1.description().since()
-		};
-
-		let description = Description::new(batch1.lower(), batch2.upper(), since);
-
-		VecMerger {
-			lower1: 0,
-			upper1: batch1.list.len(),
-			lower2: 0,
-			upper2: batch2.list.len(),
-			result: Vec::with_capacity(batch1.len() + batch2.len()),
-			description: description,
-		}
-	}
-	fn done(self) -> VecBatch<K, V, T, R> {
-
-		assert!(self.lower1 == self.upper1);
-		assert!(self.lower2 == self.upper2);
-
-		VecBatch {
-			list: self.result,
-			desc: self.description,
-		}
-	}
-	fn work(&mut self, source1: &VecBatch<K,V,T,R>, source2: &VecBatch<K,V,T,R>, frontier: &Option<Vec<T>>, fuel: &mut usize) {
-
-		let mut effort = 0;
-
-		let initial_pos = self.result.len();
-
-		// while both mergees are still active
-		while self.lower1 < self.upper1 && self.lower2 < self.upper2 && effort < *fuel {
-
-			let tuple1 = (&source1.list[self.lower1].0,&source1.list[self.lower1].1,&source1.list[self.lower1].2);
-			let tuple2 = (&source2.list[self.lower2].0,&source2.list[self.lower2].1,&source1.list[self.lower2].2);
-
-			match tuple1.cmp(&tuple2) {
-				Ordering::Less => {
-					self.result.push(source1.list[self.lower1].clone());
-					self.lower1 += 1;
-					effort += 1;
-				},
-				Ordering::Equal => {
-					let mut new_element = source1.list[self.lower1].clone();
-					new_element.3 = new_element.3 + source2.list[self.lower2].3;
-					self.result.push(new_element);
-					self.lower1 += 1;
-					self.lower2 += 1;
-					effort += 1;
-				}
-				Ordering::Greater => {
-					self.result.push(source2.list[self.lower2].clone());
-					self.lower2 += 1;
-					effort += 1;
-				}
-			}
-		}
-
-		if self.lower1 == self.upper1 || self.lower2 == self.upper2 {
-			// these are just copies, so let's bite the bullet and just do them.
-			if self.lower1 < self.upper1 {
-				self.result.extend(source1.list[self.lower1 .. self.upper1].iter().cloned());
-				self.lower1 = self.upper1;
-			}
-			if self.lower2 < self.upper2 {
-				self.result.extend(source2.list[self.lower2 .. self.upper2].iter().cloned());
-				self.lower2 = self.upper2;
-			}
-		}
-
-		// if we are supplied a frontier, we should compact.
-		if let Some(frontier) = frontier.as_ref() {
-			VecBatch::advance_builder_from(&mut self.result, frontier, initial_pos)
-		}
-
-		if effort >= *fuel { *fuel = 0; }
-		else 			   { *fuel -= effort; }
-	}
+    fn new(batch1: &VecBatch<K, V, T, R>, batch2: &VecBatch<K, V, T, R>) -> Self {
+
+        assert!(batch1.upper() == batch2.lower());
+
+        let since = if batch1.description().since().iter().all(|t1| batch2.description().since().iter().any(|t2| t2.less_equal(t1))) {
+            batch2.description().since()
+        }
+        else {
+            batch1.description().since()
+        };
+
+        let description = Description::new(batch1.lower(), batch2.upper(), since);
+
+        VecMerger {
+            lower1: 0,
+            upper1: batch1.list.len(),
+            lower2: 0,
+            upper2: batch2.list.len(),
+            result: Vec::with_capacity(batch1.len() + batch2.len()),
+            description: description,
+        }
+    }
+    fn done(self) -> VecBatch<K, V, T, R> {
+
+        assert!(self.lower1 == self.upper1);
+        assert!(self.lower2 == self.upper2);
+
+        VecBatch {
+            list: self.result,
+            desc: self.description,
+        }
+    }
+    fn work(&mut self, source1: &VecBatch<K,V,T,R>, source2: &VecBatch<K,V,T,R>, frontier: &Option<Vec<T>>, fuel: &mut usize) {
+
+        let mut effort = 0;
+
+        let initial_pos = self.result.len();
+
+        // while both mergees are still active
+        while self.lower1 < self.upper1 && self.lower2 < self.upper2 && effort < *fuel {
+
+            let tuple1 = (&source1.list[self.lower1].0,&source1.list[self.lower1].1,&source1.list[self.lower1].2);
+            let tuple2 = (&source2.list[self.lower2].0,&source2.list[self.lower2].1,&source1.list[self.lower2].2);
+
+            match tuple1.cmp(&tuple2) {
+                Ordering::Less => {
+                    self.result.push(source1.list[self.lower1].clone());
+                    self.lower1 += 1;
+                    effort += 1;
+                },
+                Ordering::Equal => {
+                    let mut new_element = source1.list[self.lower1].clone();
+                    new_element.3 = new_element.3 + source2.list[self.lower2].3;
+                    self.result.push(new_element);
+                    self.lower1 += 1;
+                    self.lower2 += 1;
+                    effort += 1;
+                }
+                Ordering::Greater => {
+                    self.result.push(source2.list[self.lower2].clone());
+                    self.lower2 += 1;
+                    effort += 1;
+                }
+            }
+        }
+
+        if self.lower1 == self.upper1 || self.lower2 == self.upper2 {
+            // these are just copies, so let's bite the bullet and just do them.
+            if self.lower1 < self.upper1 {
+                self.result.extend(source1.list[self.lower1 .. self.upper1].iter().cloned());
+                self.lower1 = self.upper1;
+            }
+            if self.lower2 < self.upper2 {
+                self.result.extend(source2.list[self.lower2 .. self.upper2].iter().cloned());
+                self.lower2 = self.upper2;
+            }
+        }
+
+        // if we are supplied a frontier, we should compact.
+        if let Some(frontier) = frontier.as_ref() {
+            VecBatch::advance_builder_from(&mut self.result, frontier, initial_pos)
+        }
+
+        if effort >= *fuel { *fuel = 0; }
+        else                { *fuel -= effort; }
+    }
 }
 
 /// A cursor for navigating a single layer.
 #[derive(Debug)]
 pub struct VecCursor {
-	key_pos: usize,
-	val_pos: usize,
+    key_pos: usize,
+    val_pos: usize,
 }
 
 impl<K, V, T, R> Cursor<K, V, T, R> for VecCursor
 where K: Ord+Clone, V: Ord+Clone, T: Lattice+Ord+Clone, R: Diff {
 
-	type Storage = VecBatch<K, V, T, R>;
-
-	fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K { &storage.list[self.key_pos].0 }
-	fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V { &storage.list[self.val_pos].1 }
-	fn map_times<L: FnMut(&T, R)>(&mut self, storage: &Self::Storage, mut logic: L) {
-		let key_val = (self.key(storage), self.val(storage));
-		let mut temp_index = self.val_pos;
-		while temp_index < storage.list.len() && key_val == (&storage.list[temp_index].0,&storage.list[temp_index].1) {
-			logic(&storage.list[temp_index].2, storage.list[temp_index].3);
-			temp_index += 1;
-		}
-	}
-	fn key_valid(&self, storage: &Self::Storage) -> bool { self.key_pos < storage.list.len() }
-	fn val_valid(&self, storage: &Self::Storage) -> bool {
-		self.val_pos < storage.list.len() && storage.list[self.key_pos].0 == storage.list[self.val_pos].0
-	}
-	fn step_key(&mut self, storage: &Self::Storage){
-		if let Some(key) = self.get_key(storage) {
-			let step = advance(&storage.list[self.key_pos..], |tuple| &tuple.0 == key);
-			self.key_pos += step;
-		}
-	}
-	fn seek_key(&mut self, storage: &Self::Storage, key: &K) {
-		if self.key_valid(storage) {
-			let step = advance(&storage.list[self.key_pos..], |tuple| &tuple.0 < key);
-			self.key_pos += step;
-		}
-	}
-	fn step_val(&mut self, storage: &Self::Storage) {
-		if let Some(val) = self.get_val(storage) {
-			let step = advance(&storage.list[self.val_pos..], |tuple| &tuple.0 == self.key(storage) && &tuple.1 == val);
-			self.val_pos += step;
-		}
-	}
-	fn seek_val(&mut self, storage: &Self::Storage, val: &V) {
-		if self.val_valid(storage) {
-			let step = advance(&storage.list[self.val_pos..], |tuple| &tuple.0 == self.key(storage) && &tuple.1 < val);
-			self.val_pos += step;
-		}
-	}
-	fn rewind_keys(&mut self, _storage: &Self::Storage) { self.key_pos = 0; }
-	fn rewind_vals(&mut self, storage: &Self::Storage) {
-		if let Some(key) = self.get_key(storage) {
-			self.rewind_keys(storage);
-			self.seek_key(storage, key);
-		}
-	}
+    type Storage = VecBatch<K, V, T, R>;
+
+    fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K { &storage.list[self.key_pos].0 }
+    fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V { &storage.list[self.val_pos].1 }
+    fn map_times<L: FnMut(&T, R)>(&mut self, storage: &Self::Storage, mut logic: L) {
+        let key_val = (self.key(storage), self.val(storage));
+        let mut temp_index = self.val_pos;
+        while temp_index < storage.list.len() && key_val == (&storage.list[temp_index].0,&storage.list[temp_index].1) {
+            logic(&storage.list[temp_index].2, storage.list[temp_index].3);
+            temp_index += 1;
+        }
+    }
+    fn key_valid(&self, storage: &Self::Storage) -> bool { self.key_pos < storage.list.len() }
+    fn val_valid(&self, storage: &Self::Storage) -> bool {
+        self.val_pos < storage.list.len() && storage.list[self.key_pos].0 == storage.list[self.val_pos].0
+    }
+    fn step_key(&mut self, storage: &Self::Storage){
+        if let Some(key) = self.get_key(storage) {
+            let step = advance(&storage.list[self.key_pos..], |tuple| &tuple.0 == key);
+            self.key_pos += step;
+        }
+    }
+    fn seek_key(&mut self, storage: &Self::Storage, key: &K) {
+        if self.key_valid(storage) {
+            let step = advance(&storage.list[self.key_pos..], |tuple| &tuple.0 < key);
+            self.key_pos += step;
+        }
+    }
+    fn step_val(&mut self, storage: &Self::Storage) {
+        if let Some(val) = self.get_val(storage) {
+            let step = advance(&storage.list[self.val_pos..], |tuple| &tuple.0 == self.key(storage) && &tuple.1 == val);
+            self.val_pos += step;
+        }
+    }
+    fn seek_val(&mut self, storage: &Self::Storage, val: &V) {
+        if self.val_valid(storage) {
+            let step = advance(&storage.list[self.val_pos..], |tuple| &tuple.0 == self.key(storage) && &tuple.1 < val);
+            self.val_pos += step;
+        }
+    }
+    fn rewind_keys(&mut self, _storage: &Self::Storage) { self.key_pos = 0; }
+    fn rewind_vals(&mut self, storage: &Self::Storage) {
+        if let Some(key) = self.get_key(storage) {
+            self.rewind_keys(storage);
+            self.seek_key(storage, key);
+        }
+    }
 }
 
 
 /// A builder for creating layers from unsorted update tuples.
 pub struct VecBuilder<K: Ord, V: Ord, T: Ord+Lattice, R: Diff> {
-	list: Vec<(K,V,T,R)>,
+    list: Vec<(K,V,T,R)>,
 }
 
 impl<K, V, T, R> Builder<K, V, T, R, VecBatch<K, V, T, R>> for VecBuilder<K, V, T, R>
 where K: Ord+Clone+'static, V: Ord+Clone+'static, T: Lattice+Ord+Clone+::std::fmt::Debug+'static, R: Diff {
 
-	fn new() -> Self { VecBuilder { list: Vec::new() } }
-	fn with_capacity(cap: usize) -> Self { VecBuilder { list: Vec::with_capacity(cap) } }
+    fn new() -> Self { VecBuilder { list: Vec::new() } }
+    fn with_capacity(cap: usize) -> Self { VecBuilder { list: Vec::with_capacity(cap) } }
 
-	#[inline]
-	fn push(&mut self, (key, val, time, diff): (K, V, T, R)) { self.list.push((key,val,time,diff)); }
+    #[inline]
+    fn push(&mut self, (key, val, time, diff): (K, V, T, R)) { self.list.push((key,val,time,diff)); }
 
-	#[inline(never)]
-	fn done(mut self, lower: &[T], upper: &[T], since: &[T]) -> VecBatch<K, V, T, R> {
-		self.list.sort();
-		VecBatch {
-			list: self.list,
-			desc: Description::new(lower, upper, since)
-		}
-	}
+    #[inline(never)]
+    fn done(mut self, lower: &[T], upper: &[T], since: &[T]) -> VecBatch<K, V, T, R> {
+        self.list.sort();
+        VecBatch {
+            list: self.list,
+            desc: Description::new(lower, upper, since)
+        }
+    }
 }
 
 
@@ -273,28 +273,28 @@ where K: Ord+Clone+'static, V: Ord+Clone+'static, T: Lattice+Ord+Clone+::std::fm
 #[inline(never)]
 pub fn advance<T, F: Fn(&T)->bool>(slice: &[T], function: F) -> usize {
 
-	// start with no advance
-	let mut index = 0;
-	if index < slice.len() && function(&slice[index]) {
-
-		// advance in exponentially growing steps.
-		let mut step = 1;
-		while index + step < slice.len() && function(&slice[index + step]) {
-			index += step;
-			step = step << 1;
-		}
-
-		// advance in exponentially shrinking steps.
-		step = step >> 1;
-		while step > 0 {
-			if index + step < slice.len() && function(&slice[index + step]) {
-				index += step;
-			}
-			step = step >> 1;
-		}
-
-		index += 1;
-	}
-
-	index
+    // start with no advance
+    let mut index = 0;
+    if index < slice.len() && function(&slice[index]) {
+
+        // advance in exponentially growing steps.
+        let mut step = 1;
+        while index + step < slice.len() && function(&slice[index + step]) {
+            index += step;
+            step = step << 1;
+        }
+
+        // advance in exponentially shrinking steps.
+        step = step >> 1;
+        while step > 0 {
+            if index + step < slice.len() && function(&slice[index + step]) {
+                index += step;
+            }
+            step = step >> 1;
+        }
+
+        index += 1;
+    }
+
+    index
 }
diff --git a/src/trace/layers/ordered.rs b/src/trace/layers/ordered.rs
index 43ae230fb..c6b6f1a1c 100644
--- a/src/trace/layers/ordered.rs
+++ b/src/trace/layers/ordered.rs
@@ -25,15 +25,15 @@ where
     K: Ord,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	/// The keys of the layer.
-	pub keys: Vec<K>,
-	/// The offsets associate with each key.
-	///
-	/// The bounds for `keys[i]` are `(offs[i], offs[i+1]`). The offset array is guaranteed to be one
-	/// element longer than the keys array, ensuring that these accesses do not panic.
-	pub offs: Vec<O>,
-	/// The ranges of values associated with the keys.
-	pub vals: L,
+    /// The keys of the layer.
+    pub keys: Vec<K>,
+    /// The offsets associate with each key.
+    ///
+    /// The bounds for `keys[i]` are `(offs[i], offs[i+1]`). The offset array is guaranteed to be one
+    /// element longer than the keys array, ensuring that these accesses do not panic.
+    pub offs: Vec<O>,
+    /// The ranges of values associated with the keys.
+    pub vals: L,
 }
 
 impl<K, L, O> Trie for OrderedLayer<K, L, O>
@@ -42,33 +42,33 @@ where
     L: Trie,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	type Item = (K, L::Item);
-	type Cursor = OrderedCursor<L>;
-	type MergeBuilder = OrderedBuilder<K, L::MergeBuilder, O>;
-	type TupleBuilder = OrderedBuilder<K, L::TupleBuilder, O>;
+    type Item = (K, L::Item);
+    type Cursor = OrderedCursor<L>;
+    type MergeBuilder = OrderedBuilder<K, L::MergeBuilder, O>;
+    type TupleBuilder = OrderedBuilder<K, L::TupleBuilder, O>;
 
-	fn keys(&self) -> usize { self.keys.len() }
-	fn tuples(&self) -> usize { self.vals.tuples() }
-	fn cursor_from(&self, lower: usize, upper: usize) -> Self::Cursor {
+    fn keys(&self) -> usize { self.keys.len() }
+    fn tuples(&self) -> usize { self.vals.tuples() }
+    fn cursor_from(&self, lower: usize, upper: usize) -> Self::Cursor {
 
-		if lower < upper {
+        if lower < upper {
 
-			let child_lower = self.offs[lower];
-			let child_upper = self.offs[lower + 1];
-			OrderedCursor {
-				bounds: (lower, upper),
-				child: self.vals.cursor_from(child_lower.try_into().unwrap(), child_upper.try_into().unwrap()),
-				pos: lower,
-			}
-		}
-		else {
-			OrderedCursor {
-				bounds: (0, 0),
-				child: self.vals.cursor_from(0, 0),
-				pos: 0,
-			}
-		}
-	}
+            let child_lower = self.offs[lower];
+            let child_upper = self.offs[lower + 1];
+            OrderedCursor {
+                bounds: (lower, upper),
+                child: self.vals.cursor_from(child_lower.try_into().unwrap(), child_upper.try_into().unwrap()),
+                pos: lower,
+            }
+        }
+        else {
+            OrderedCursor {
+                bounds: (0, 0),
+                child: self.vals.cursor_from(0, 0),
+                pos: 0,
+            }
+        }
+    }
 }
 
 /// Assembles a layer of this
@@ -77,12 +77,12 @@ where
     K: Ord,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	/// Keys
-	pub keys: Vec<K>,
-	/// Offsets
-	pub offs: Vec<O>,
-	/// The next layer down
-	pub vals: L,
+    /// Keys
+    pub keys: Vec<K>,
+    /// Offsets
+    pub offs: Vec<O>,
+    /// The next layer down
+    pub vals: L,
 }
 
 impl<K, L, O> Builder for OrderedBuilder<K, L, O>
@@ -91,21 +91,21 @@ where
     L: Builder,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	type Trie = OrderedLayer<K, L::Trie, O>;
-	fn boundary(&mut self) -> usize {
-		self.offs[self.keys.len()] = O::try_from(self.vals.boundary()).unwrap();
-		self.keys.len()
-	}
-	fn done(mut self) -> Self::Trie {
-		if self.keys.len() > 0 && self.offs[self.keys.len()].try_into().unwrap() == 0 {
-			self.offs[self.keys.len()] = O::try_from(self.vals.boundary()).unwrap();
-		}
-		OrderedLayer {
-			keys: self.keys,
-			offs: self.offs,
-			vals: self.vals.done(),
-		}
-	}
+    type Trie = OrderedLayer<K, L::Trie, O>;
+    fn boundary(&mut self) -> usize {
+        self.offs[self.keys.len()] = O::try_from(self.vals.boundary()).unwrap();
+        self.keys.len()
+    }
+    fn done(mut self) -> Self::Trie {
+        if self.keys.len() > 0 && self.offs[self.keys.len()].try_into().unwrap() == 0 {
+            self.offs[self.keys.len()] = O::try_from(self.vals.boundary()).unwrap();
+        }
+        OrderedLayer {
+            keys: self.keys,
+            offs: self.offs,
+            vals: self.vals.done(),
+        }
+    }
 }
 
 impl<K, L, O> MergeBuilder for OrderedBuilder<K, L, O>
@@ -114,44 +114,44 @@ where
     L: MergeBuilder,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	fn with_capacity(other1: &Self::Trie, other2: &Self::Trie) -> Self {
-		let mut offs = Vec::with_capacity(other1.keys() + other2.keys() + 1);
-		offs.push(O::try_from(0 as usize).unwrap());
-		OrderedBuilder {
-			keys: Vec::with_capacity(other1.keys() + other2.keys()),
-			offs: offs,
-			vals: L::with_capacity(&other1.vals, &other2.vals),
-		}
-	}
-	#[inline]
-	fn copy_range(&mut self, other: &Self::Trie, lower: usize, upper: usize) {
-		debug_assert!(lower < upper);
-		let other_basis = other.offs[lower];
-		let self_basis = self.offs.last().map(|&x| x).unwrap_or(O::try_from(0).unwrap());
+    fn with_capacity(other1: &Self::Trie, other2: &Self::Trie) -> Self {
+        let mut offs = Vec::with_capacity(other1.keys() + other2.keys() + 1);
+        offs.push(O::try_from(0 as usize).unwrap());
+        OrderedBuilder {
+            keys: Vec::with_capacity(other1.keys() + other2.keys()),
+            offs: offs,
+            vals: L::with_capacity(&other1.vals, &other2.vals),
+        }
+    }
+    #[inline]
+    fn copy_range(&mut self, other: &Self::Trie, lower: usize, upper: usize) {
+        debug_assert!(lower < upper);
+        let other_basis = other.offs[lower];
+        let self_basis = self.offs.last().map(|&x| x).unwrap_or(O::try_from(0).unwrap());
 
-		self.keys.extend_from_slice(&other.keys[lower .. upper]);
-		for index in lower .. upper {
-			self.offs.push((other.offs[index + 1] + self_basis) - other_basis);
-		}
-		self.vals.copy_range(&other.vals, other_basis.try_into().unwrap(), other.offs[upper].try_into().unwrap());
-	}
+        self.keys.extend_from_slice(&other.keys[lower .. upper]);
+        for index in lower .. upper {
+            self.offs.push((other.offs[index + 1] + self_basis) - other_basis);
+        }
+        self.vals.copy_range(&other.vals, other_basis.try_into().unwrap(), other.offs[upper].try_into().unwrap());
+    }
 
-	fn push_merge(&mut self, other1: (&Self::Trie, usize, usize), other2: (&Self::Trie, usize, usize)) -> usize {
-		let (trie1, mut lower1, upper1) = other1;
-		let (trie2, mut lower2, upper2) = other2;
+    fn push_merge(&mut self, other1: (&Self::Trie, usize, usize), other2: (&Self::Trie, usize, usize)) -> usize {
+        let (trie1, mut lower1, upper1) = other1;
+        let (trie2, mut lower2, upper2) = other2;
 
-		self.keys.reserve((upper1 - lower1) + (upper2 - lower2));
+        self.keys.reserve((upper1 - lower1) + (upper2 - lower2));
 
-		// while both mergees are still active
-		while lower1 < upper1 && lower2 < upper2 {
-			self.merge_step((trie1, &mut lower1, upper1), (trie2, &mut lower2, upper2));
-		}
+        // while both mergees are still active
+        while lower1 < upper1 && lower2 < upper2 {
+            self.merge_step((trie1, &mut lower1, upper1), (trie2, &mut lower2, upper2));
+        }
 
-		if lower1 < upper1 { self.copy_range(trie1, lower1, upper1); }
-		if lower2 < upper2 { self.copy_range(trie2, lower2, upper2); }
+        if lower1 < upper1 { self.copy_range(trie1, lower1, upper1); }
+        if lower2 < upper2 { self.copy_range(trie2, lower2, upper2); }
 
-		self.keys.len()
-	}
+        self.keys.len()
+    }
 }
 
 impl<K, L, O> OrderedBuilder<K, L, O>
@@ -160,45 +160,45 @@ where
     L: MergeBuilder,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	/// Performs one step of merging.
-	#[inline]
-	pub fn merge_step(&mut self, other1: (&<Self as Builder>::Trie, &mut usize, usize), other2: (&<Self as Builder>::Trie, &mut usize, usize)) {
+    /// Performs one step of merging.
+    #[inline]
+    pub fn merge_step(&mut self, other1: (&<Self as Builder>::Trie, &mut usize, usize), other2: (&<Self as Builder>::Trie, &mut usize, usize)) {
 
-		let (trie1, lower1, upper1) = other1;
-		let (trie2, lower2, upper2) = other2;
+        let (trie1, lower1, upper1) = other1;
+        let (trie2, lower2, upper2) = other2;
 
-		match trie1.keys[*lower1].cmp(&trie2.keys[*lower2]) {
-			::std::cmp::Ordering::Less => {
-				// determine how far we can advance lower1 until we reach/pass lower2
-				let step = 1 + advance(&trie1.keys[(1 + *lower1)..upper1], |x| x < &trie2.keys[*lower2]);
+        match trie1.keys[*lower1].cmp(&trie2.keys[*lower2]) {
+            ::std::cmp::Ordering::Less => {
+                // determine how far we can advance lower1 until we reach/pass lower2
+                let step = 1 + advance(&trie1.keys[(1 + *lower1)..upper1], |x| x < &trie2.keys[*lower2]);
                 let step = std::cmp::min(step, 1_000);
-				self.copy_range(trie1, *lower1, *lower1 + step);
-				*lower1 += step;
-			},
-			::std::cmp::Ordering::Equal => {
-				let lower = self.vals.boundary();
-				// record vals_length so we can tell if anything was pushed.
-				let upper = self.vals.push_merge(
-					(&trie1.vals, trie1.offs[*lower1].try_into().unwrap(), trie1.offs[*lower1 + 1].try_into().unwrap()),
-					(&trie2.vals, trie2.offs[*lower2].try_into().unwrap(), trie2.offs[*lower2 + 1].try_into().unwrap())
-				);
-				if upper > lower {
-					self.keys.push(trie1.keys[*lower1].clone());
-					self.offs.push(O::try_from(upper).unwrap());
-				}
+                self.copy_range(trie1, *lower1, *lower1 + step);
+                *lower1 += step;
+            },
+            ::std::cmp::Ordering::Equal => {
+                let lower = self.vals.boundary();
+                // record vals_length so we can tell if anything was pushed.
+                let upper = self.vals.push_merge(
+                    (&trie1.vals, trie1.offs[*lower1].try_into().unwrap(), trie1.offs[*lower1 + 1].try_into().unwrap()),
+                    (&trie2.vals, trie2.offs[*lower2].try_into().unwrap(), trie2.offs[*lower2 + 1].try_into().unwrap())
+                );
+                if upper > lower {
+                    self.keys.push(trie1.keys[*lower1].clone());
+                    self.offs.push(O::try_from(upper).unwrap());
+                }
 
-				*lower1 += 1;
-				*lower2 += 1;
-			},
-			::std::cmp::Ordering::Greater => {
-				// determine how far we can advance lower2 until we reach/pass lower1
-				let step = 1 + advance(&trie2.keys[(1 + *lower2)..upper2], |x| x < &trie1.keys[*lower1]);
+                *lower1 += 1;
+                *lower2 += 1;
+            },
+            ::std::cmp::Ordering::Greater => {
+                // determine how far we can advance lower2 until we reach/pass lower1
+                let step = 1 + advance(&trie2.keys[(1 + *lower2)..upper2], |x| x < &trie1.keys[*lower1]);
                 let step = std::cmp::min(step, 1_000);
-				self.copy_range(trie2, *lower2, *lower2 + step);
-				*lower2 += step;
-			},
-		}
-	}
+                self.copy_range(trie2, *lower2, *lower2 + step);
+                *lower2 += step;
+            },
+        }
+    }
 }
 
 impl<K, L, O> TupleBuilder for OrderedBuilder<K, L, O>
@@ -207,41 +207,41 @@ where
     L: TupleBuilder,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	type Item = (K, L::Item);
-	fn new() -> Self { OrderedBuilder { keys: Vec::new(), offs: vec![O::try_from(0).unwrap()], vals: L::new() } }
-	fn with_capacity(cap: usize) -> Self {
-		let mut offs = Vec::with_capacity(cap + 1);
-		offs.push(O::try_from(0).unwrap());
-		OrderedBuilder{
-			keys: Vec::with_capacity(cap),
-			offs: offs,
-			vals: L::with_capacity(cap),
-		}
-	}
-	#[inline]
-	fn push_tuple(&mut self, (key, val): (K, L::Item)) {
+    type Item = (K, L::Item);
+    fn new() -> Self { OrderedBuilder { keys: Vec::new(), offs: vec![O::try_from(0).unwrap()], vals: L::new() } }
+    fn with_capacity(cap: usize) -> Self {
+        let mut offs = Vec::with_capacity(cap + 1);
+        offs.push(O::try_from(0).unwrap());
+        OrderedBuilder{
+            keys: Vec::with_capacity(cap),
+            offs: offs,
+            vals: L::with_capacity(cap),
+        }
+    }
+    #[inline]
+    fn push_tuple(&mut self, (key, val): (K, L::Item)) {
 
-		// if first element, prior element finish, or different element, need to push and maybe punctuate.
-		if self.keys.len() == 0 || self.offs[self.keys.len()].try_into().unwrap() != 0 || self.keys[self.keys.len()-1] != key {
-			if self.keys.len() > 0 && self.offs[self.keys.len()].try_into().unwrap() == 0 {
-				self.offs[self.keys.len()] = O::try_from(self.vals.boundary()).unwrap();
-			}
-			self.keys.push(key);
-			self.offs.push(O::try_from(0).unwrap());		// <-- indicates "unfinished".
-		}
-		self.vals.push_tuple(val);
-	}
+        // if first element, prior element finish, or different element, need to push and maybe punctuate.
+        if self.keys.len() == 0 || self.offs[self.keys.len()].try_into().unwrap() != 0 || self.keys[self.keys.len()-1] != key {
+            if self.keys.len() > 0 && self.offs[self.keys.len()].try_into().unwrap() == 0 {
+                self.offs[self.keys.len()] = O::try_from(self.vals.boundary()).unwrap();
+            }
+            self.keys.push(key);
+            self.offs.push(O::try_from(0).unwrap());        // <-- indicates "unfinished".
+        }
+        self.vals.push_tuple(val);
+    }
 }
 
 /// A cursor with a child cursor that is updated as we move.
 #[derive(Debug)]
 pub struct OrderedCursor<L: Trie> {
-	// keys: OwningRef<Rc<Erased>, [K]>,
-	// offs: OwningRef<Rc<Erased>, [usize]>,
-	pos: usize,
-	bounds: (usize, usize),
-	/// The cursor for the trie layer below this one.
-	pub child: L::Cursor,
+    // keys: OwningRef<Rc<Erased>, [K]>,
+    // offs: OwningRef<Rc<Erased>, [usize]>,
+    pos: usize,
+    bounds: (usize, usize),
+    /// The cursor for the trie layer below this one.
+    pub child: L::Cursor,
 }
 
 impl<K, L, O> Cursor<OrderedLayer<K, L, O>> for OrderedCursor<L>
@@ -250,36 +250,36 @@ where
     L: Trie,
     O: OrdOffset, <O as TryFrom<usize>>::Error: Debug, <O as TryInto<usize>>::Error: Debug
 {
-	type Key = K;
-	fn key<'a>(&self, storage: &'a OrderedLayer<K, L, O>) -> &'a Self::Key { &storage.keys[self.pos] }
-	fn step(&mut self, storage: &OrderedLayer<K, L, O>) {
-		self.pos += 1;
-		if self.valid(storage) {
-			self.child.reposition(&storage.vals, storage.offs[self.pos].try_into().unwrap(), storage.offs[self.pos + 1].try_into().unwrap());
-		}
-		else {
-			self.pos = self.bounds.1;
-		}
-	}
-	fn seek(&mut self, storage: &OrderedLayer<K, L, O>, key: &Self::Key) {
-		self.pos += advance(&storage.keys[self.pos .. self.bounds.1], |k| k.lt(key));
-		if self.valid(storage) {
-			self.child.reposition(&storage.vals, storage.offs[self.pos].try_into().unwrap(), storage.offs[self.pos + 1].try_into().unwrap());
-		}
-	}
-	// fn size(&self) -> usize { self.bounds.1 - self.bounds.0 }
-	fn valid(&self, _storage: &OrderedLayer<K, L, O>) -> bool { self.pos < self.bounds.1 }
-	fn rewind(&mut self, storage: &OrderedLayer<K, L, O>) {
-		self.pos = self.bounds.0;
-		if self.valid(storage) {
-			self.child.reposition(&storage.vals, storage.offs[self.pos].try_into().unwrap(), storage.offs[self.pos + 1].try_into().unwrap());
-		}
-	}
-	fn reposition(&mut self, storage: &OrderedLayer<K, L, O>, lower: usize, upper: usize) {
-		self.pos = lower;
-		self.bounds = (lower, upper);
-		if self.valid(storage) {
-			self.child.reposition(&storage.vals, storage.offs[self.pos].try_into().unwrap(), storage.offs[self.pos + 1].try_into().unwrap());
-		}
-	}
+    type Key = K;
+    fn key<'a>(&self, storage: &'a OrderedLayer<K, L, O>) -> &'a Self::Key { &storage.keys[self.pos] }
+    fn step(&mut self, storage: &OrderedLayer<K, L, O>) {
+        self.pos += 1;
+        if self.valid(storage) {
+            self.child.reposition(&storage.vals, storage.offs[self.pos].try_into().unwrap(), storage.offs[self.pos + 1].try_into().unwrap());
+        }
+        else {
+            self.pos = self.bounds.1;
+        }
+    }
+    fn seek(&mut self, storage: &OrderedLayer<K, L, O>, key: &Self::Key) {
+        self.pos += advance(&storage.keys[self.pos .. self.bounds.1], |k| k.lt(key));
+        if self.valid(storage) {
+            self.child.reposition(&storage.vals, storage.offs[self.pos].try_into().unwrap(), storage.offs[self.pos + 1].try_into().unwrap());
+        }
+    }
+    // fn size(&self) -> usize { self.bounds.1 - self.bounds.0 }
+    fn valid(&self, _storage: &OrderedLayer<K, L, O>) -> bool { self.pos < self.bounds.1 }
+    fn rewind(&mut self, storage: &OrderedLayer<K, L, O>) {
+        self.pos = self.bounds.0;
+        if self.valid(storage) {
+            self.child.reposition(&storage.vals, storage.offs[self.pos].try_into().unwrap(), storage.offs[self.pos + 1].try_into().unwrap());
+        }
+    }
+    fn reposition(&mut self, storage: &OrderedLayer<K, L, O>, lower: usize, upper: usize) {
+        self.pos = lower;
+        self.bounds = (lower, upper);
+        if self.valid(storage) {
+            self.child.reposition(&storage.vals, storage.offs[self.pos].try_into().unwrap(), storage.offs[self.pos + 1].try_into().unwrap());
+        }
+    }
 }
diff --git a/src/trace/mod.rs b/src/trace/mod.rs
index ab09d8f22..b588c8799 100644
--- a/src/trace/mod.rs
+++ b/src/trace/mod.rs
@@ -20,13 +20,13 @@ use timely::progress::Timestamp;
 pub use self::cursor::Cursor;
 pub use self::description::Description;
 
-// 	The traces and batch and cursors want the flexibility to appear as if they manage certain types of keys and
-// 	values and such, while perhaps using other representations, I'm thinking mostly of wrappers around the keys
-// 	and vals that change the `Ord` implementation, or stash hash codes, or the like.
+//     The traces and batch and cursors want the flexibility to appear as if they manage certain types of keys and
+//     values and such, while perhaps using other representations, I'm thinking mostly of wrappers around the keys
+//     and vals that change the `Ord` implementation, or stash hash codes, or the like.
 //
-// 	This complicates what requirements we make so that the trace is still usable by someone who knows only about
-// 	the base key and value types. For example, the complex types should likely dereference to the simpler types,
-//	so that the user can make sense of the result as if they were given references to the simpler types. At the
+//     This complicates what requirements we make so that the trace is still usable by someone who knows only about
+//     the base key and value types. For example, the complex types should likely dereference to the simpler types,
+//    so that the user can make sense of the result as if they were given references to the simpler types. At the
 //  same time, the collection should be formable from base types (perhaps we need an `Into` or `From` constraint)
 //  and we should, somehow, be able to take a reference to the simple types to compare against the more complex
 //  types. This second one is also like an `Into` or `From` constraint, except that we start with a reference and
@@ -42,39 +42,39 @@ pub use self::description::Description;
 /// capabilities (which may release restrictions on the mutations to the underlying trace and cause work to happen).
 pub trait TraceReader {
 
-	/// Key by which updates are indexed.
-	type Key;
-	/// Values associated with keys.
-	type Val;
-	/// Timestamps associated with updates
-	type Time;
-	/// Associated update.
-	type R;
-
-	/// The type of an immutable collection of updates.
-	type Batch: BatchReader<Self::Key, Self::Val, Self::Time, Self::R>+Clone+'static;
-
-	/// The type used to enumerate the collections contents.
-	type Cursor: Cursor<Self::Key, Self::Val, Self::Time, 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) {
-		if let Some(cursor) = self.cursor_through(Antichain::new().borrow()) {
-			cursor
-		}
-		else {
-			panic!("unable to acquire complete cursor for trace; is it closed?");
-		}
-	}
-
-	/// Acquires a cursor to the restriction of the collection's contents to updates at times not greater or
-	/// equal to an element of `upper`.
-	///
-	/// This method is expected to work if called with an `upper` that (i) was an observed bound in batches from
-	/// 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)>;
+    /// 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 of an immutable collection of updates.
+    type Batch: BatchReader<Self::Key, Self::Val, Self::Time, Self::R>+Clone+'static;
+
+    /// The type used to enumerate the collections contents.
+    type Cursor: Cursor<Self::Key, Self::Val, Self::Time, 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) {
+        if let Some(cursor) = self.cursor_through(Antichain::new().borrow()) {
+            cursor
+        }
+        else {
+            panic!("unable to acquire complete cursor for trace; is it closed?");
+        }
+    }
+
+    /// Acquires a cursor to the restriction of the collection's contents to updates at times not greater or
+    /// equal to an element of `upper`.
+    ///
+    /// This method is expected to work if called with an `upper` that (i) was an observed bound in batches from
+    /// 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)>;
 
     /// Advances the frontier that constrains logical compaction.
     ///
@@ -91,25 +91,25 @@ pub trait TraceReader {
     ///
     /// It is an error to call this method with a frontier not beyond the most recent arguments to this method,
     /// or the initial value of `get_logical_compaction()` if this method has not yet been called.
-	fn set_logical_compaction(&mut self, frontier: AntichainRef<Self::Time>);
+    fn set_logical_compaction(&mut self, frontier: AntichainRef<Self::Time>);
 
     /// Deprecated form of `set_logical_compaction`.
     #[deprecated(since = "0.11", note = "please use `set_logical_compaction`")]
-	fn advance_by(&mut self, frontier: AntichainRef<Self::Time>) {
+    fn advance_by(&mut self, frontier: AntichainRef<Self::Time>) {
         self.set_logical_compaction(frontier);
     }
 
     /// Reports the logical compaction frontier.
-	///
+    ///
     /// All update times beyond this frontier will be presented with their original times, and all update times
     /// not beyond this frontier will present as a time that compares identically with all query times beyond
     /// this frontier. Practically, update times not beyond this frontier should not be taken to be accurate as
     /// presented, and should be used carefully, only in accumulation to times that are beyond the frontier.
-	fn get_logical_compaction(&mut self) -> AntichainRef<Self::Time>;
+    fn get_logical_compaction(&mut self) -> AntichainRef<Self::Time>;
 
     /// Deprecated form of `get_logical_compaction`.
     #[deprecated(since = "0.11", note = "please use `get_logical_compaction`")]
-	fn advance_frontier(&mut self) -> AntichainRef<Self::Time> {
+    fn advance_frontier(&mut self) -> AntichainRef<Self::Time> {
         self.get_logical_compaction()
     }
 
@@ -127,16 +127,16 @@ pub trait TraceReader {
     ///
     /// It is an error to call this method with a frontier not beyond the most recent arguments to this method,
     /// or the initial value of `get_physical_compaction()` if this method has not yet been called.
-	fn set_physical_compaction(&mut self, frontier: AntichainRef<Self::Time>);
+    fn set_physical_compaction(&mut self, frontier: AntichainRef<Self::Time>);
 
     /// Deprecated form of `set_physical_compaction`.
     #[deprecated(since = "0.11", note = "please use `set_physical_compaction`")]
-	fn distinguish_since(&mut self, frontier: AntichainRef<Self::Time>) {
+    fn distinguish_since(&mut self, frontier: AntichainRef<Self::Time>) {
         self.set_physical_compaction(frontier);
     }
 
-	/// Reports the physical compaction frontier.
-	///
+    /// Reports the physical compaction frontier.
+    ///
     /// All batches containing updates beyond this frontier will not be merged with ohter batches. This allows
     /// the caller to create a cursor through any frontier beyond the physical compaction frontier, with the
     /// `cursor_through()` method. This functionality is primarily of interest to the `join` operator, and any
@@ -145,30 +145,30 @@ pub trait TraceReader {
 
     /// Deprecated form of `get_physical_compaction`.
     #[deprecated(since = "0.11", note = "please use `get_physical_compaction`")]
-	fn distinguish_frontier(&mut self) -> AntichainRef<Self::Time> {
+    fn distinguish_frontier(&mut self) -> AntichainRef<Self::Time> {
         self.get_physical_compaction()
     }
 
-	/// Maps logic across the non-empty sequence of batches in the trace.
-	///
-	/// This is currently used only to extract historical data to prime late-starting operators who want to reproduce
-	/// the stream of batches moving past the trace. It could also be a fine basis for a default implementation of the
-	/// cursor methods, as they (by default) just move through batches accumulating cursors into a cursor list.
-	fn map_batches<F: FnMut(&Self::Batch)>(&mut self, f: F);
-
-	/// Reads the upper frontier of committed times.
-	///
-	///
-	fn read_upper(&mut self, target: &mut Antichain<Self::Time>)
-	where
-		Self::Time: Timestamp,
-	{
-		target.clear();
-		target.insert(<Self::Time as timely::progress::Timestamp>::minimum());
-		self.map_batches(|batch| {
-			target.clone_from(batch.upper());
-		});
-	}
+    /// Maps logic across the non-empty sequence of batches in the trace.
+    ///
+    /// This is currently used only to extract historical data to prime late-starting operators who want to reproduce
+    /// the stream of batches moving past the trace. It could also be a fine basis for a default implementation of the
+    /// cursor methods, as they (by default) just move through batches accumulating cursors into a cursor list.
+    fn map_batches<F: FnMut(&Self::Batch)>(&mut self, f: F);
+
+    /// Reads the upper frontier of committed times.
+    ///
+    ///
+    fn read_upper(&mut self, target: &mut Antichain<Self::Time>)
+    where
+        Self::Time: Timestamp,
+    {
+        target.clear();
+        target.insert(<Self::Time as timely::progress::Timestamp>::minimum());
+        self.map_batches(|batch| {
+            target.clone_from(batch.upper());
+        });
+    }
 
     /// Advances `upper` by any empty batches.
     ///
@@ -182,7 +182,7 @@ pub trait TraceReader {
     {
         self.map_batches(|batch| {
             if batch.is_empty() && batch.lower() == upper {
-				upper.clone_from(batch.upper());
+                upper.clone_from(batch.upper());
             }
         });
     }
@@ -199,31 +199,31 @@ pub trait TraceReader {
 pub trait Trace : TraceReader
 where <Self as TraceReader>::Batch: Batch<Self::Key, Self::Val, Self::Time, Self::R> {
 
-	/// Allocates a new empty trace.
-	fn new(
-		info: ::timely::dataflow::operators::generic::OperatorInfo,
-		logging: Option<::logging::Logger>,
-		activator: Option<timely::scheduling::activate::Activator>,
-	) -> Self;
-
-	///	Exert merge effort, even without updates.
-	fn exert(&mut self, effort: &mut isize);
-
-	/// Introduces a batch of updates to the trace.
-	///
-	/// Batches describe the time intervals they contain, and they should be added to the trace in contiguous
-	/// intervals. If a batch arrives with a lower bound that does not equal the upper bound of the most recent
-	/// addition, the trace will add an empty batch. It is an error to then try to populate that region of time.
-	///
-	/// This restriction could be relaxed, especially if we discover ways in which batch interval order could
-	/// commute. For now, the trace should complain, to the extent that it cares about contiguous intervals.
-	fn insert(&mut self, batch: Self::Batch);
-
-	/// Introduces an empty batch concluding the trace.
-	///
-	/// This method should be logically equivalent to introducing an empty batch whose lower frontier equals
-	/// the upper frontier of the most recently introduced batch, and whose upper frontier is empty.
-	fn close(&mut self);
+    /// Allocates a new empty trace.
+    fn new(
+        info: ::timely::dataflow::operators::generic::OperatorInfo,
+        logging: Option<::logging::Logger>,
+        activator: Option<timely::scheduling::activate::Activator>,
+    ) -> Self;
+
+    ///    Exert merge effort, even without updates.
+    fn exert(&mut self, effort: &mut isize);
+
+    /// Introduces a batch of updates to the trace.
+    ///
+    /// Batches describe the time intervals they contain, and they should be added to the trace in contiguous
+    /// intervals. If a batch arrives with a lower bound that does not equal the upper bound of the most recent
+    /// addition, the trace will add an empty batch. It is an error to then try to populate that region of time.
+    ///
+    /// This restriction could be relaxed, especially if we discover ways in which batch interval order could
+    /// commute. For now, the trace should complain, to the extent that it cares about contiguous intervals.
+    fn insert(&mut self, batch: Self::Batch);
+
+    /// Introduces an empty batch concluding the trace.
+    ///
+    /// This method should be logically equivalent to introducing an empty batch whose lower frontier equals
+    /// the upper frontier of the most recently introduced batch, and whose upper frontier is empty.
+    fn close(&mut self);
 }
 
 /// A batch of updates whose contents may be read.
@@ -234,320 +234,320 @@ where <Self as TraceReader>::Batch: Batch<Self::Key, Self::Val, Self::Time, Self
 /// 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>
 where
-	Self: ::std::marker::Sized,
+    Self: ::std::marker::Sized,
 {
-	/// The type used to enumerate the batch's contents.
-	type Cursor: Cursor<K, V, T, R, Storage=Self>;
-	/// Acquires a cursor to the batch's contents.
-	fn cursor(&self) -> Self::Cursor;
-	/// The number of updates in the batch.
-	fn len(&self) -> usize;
-	/// 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>;
-
-	/// All times in the batch are greater or equal to an element of `lower`.
-	fn lower(&self) -> &Antichain<T> { 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() }
+    /// The type used to enumerate the batch's contents.
+    type Cursor: Cursor<K, V, T, R, Storage=Self>;
+    /// Acquires a cursor to the batch's contents.
+    fn cursor(&self) -> Self::Cursor;
+    /// The number of updates in the batch.
+    fn len(&self) -> usize;
+    /// 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>;
+
+    /// All times in the batch are greater or equal to an element of `lower`.
+    fn lower(&self) -> &Antichain<T> { 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() }
 }
 
 /// An immutable collection of updates.
 pub trait Batch<K, V, T, R> : BatchReader<K, V, T, R> where Self: ::std::marker::Sized {
-	/// A type used to assemble batches from disordered updates.
-	type Batcher: Batcher<K, V, T, R, Self>;
-	/// A type used to assemble batches from ordered update sequences.
-	type Builder: Builder<K, V, T, R, Self>;
-	/// A type used to progressively merge batches.
-	type Merger: Merger<K, V, T, R, Self>;
-
-	/// Initiates the merging of consecutive batches.
-	///
-	/// The result of this method can be exercised to eventually produce the same result
-	/// that a call to `self.merge(other)` would produce, but it can be done in a measured
-	/// fashion. This can help to avoid latency spikes where a large merge needs to happen.
-	fn begin_merge(&self, other: &Self, compaction_frontier: Option<AntichainRef<T>>) -> Self::Merger {
-		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 {
-		<Self::Builder>::new().done(lower, upper, since)
-	}
+    /// A type used to assemble batches from disordered updates.
+    type Batcher: Batcher<K, V, T, R, Self>;
+    /// A type used to assemble batches from ordered update sequences.
+    type Builder: Builder<K, V, T, R, Self>;
+    /// A type used to progressively merge batches.
+    type Merger: Merger<K, V, T, R, Self>;
+
+    /// Initiates the merging of consecutive batches.
+    ///
+    /// The result of this method can be exercised to eventually produce the same result
+    /// that a call to `self.merge(other)` would produce, but it can be done in a measured
+    /// fashion. This can help to avoid latency spikes where a large merge needs to happen.
+    fn begin_merge(&self, other: &Self, compaction_frontier: Option<AntichainRef<T>>) -> Self::Merger {
+        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 {
+        <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>> {
-	/// 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)>);
-	/// Returns all updates not greater or equal to an element of `upper`.
-	fn seal(&mut self, upper: Antichain<T>) -> Output;
-	/// Returns the lower envelope of contained update times.
-	fn frontier(&mut self) -> timely::progress::frontier::AntichainRef<T>;
+    /// 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)>);
+    /// Returns all updates not greater or equal to an element of `upper`.
+    fn seal(&mut self, upper: Antichain<T>) -> Output;
+    /// Returns the lower envelope of contained update times.
+    fn frontier(&mut self) -> timely::progress::frontier::AntichainRef<T>;
 }
 
 /// Functionality for building batches from ordered update sequences.
 pub trait Builder<K, V, T, R, Output: Batch<K, V, T, R>> {
-	/// 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));
-	/// Adds an ordered sequence of elements to the batch.
-	fn extend<I: Iterator<Item=(K,V,T,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;
+    /// 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));
+    /// Adds an ordered sequence of elements to the batch.
+    fn extend<I: Iterator<Item=(K,V,T,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;
 }
 
 /// Represents a merge in progress.
 pub trait Merger<K, V, T, R, Output: Batch<K, V, T, R>> {
-	/// Creates a new merger to merge the supplied batches, optionally compacting
-	/// up to the supplied frontier.
-	fn new(source1: &Output, source2: &Output, compaction_frontier: Option<AntichainRef<T>>) -> Self;
-	/// Perform some amount of work, decrementing `fuel`.
-	///
-	/// If `fuel` is non-zero after the call, the merging is complete and
-	/// one should call `done` to extract the merged results.
-	fn work(&mut self, source1: &Output, source2: &Output, fuel: &mut isize);
-	/// Extracts merged results.
-	///
-	/// This method should only be called after `work` has been called and
-	/// has not brought `fuel` to zero. Otherwise, the merge is still in
-	/// progress.
-	fn done(self) -> Output;
+    /// 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;
+    /// Perform some amount of work, decrementing `fuel`.
+    ///
+    /// If `fuel` is non-zero after the call, the merging is complete and
+    /// one should call `done` to extract the merged results.
+    fn work(&mut self, source1: &Output, source2: &Output, fuel: &mut isize);
+    /// Extracts merged results.
+    ///
+    /// This method should only be called after `work` has been called and
+    /// has not brought `fuel` to zero. Otherwise, the merge is still in
+    /// progress.
+    fn done(self) -> Output;
 }
 
 
 /// Blanket implementations for reference counted batches.
 pub mod rc_blanket_impls {
 
-	use std::rc::Rc;
-
-	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> {
-
-		/// The type used to enumerate the batch's contents.
-		type Cursor = RcBatchCursor<K, V, T, R, B>;
-		/// Acquires a cursor to the batch's contents.
-		fn cursor(&self) -> Self::Cursor {
-			RcBatchCursor::new((&**self).cursor())
-		}
-
-		/// 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() }
-	}
-
-	/// 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)>,
-	    cursor: B::Cursor,
-	}
-
-	impl<K, V, T, R, B: BatchReader<K, V, T, R>> RcBatchCursor<K, V, T, R, 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> {
-
-	    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 map_times<L: FnMut(&T, &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 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 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>;
-	}
-
-	/// Wrapper type for batching reference counted batches.
-	pub struct RcBatcher<K,V,T,R,B:Batch<K,V,T,R>> { batcher: B::Batcher }
-
-	/// Functionality for collecting and batching updates.
-	impl<K,V,T,R,B:Batch<K,V,T,R>> Batcher<K, V, T, R, Rc<B>> for RcBatcher<K,V,T,R,B> {
-		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() }
-	}
-
-	/// Wrapper type for building reference counted batches.
-	pub struct RcBuilder<K,V,T,R,B:Batch<K,V,T,R>> { builder: B::Builder }
-
-	/// Functionality for building batches from ordered update sequences.
-	impl<K,V,T,R,B:Batch<K,V,T,R>> Builder<K, V, T, R, Rc<B>> for RcBuilder<K,V,T,R,B> {
-		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)) }
-	}
-
-	/// Wrapper type for merging reference counted batches.
-	pub struct RcMerger<K,V,T,R,B:Batch<K,V,T,R>> { merger: B::Merger }
-
-	/// Represents a merge in progress.
-	impl<K,V,T,R,B:Batch<K,V,T,R>> Merger<K, V, T, R, Rc<B>> for RcMerger<K,V,T,R,B> {
-		fn new(source1: &Rc<B>, source2: &Rc<B>, compaction_frontier: Option<AntichainRef<T>>) -> Self { RcMerger { merger: B::begin_merge(source1, source2, compaction_frontier) } }
-		fn work(&mut self, source1: &Rc<B>, source2: &Rc<B>, fuel: &mut isize) { self.merger.work(source1, source2, fuel) }
-		fn done(self) -> Rc<B> { Rc::new(self.merger.done()) }
-	}
+    use std::rc::Rc;
+
+    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> {
+
+        /// The type used to enumerate the batch's contents.
+        type Cursor = RcBatchCursor<K, V, T, R, B>;
+        /// Acquires a cursor to the batch's contents.
+        fn cursor(&self) -> Self::Cursor {
+            RcBatchCursor::new((&**self).cursor())
+        }
+
+        /// 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() }
+    }
+
+    /// 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)>,
+        cursor: B::Cursor,
+    }
+
+    impl<K, V, T, R, B: BatchReader<K, V, T, R>> RcBatchCursor<K, V, T, R, 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> {
+
+        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 map_times<L: FnMut(&T, &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 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 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>;
+    }
+
+    /// Wrapper type for batching reference counted batches.
+    pub struct RcBatcher<K,V,T,R,B:Batch<K,V,T,R>> { batcher: B::Batcher }
+
+    /// Functionality for collecting and batching updates.
+    impl<K,V,T,R,B:Batch<K,V,T,R>> Batcher<K, V, T, R, Rc<B>> for RcBatcher<K,V,T,R,B> {
+        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() }
+    }
+
+    /// Wrapper type for building reference counted batches.
+    pub struct RcBuilder<K,V,T,R,B:Batch<K,V,T,R>> { builder: B::Builder }
+
+    /// Functionality for building batches from ordered update sequences.
+    impl<K,V,T,R,B:Batch<K,V,T,R>> Builder<K, V, T, R, Rc<B>> for RcBuilder<K,V,T,R,B> {
+        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)) }
+    }
+
+    /// Wrapper type for merging reference counted batches.
+    pub struct RcMerger<K,V,T,R,B:Batch<K,V,T,R>> { merger: B::Merger }
+
+    /// Represents a merge in progress.
+    impl<K,V,T,R,B:Batch<K,V,T,R>> Merger<K, V, T, R, Rc<B>> for RcMerger<K,V,T,R,B> {
+        fn new(source1: &Rc<B>, source2: &Rc<B>, compaction_frontier: Option<AntichainRef<T>>) -> Self { RcMerger { merger: B::begin_merge(source1, source2, compaction_frontier) } }
+        fn work(&mut self, source1: &Rc<B>, source2: &Rc<B>, fuel: &mut isize) { self.merger.work(source1, source2, fuel) }
+        fn done(self) -> Rc<B> { Rc::new(self.merger.done()) }
+    }
 }
 
 
 /// Blanket implementations for reference counted batches.
 pub mod abomonated_blanket_impls {
 
-	extern crate abomonation;
-
-	use abomonation::{Abomonation, measure};
-	use abomonation::abomonated::Abomonated;
-	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>+Abomonation> BatchReader<K,V,T,R> for Abomonated<B, Vec<u8>> {
-
-		/// The type used to enumerate the batch's contents.
-		type Cursor = AbomonatedBatchCursor<K, V, T, R, B>;
-		/// Acquires a cursor to the batch's contents.
-		fn cursor(&self) -> Self::Cursor {
-			AbomonatedBatchCursor::new((&**self).cursor())
-		}
-
-		/// 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() }
-	}
-
-	/// 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)>,
-	    cursor: B::Cursor,
-	}
-
-	impl<K, V, T, R, B: BatchReader<K, V, T, R>> AbomonatedBatchCursor<K, V, T, R, 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> {
-
-	    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 map_times<L: FnMut(&T, &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 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 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>;
-	}
-
-	/// Wrapper type for batching reference counted batches.
-	pub struct AbomonatedBatcher<K,V,T,R,B:Batch<K,V,T,R>> { batcher: B::Batcher }
-
-	/// Functionality for collecting and batching updates.
-	impl<K,V,T,R,B:Batch<K,V,T,R>+Abomonation> Batcher<K, V, T, R, Abomonated<B,Vec<u8>>> for AbomonatedBatcher<K,V,T,R,B> {
-		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>> {
-			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() }
-	}
-
-	/// Wrapper type for building reference counted batches.
-	pub struct AbomonatedBuilder<K,V,T,R,B:Batch<K,V,T,R>> { builder: B::Builder }
-
-	/// Functionality for building batches from ordered update sequences.
-	impl<K,V,T,R,B:Batch<K,V,T,R>+Abomonation> Builder<K, V, T, R, Abomonated<B,Vec<u8>>> for AbomonatedBuilder<K,V,T,R,B> {
-		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>> {
-			let batch = self.builder.done(lower, upper, since);
-			let mut bytes = Vec::with_capacity(measure(&batch));
-			unsafe { abomonation::encode(&batch, &mut bytes).unwrap() };
-			unsafe { Abomonated::<B,_>::new(bytes).unwrap() }
-		}
-	}
-
-	/// Wrapper type for merging reference counted batches.
-	pub struct AbomonatedMerger<K,V,T,R,B:Batch<K,V,T,R>> { merger: B::Merger }
-
-	/// Represents a merge in progress.
-	impl<K,V,T,R,B:Batch<K,V,T,R>+Abomonation> Merger<K, V, T, R, Abomonated<B,Vec<u8>>> for AbomonatedMerger<K,V,T,R,B> {
-		fn new(source1: &Abomonated<B,Vec<u8>>, source2: &Abomonated<B,Vec<u8>>, compaction_frontier: Option<AntichainRef<T>>) -> Self {
-			AbomonatedMerger { merger: B::begin_merge(source1, source2, compaction_frontier) }
-		}
-		fn work(&mut self, source1: &Abomonated<B,Vec<u8>>, source2: &Abomonated<B,Vec<u8>>, fuel: &mut isize) {
-			self.merger.work(source1, source2, fuel)
-		}
-		fn done(self) -> Abomonated<B, Vec<u8>> {
-			let batch = self.merger.done();
-			let mut bytes = Vec::with_capacity(measure(&batch));
-			unsafe { abomonation::encode(&batch, &mut bytes).unwrap() };
-			unsafe { Abomonated::<B,_>::new(bytes).unwrap() }
-		}
-	}
+    extern crate abomonation;
+
+    use abomonation::{Abomonation, measure};
+    use abomonation::abomonated::Abomonated;
+    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>+Abomonation> BatchReader<K,V,T,R> for Abomonated<B, Vec<u8>> {
+
+        /// The type used to enumerate the batch's contents.
+        type Cursor = AbomonatedBatchCursor<K, V, T, R, B>;
+        /// Acquires a cursor to the batch's contents.
+        fn cursor(&self) -> Self::Cursor {
+            AbomonatedBatchCursor::new((&**self).cursor())
+        }
+
+        /// 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() }
+    }
+
+    /// 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)>,
+        cursor: B::Cursor,
+    }
+
+    impl<K, V, T, R, B: BatchReader<K, V, T, R>> AbomonatedBatchCursor<K, V, T, R, 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> {
+
+        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 map_times<L: FnMut(&T, &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 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 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>;
+    }
+
+    /// Wrapper type for batching reference counted batches.
+    pub struct AbomonatedBatcher<K,V,T,R,B:Batch<K,V,T,R>> { batcher: B::Batcher }
+
+    /// Functionality for collecting and batching updates.
+    impl<K,V,T,R,B:Batch<K,V,T,R>+Abomonation> Batcher<K, V, T, R, Abomonated<B,Vec<u8>>> for AbomonatedBatcher<K,V,T,R,B> {
+        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>> {
+            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() }
+    }
+
+    /// Wrapper type for building reference counted batches.
+    pub struct AbomonatedBuilder<K,V,T,R,B:Batch<K,V,T,R>> { builder: B::Builder }
+
+    /// Functionality for building batches from ordered update sequences.
+    impl<K,V,T,R,B:Batch<K,V,T,R>+Abomonation> Builder<K, V, T, R, Abomonated<B,Vec<u8>>> for AbomonatedBuilder<K,V,T,R,B> {
+        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>> {
+            let batch = self.builder.done(lower, upper, since);
+            let mut bytes = Vec::with_capacity(measure(&batch));
+            unsafe { abomonation::encode(&batch, &mut bytes).unwrap() };
+            unsafe { Abomonated::<B,_>::new(bytes).unwrap() }
+        }
+    }
+
+    /// Wrapper type for merging reference counted batches.
+    pub struct AbomonatedMerger<K,V,T,R,B:Batch<K,V,T,R>> { merger: B::Merger }
+
+    /// Represents a merge in progress.
+    impl<K,V,T,R,B:Batch<K,V,T,R>+Abomonation> Merger<K, V, T, R, Abomonated<B,Vec<u8>>> for AbomonatedMerger<K,V,T,R,B> {
+        fn new(source1: &Abomonated<B,Vec<u8>>, source2: &Abomonated<B,Vec<u8>>, compaction_frontier: Option<AntichainRef<T>>) -> Self {
+            AbomonatedMerger { merger: B::begin_merge(source1, source2, compaction_frontier) }
+        }
+        fn work(&mut self, source1: &Abomonated<B,Vec<u8>>, source2: &Abomonated<B,Vec<u8>>, fuel: &mut isize) {
+            self.merger.work(source1, source2, fuel)
+        }
+        fn done(self) -> Abomonated<B, Vec<u8>> {
+            let batch = self.merger.done();
+            let mut bytes = Vec::with_capacity(measure(&batch));
+            unsafe { abomonation::encode(&batch, &mut bytes).unwrap() };
+            unsafe { Abomonated::<B,_>::new(bytes).unwrap() }
+        }
+    }
 }