diff --git a/src/common/composite_file.rs b/src/common/composite_file.rs
index 39db0bbcb..60f9286df 100644
--- a/src/common/composite_file.rs
+++ b/src/common/composite_file.rs
@@ -3,11 +3,14 @@ use common::CountingWriter;
 use std::collections::HashMap;
 use schema::Field;
 use common::VInt;
+use directory::WritePtr;
 use std::io;
 use directory::ReadOnlySource;
 use common::BinarySerializable;
 
-pub struct CompositeWrite<W: Write> {
+
+
+pub struct CompositeWrite<W=WritePtr> {
     write: CountingWriter<W>,
     offsets: HashMap<Field, usize>,
 }
diff --git a/src/common/counting_writer.rs b/src/common/counting_writer.rs
index db13e368f..d9ea877d2 100644
--- a/src/common/counting_writer.rs
+++ b/src/common/counting_writer.rs
@@ -2,7 +2,7 @@ use std::io::Write;
 use std::io;
 
 
-pub struct CountingWriter<W: Write> {
+pub struct CountingWriter<W> {
     underlying: W,
     written_bytes: usize,
 }
diff --git a/src/core/searcher.rs b/src/core/searcher.rs
index eeac26072..e8e54475a 100644
--- a/src/core/searcher.rs
+++ b/src/core/searcher.rs
@@ -71,6 +71,8 @@ impl Searcher {
         query.search(self, collector)
     }
 
+
+    // This API may change in the future.
     pub fn field(&self, field: Field) -> Result<FieldSearcher> {
         let field_readers = self.segment_readers
             .iter()
@@ -84,6 +86,7 @@ impl Searcher {
 
 
 
+
 pub struct FieldSearcher {
     field_readers: Vec<Arc<FieldReader>>,
 }
diff --git a/src/fastfield/mod.rs b/src/fastfield/mod.rs
index fc69f6ddf..cce503f21 100644
--- a/src/fastfield/mod.rs
+++ b/src/fastfield/mod.rs
@@ -85,7 +85,7 @@ mod tests {
         let mut directory: RAMDirectory = RAMDirectory::create();
         {
             let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::new(write).unwrap();
+            let mut serializer = FastFieldSerializer::from_write(write).unwrap();
             let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
             add_single_field_doc(&mut fast_field_writers, *FIELD, 13u64);
             add_single_field_doc(&mut fast_field_writers, *FIELD, 14u64);
@@ -114,7 +114,7 @@ mod tests {
         let mut directory: RAMDirectory = RAMDirectory::create();
         {
             let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::new(write).unwrap();
+            let mut serializer = FastFieldSerializer::from_write(write).unwrap();
             let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
             add_single_field_doc(&mut fast_field_writers, *FIELD, 4u64);
             add_single_field_doc(&mut fast_field_writers, *FIELD, 14_082_001u64);
@@ -156,7 +156,7 @@ mod tests {
 
         {
             let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::new(write).unwrap();
+            let mut serializer = FastFieldSerializer::from_write(write).unwrap();
             let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
             for _ in 0..10_000 {
                 add_single_field_doc(&mut fast_field_writers, *FIELD, 100_000u64);
@@ -185,7 +185,7 @@ mod tests {
 
         {
             let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::new(write).unwrap();
+            let mut serializer = FastFieldSerializer::from_write(write).unwrap();
             let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
             // forcing the amplitude to be high
             add_single_field_doc(&mut fast_field_writers, *FIELD, 0u64);
@@ -224,7 +224,7 @@ mod tests {
         let schema = schema_builder.build();
         {
             let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::new(write).unwrap();
+            let mut serializer = FastFieldSerializer::from_write(write).unwrap();
             let mut fast_field_writers = FastFieldsWriter::from_schema(&schema);
             for i in -100i64..10_000i64 {
                 let mut doc = Document::default();
@@ -266,7 +266,7 @@ mod tests {
 
         {
             let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::new(write).unwrap();
+            let mut serializer = FastFieldSerializer::from_write(write).unwrap();
             let mut fast_field_writers = FastFieldsWriter::from_schema(&schema);
             let doc = Document::default();
             fast_field_writers.add_document(&doc);
@@ -300,7 +300,7 @@ mod tests {
         let mut directory = RAMDirectory::create();
         {
             let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::new(write).unwrap();
+            let mut serializer = FastFieldSerializer::from_write(write).unwrap();
             let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
             for x in &permutation {
                 add_single_field_doc(&mut fast_field_writers, *FIELD, *x);
@@ -355,7 +355,7 @@ mod tests {
         let mut directory: RAMDirectory = RAMDirectory::create();
         {
             let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::new(write).unwrap();
+            let mut serializer = FastFieldSerializer::from_write(write).unwrap();
             let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
             for x in &permutation {
                 add_single_field_doc(&mut fast_field_writers, *FIELD, *x);
@@ -388,7 +388,7 @@ mod tests {
         let mut directory: RAMDirectory = RAMDirectory::create();
         {
             let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::new(write).unwrap();
+            let mut serializer = FastFieldSerializer::from_write(write).unwrap();
             let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
             for x in &permutation {
                 add_single_field_doc(&mut fast_field_writers, *FIELD, *x);
diff --git a/src/fastfield/reader.rs b/src/fastfield/reader.rs
index b67510524..cdec175e2 100644
--- a/src/fastfield/reader.rs
+++ b/src/fastfield/reader.rs
@@ -137,7 +137,7 @@ impl From<Vec<u64>> for U64FastFieldReader {
         let mut directory: RAMDirectory = RAMDirectory::create();
         {
             let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::new(write).unwrap();
+            let mut serializer = FastFieldSerializer::from_write(write).unwrap();
             let mut fast_field_writers = FastFieldsWriter::from_schema(&schema);
             for val in vals {
                 let mut fast_field_writer = fast_field_writers.get_field_writer(field).unwrap();
diff --git a/src/fastfield/serializer.rs b/src/fastfield/serializer.rs
index 62dd7cba1..ce2184fde 100644
--- a/src/fastfield/serializer.rs
+++ b/src/fastfield/serializer.rs
@@ -31,8 +31,10 @@ pub struct FastFieldSerializer {
 }
 
 impl FastFieldSerializer {
+
+
     /// Constructor
-    pub fn new(write: WritePtr) -> io::Result<FastFieldSerializer> {
+    pub fn from_write(write: WritePtr) -> io::Result<FastFieldSerializer> {
         // just making room for the pointer to header.
         let composite_write = CompositeWrite::wrap(write);
         Ok(FastFieldSerializer {
diff --git a/src/indexer/segment_serializer.rs b/src/indexer/segment_serializer.rs
index 76190bd9b..719c98c14 100644
--- a/src/indexer/segment_serializer.rs
+++ b/src/indexer/segment_serializer.rs
@@ -21,10 +21,10 @@ impl SegmentSerializer {
         let store_write = try!(segment.open_write(SegmentComponent::STORE));
 
         let fast_field_write = try!(segment.open_write(SegmentComponent::FASTFIELDS));
-        let fast_field_serializer = try!(FastFieldSerializer::new(fast_field_write));
+        let fast_field_serializer = try!(FastFieldSerializer::from_write(fast_field_write));
 
         let fieldnorms_write = try!(segment.open_write(SegmentComponent::FIELDNORMS));
-        let fieldnorms_serializer = try!(FastFieldSerializer::new(fieldnorms_write));
+        let fieldnorms_serializer = try!(FastFieldSerializer::from_write(fieldnorms_write));
 
         let postings_serializer = try!(InvertedIndexSerializer::open(segment));
         Ok(SegmentSerializer {
diff --git a/src/postings/serializer.rs b/src/postings/serializer.rs
index 76c1f1f6b..410226e7a 100644
--- a/src/postings/serializer.rs
+++ b/src/postings/serializer.rs
@@ -76,11 +76,10 @@ impl InvertedIndexSerializer {
     pub fn open(segment: &mut Segment) -> Result<InvertedIndexSerializer> {
         use SegmentComponent::{TERMS, POSTINGS, POSITIONS};
         InvertedIndexSerializer::new(
-            CompositeWrite::wrap(
-                segment.open_write(TERMS)?),
-                CompositeWrite::wrap(segment.open_write(POSTINGS)?),
-                CompositeWrite::wrap(segment.open_write(POSITIONS)?),
-                segment.schema())
+            CompositeWrite::wrap(segment.open_write(TERMS)?),
+            CompositeWrite::wrap(segment.open_write(POSTINGS)?),
+            CompositeWrite::wrap(segment.open_write(POSITIONS)?),
+            segment.schema())
     }
 
     /// Must be called before starting pushing terms of
diff --git a/src/termdict/mod.rs b/src/termdict/mod.rs
index f045eb1f7..03a4ac0af 100644
--- a/src/termdict/mod.rs
+++ b/src/termdict/mod.rs
@@ -95,7 +95,6 @@ mod streamdict;
 pub use self::streamdict::{TermDictionaryImpl, TermDictionaryBuilderImpl, TermStreamerImpl,
                            TermStreamerBuilderImpl};
 
-
 mod merger;
 use std::io;
 
@@ -325,7 +324,6 @@ mod tests {
             term_string.push_str(term.text());
         }
         assert_eq!(&*term_string, "abcdef");
-
     }