--- a/src/shard_merge.rs	Mon Feb 01 20:41:25 2016 +0000
+++ b/src/shard_merge.rs	Mon Feb 01 20:41:45 2016 +0000
@@ -9,8 +9,8 @@
 /// This type uses dynamic instead of static dispatch because it realizes an arbitrary structure
 /// and can therefore not work with a single type signature.
 pub struct ShardMergeIterator<'a, T: PartialOrd> {
-    left: Box<Iterator<Item=T> + 'a>,
-    right: Box<Iterator<Item=T> + 'a>,
+    left: Box<Iterator<Item = T> + 'a>,
+    right: Box<Iterator<Item = T> + 'a>,
 
     left_peeked: Option<T>,
     right_peeked: Option<T>,
@@ -21,24 +21,33 @@
     fn next(&mut self) -> Option<Self::Item> {
         // fill up
         match (self.left_peeked.clone(), self.right_peeked.clone()) {
-            (None, None) => { self.left_peeked = self.left.next(); self.right_peeked = self.right.next() },
+            (None, None) => {
+                self.left_peeked = self.left.next();
+                self.right_peeked = self.right.next()
+            }
             (Some(_), None) => self.right_peeked = self.right.next(),
             (None, Some(_)) => self.left_peeked = self.left.next(),
-            (Some(_), Some(_)) => ()
+            (Some(_), Some(_)) => (),
         }
 
         // Consume peeked values
         match (self.left_peeked.clone(), self.right_peeked.clone()) {
-            (None, None) => { return None },
-            (l @ Some(_), None) => { self.left_peeked = None; return l },
-            (None, r @ Some(_)) => { self.right_peeked = None; return r },
+            (None, None) => return None,
+            (l @ Some(_), None) => {
+                self.left_peeked = None;
+                return l;
+            }
+            (None, r @ Some(_)) => {
+                self.right_peeked = None;
+                return r;
+            }
             (l @ Some(_), r @ Some(_)) => {
                 if l <= r {
                     self.left_peeked = None;
-                    return l
+                    return l;
                 } else {
                     self.right_peeked = None;
-                    return r
+                    return r;
                 }
             }
         }
@@ -46,7 +55,9 @@
 }
 
 impl<'a, T: PartialOrd + Clone> ShardMergeIterator<'a, T> {
-    fn default() -> ShardMergeIterator<'a, T> where T: 'a {
+    fn default() -> ShardMergeIterator<'a, T>
+        where T: 'a
+    {
         ShardMergeIterator {
             left: Box::new(iter::empty()),
             right: Box::new(iter::empty()),
@@ -56,43 +67,68 @@
     }
     /// Takes multiple iterators of type It and generates one ShardedMergeIterator..
     /// (yes, iterator over a collection of iterators).
-    pub fn build<It: Iterator<Item=T>, ItIt: Iterator<Item=It>>(sources: &mut ItIt) -> ShardMergeIterator<'a, T>
-        where T: 'a, It: 'a {
-            let mut merged: Vec<ShardMergeIterator<T>> = Vec::new();
+    pub fn build<It: Iterator<Item = T>, ItIt: Iterator<Item = It>>(sources: &mut ItIt)
+                                                                    -> ShardMergeIterator<'a, T>
+        where T: 'a,
+              It: 'a
+    {
+        let mut merged: Vec<ShardMergeIterator<T>> = Vec::new();
 
-            // Initial merging: Merge pairs of input iterators together.
-            loop {
-                let src1: It;
-                match sources.next() {
-                    None => break,
-                    Some(src) => src1 = src,
+        // Initial merging: Merge pairs of input iterators together.
+        loop {
+            let src1: It;
+            match sources.next() {
+                None => break,
+                Some(src) => src1 = src,
+            }
+            match sources.next() {
+                None => {
+                    merged.push(ShardMergeIterator {
+                        left: Box::new(src1),
+                        right: Box::new(iter::empty()),
+                        ..ShardMergeIterator::default()
+                    })
                 }
-                match sources.next() {
-                    None => merged.push(ShardMergeIterator { left: Box::new(src1), right: Box::new(iter::empty()), .. ShardMergeIterator::default() }),
-                    Some(src) => merged.push(ShardMergeIterator { left: Box::new(src1), right: Box::new(src), .. ShardMergeIterator::default() }),
+                Some(src) => {
+                    merged.push(ShardMergeIterator {
+                        left: Box::new(src1),
+                        right: Box::new(src),
+                        ..ShardMergeIterator::default()
+                    })
                 }
             }
+        }
 
-            // Recursively build the merge tree from the leaves.
-            ShardMergeIterator::merge(merged)
+        // Recursively build the merge tree from the leaves.
+        ShardMergeIterator::merge(merged)
     }
 
     /// Merge multiple ShardMergeIterators, recursively (meaning it will result in a more or less
     /// balanced merge sort tree).
-    fn merge(mut its: Vec<ShardMergeIterator<'a, T>>) -> ShardMergeIterator<'a, T> where T: 'a {
+    fn merge(mut its: Vec<ShardMergeIterator<'a, T>>) -> ShardMergeIterator<'a, T>
+        where T: 'a
+    {
         if its.len() == 0 {
             ShardMergeIterator::default()
         } else if its.len() == 1 {
-            ShardMergeIterator { left: Box::new(its.remove(0)), .. ShardMergeIterator::default() }
+            ShardMergeIterator { left: Box::new(its.remove(0)), ..ShardMergeIterator::default() }
         } else if its.len() == 2 {
             let it1 = its.remove(0);
             let it2 = its.remove(0);
-            ShardMergeIterator { left: Box::new(it1), right: Box::new(it2), ..ShardMergeIterator::default() }
+            ShardMergeIterator {
+                left: Box::new(it1),
+                right: Box::new(it2),
+                ..ShardMergeIterator::default()
+            }
         } else {
             // its is left part, right is right part
             let split_at = its.len() / 2;
             let right = its.split_off(split_at);
-            ShardMergeIterator { left: Box::new(ShardMergeIterator::merge(its)), right: Box::new(ShardMergeIterator::merge(right)), .. ShardMergeIterator::default() }
+            ShardMergeIterator {
+                left: Box::new(ShardMergeIterator::merge(its)),
+                right: Box::new(ShardMergeIterator::merge(right)),
+                ..ShardMergeIterator::default()
+            }
         }
     }
 }
@@ -123,8 +159,13 @@
 
     #[test]
     fn test_merge_iterator() {
-        let it = ShardMergeIterator::build(&mut vec![get_collection_1(), get_collection_2(), get_collection_3(),
-            get_collection_4(), get_collection_5(), get_collection_6()].into_iter());
+        let it = ShardMergeIterator::build(&mut vec![get_collection_1(),
+                                                     get_collection_2(),
+                                                     get_collection_3(),
+                                                     get_collection_4(),
+                                                     get_collection_5(),
+                                                     get_collection_6()]
+                                                    .into_iter());
         let mut cmp = 0;
         let mut cnt = 0;
 
@@ -134,7 +175,9 @@
             cnt += 1;
         }
 
-        assert_eq!(cnt, get_collection_1().len()+get_collection_2().len()+get_collection_3().len()+
-                   get_collection_4().len()+get_collection_5().len()+get_collection_6().len());
+        assert_eq!(cnt,
+                   get_collection_1().len() + get_collection_2().len() +
+                   get_collection_3().len() + get_collection_4().len() +
+                   get_collection_5().len() + get_collection_6().len());
     }
 }