diff --git a/src/core/index.rs b/src/core/index.rs
index 50740281f..936087dd5 100644
--- a/src/core/index.rs
+++ b/src/core/index.rs
@@ -184,15 +184,10 @@ impl Index {
     /// Returns the list of segments that are searchable
     pub fn searchable_segments(&self) -> Result<Vec<Segment>> {
         let metas = load_metas(self.directory())?; 
-        let searchable_segment_ids = metas
+        Ok(metas
             .committed_segments
             .iter()
-            .map(|segment_meta| segment_meta.segment_id)
-            .collect::<Vec<_>>();
-        let commit_opstamp = metas.opstamp;
-        Ok(searchable_segment_ids
-            .into_iter()
-            .map(|segment_id| self.segment(segment_id, commit_opstamp))
+            .map(|segment_meta| self.segment(segment_meta))
             .collect())
     }
     
@@ -208,8 +203,17 @@ impl Index {
     /// Return a segment object given a `segment_id`
     ///
     /// The segment may or may not exist.
-    pub fn segment(&self, segment_id: SegmentId, opstamp: u64) -> Segment {
-        create_segment(self.clone(), segment_id, opstamp)
+    // pub fn segment(&self, segment_id: SegmentId, opstamp: u64) -> Segment {
+    //     (self.clone(), segment_id, opstamp)
+    // }
+
+    pub fn segment(&self, segment_meta: &SegmentMeta) -> Segment {
+        create_segment(self.clone(), segment_meta.segment_id, segment_meta.opstamp)
+    }
+
+    /// Creates a new segment.
+    pub fn new_segment(&self, opstamp: u64) -> Segment {
+        create_segment(self.clone(), SegmentId::generate_random(), opstamp)
     }
 
     /// Return a reference to the index directory.
@@ -225,7 +229,6 @@ impl Index {
     /// Reads the meta.json and returns the list of
     /// committed segments.
     pub fn committed_segments(&self) -> Result<Vec<SegmentMeta>> {
-        
         Ok(load_metas(self.directory())?.committed_segments)
     }
     
@@ -238,11 +241,6 @@ impl Index {
             .collect())           
     }
 
-    /// Creates a new segment.
-    pub fn new_segment(&self, opstamp: u64) -> Segment {
-        self.segment(SegmentId::generate_random(), opstamp)
-    }
-
     /// Creates a new generation of searchers after
     /// a change of the set of searchable indexes.
     ///
diff --git a/src/indexer/segment_manager.rs b/src/indexer/segment_manager.rs
index 10ee89486..af180e2b3 100644
--- a/src/indexer/segment_manager.rs
+++ b/src/indexer/segment_manager.rs
@@ -101,7 +101,7 @@ impl SegmentManager {
         segment_ids
     }
 
-    pub fn commit(&self, docstamp: u64) {
+    pub fn commit(&self) {
         let mut registers_lock = self.write();
         let segment_entries = registers_lock.uncommitted.segment_entries();
         for segment_entry in segment_entries {
diff --git a/src/indexer/segment_register.rs b/src/indexer/segment_register.rs
index 4c838bf63..eb28ae5c4 100644
--- a/src/indexer/segment_register.rs
+++ b/src/indexer/segment_register.rs
@@ -157,14 +157,15 @@ impl SegmentRegister {
     } 
     
     pub fn new(segment_metas: Vec<SegmentMeta>, delete_cursor: DeleteQueueCursor) -> SegmentRegister {
-        let mut segment_states = HashMap::new();
-        for segment_meta in segment_metas {
-            let segment_id = segment_meta.segment_id;
-            let segment_entry = SegmentEntry::new(segment_meta, delete_cursor.clone());
-            segment_states.insert(segment_id, segment_entry);
-        }
         SegmentRegister {
-            segment_states: segment_states,
+            segment_states: segment_metas
+                .into_iter()
+                .map(|segment_meta| {
+                    let segment_id = segment_meta.segment_id;
+                    let segment_entry = SegmentEntry::new(segment_meta, delete_cursor.clone());
+                    (segment_id, segment_entry)
+                })
+                .collect(),
         }
     }
 }
diff --git a/src/indexer/segment_updater.rs b/src/indexer/segment_updater.rs
index 9482f9aaa..1c518dc98 100644
--- a/src/indexer/segment_updater.rs
+++ b/src/indexer/segment_updater.rs
@@ -177,7 +177,7 @@ impl SegmentUpdater {
     fn purge_deletes(&self, target_opstamp: u64) -> Result<()> {
         let uncommitted = self.0.segment_manager.segment_entries();
         for mut segment_entry in uncommitted {
-            let mut segment = self.0.index.segment(segment_entry.meta().segment_id, segment_entry.meta().opstamp); 
+            let mut segment = self.0.index.segment(segment_entry.meta()); 
             let (_, deleted_docset) = advance_deletes(
                  &segment,
                  segment_entry.delete_cursor(),
@@ -186,7 +186,6 @@ impl SegmentUpdater {
                 let mut delete_file = segment.with_opstamp(target_opstamp).open_write(SegmentComponent::DELETE)?;
                 write_delete_bitset(&deleted_docset, &mut delete_file)?;
             }
-            
         }
         Ok(())
     }
@@ -194,7 +193,7 @@ impl SegmentUpdater {
     pub fn commit(&self, opstamp: u64) -> impl Future<Item=(), Error=&'static str> {
         self.run_async(move |segment_updater| {
             segment_updater.purge_deletes(opstamp).expect("Failed purge deletes");
-            segment_updater.0.segment_manager.commit(opstamp);
+            segment_updater.0.segment_manager.commit();
             let mut directory = segment_updater.0.index.directory().box_clone();
             save_metas(
                     &segment_updater.0.segment_manager,
@@ -238,7 +237,7 @@ impl SegmentUpdater {
             
             let segments: Vec<Segment> = segment_metas
                 .iter()
-                .map(|ref segment_metas| index.segment(segment_metas.segment_id, segment_metas.opstamp))
+                .map(|ref segment_meta| index.segment(segment_meta))
                 .collect();
             
             // An IndexMerger is like a "view" of our merged segments.