diff --git a/examples/gzbuilder.rs b/examples/gzbuilder.rs
new file mode 100644
index 000000000..a61a03f4f
--- /dev/null
+++ b/examples/gzbuilder.rs
@@ -0,0 +1,24 @@
+extern crate flate2;
+
+use std::io::prelude::*;
+use std::io;
+use std::fs::File;
+use flate2::GzBuilder;
+use flate2::Compression;
+
+// Open file and debug print the contents compressed with gzip
+fn main() {
+    sample_builder().unwrap();
+}
+
+// GzBuilder opens a file and writes a sample string using Builder pattern
+fn sample_builder() -> Result<(), io::Error> {
+    let f = File::create("examples/hello_world.gz")?;
+    let mut gz = GzBuilder::new()
+                 .filename("hello_world.txt")
+                 .comment("test file, please delete")
+                 .write(f, Compression::Default);
+    gz.write(b"hello world")?;
+    gz.finish()?;
+    Ok(())
+}
diff --git a/examples/gzdecoder-bufread.rs b/examples/gzdecoder-bufread.rs
new file mode 100644
index 000000000..77f325194
--- /dev/null
+++ b/examples/gzdecoder-bufread.rs
@@ -0,0 +1,24 @@
+extern crate flate2;
+
+use std::io::prelude::*;
+use std::io;
+use flate2::Compression;
+use flate2::write::GzEncoder;
+use flate2::bufread::GzDecoder;
+
+// Compress a sample string and print it after transformation.
+fn main() {
+    let mut e = GzEncoder::new(Vec::new(), Compression::Default);
+    e.write(b"Hello World").unwrap();
+    let bytes = e.finish().unwrap();
+    println!("{}", decode_reader(bytes).unwrap());
+}
+
+// Uncompresses a Gz Encoded vector of bytes and returns a string or error
+// Here &[u8] implements BufRead
+fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
+    let mut gz = GzDecoder::new(&bytes[..])?;
+    let mut s = String::new();
+    gz.read_to_string(&mut s)?;
+    Ok(s)
+}
diff --git a/examples/gzdecoder-read.rs b/examples/gzdecoder-read.rs
new file mode 100644
index 000000000..843d7bd6a
--- /dev/null
+++ b/examples/gzdecoder-read.rs
@@ -0,0 +1,24 @@
+extern crate flate2;
+
+use std::io::prelude::*;
+use std::io;
+use flate2::Compression;
+use flate2::write::GzEncoder;
+use flate2::read::GzDecoder;
+
+// Compress a sample string and print it after transformation.
+fn main() {
+    let mut e = GzEncoder::new(Vec::new(), Compression::Default);
+    e.write(b"Hello World").unwrap();
+    let bytes = e.finish().unwrap();
+    println!("{}", decode_reader(bytes).unwrap());
+}
+
+// Uncompresses a Gz Encoded vector of bytes and returns a string or error
+// Here &[u8] implements Read
+fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
+    let mut gz = GzDecoder::new(&bytes[..])?;
+    let mut s = String::new();
+    gz.read_to_string(&mut s)?;
+    Ok(s)
+}
diff --git a/examples/gzencoder-bufread.rs b/examples/gzencoder-bufread.rs
new file mode 100644
index 000000000..8b320d813
--- /dev/null
+++ b/examples/gzencoder-bufread.rs
@@ -0,0 +1,24 @@
+extern crate flate2;
+
+use std::io::prelude::*;
+use std::io;
+use flate2::Compression;
+use flate2::bufread::GzEncoder;
+use std::fs::File;
+use std::io::BufReader;
+
+// Open file and debug print the contents compressed with gzip
+fn main() {
+    println!("{:?}", open_hello_world().unwrap());
+}
+
+// Opens sample file, compresses the contents and returns a Vector or error
+// File wrapped in a BufReader implements Bufread
+fn open_hello_world() -> io::Result<Vec<u8>> {
+    let f = File::open("examples/hello_world.txt")?;
+    let b = BufReader::new(f);
+    let mut gz = GzEncoder::new(b, Compression::Fast);
+    let mut buffer = Vec::new();
+    gz.read_to_end(&mut buffer)?;
+    Ok(buffer)
+}
diff --git a/examples/gzencoder-read.rs b/examples/gzencoder-read.rs
new file mode 100644
index 000000000..65dd26bc4
--- /dev/null
+++ b/examples/gzencoder-read.rs
@@ -0,0 +1,20 @@
+extern crate flate2;
+
+use std::io::prelude::*;
+use std::io;
+use flate2::Compression;
+use flate2::read::GzEncoder;
+
+// Print the GZ compressed representation of hello world
+fn main() {
+    println!("{:?}", gzencoder_read_hello_world().unwrap());
+}
+
+// Return a vector containing the GZ compressed version of hello world
+fn gzencoder_read_hello_world() -> io::Result<Vec<u8>> {
+    let mut ret_vec = [0;100];
+    let c = b"hello world";
+    let mut z = GzEncoder::new(&c[..], Compression::Fast);
+    let count = z.read(&mut ret_vec)?;
+    Ok(ret_vec[0..count].to_vec())
+}
diff --git a/examples/gzencoder-write.rs b/examples/gzencoder-write.rs
new file mode 100644
index 000000000..b423b5241
--- /dev/null
+++ b/examples/gzencoder-write.rs
@@ -0,0 +1,12 @@
+extern crate flate2;
+
+use std::io::prelude::*;
+use flate2::Compression;
+use flate2::write::GzEncoder;
+
+// Vec<u8> implements Write to print the compressed bytes of sample string
+fn main() {
+    let mut e = GzEncoder::new(Vec::new(), Compression::Default);
+    e.write(b"Hello World").unwrap();
+    println!("{:?}", e.finish().unwrap());
+}
diff --git a/examples/gzmultidecoder-bufread.rs b/examples/gzmultidecoder-bufread.rs
new file mode 100644
index 000000000..d5db3673e
--- /dev/null
+++ b/examples/gzmultidecoder-bufread.rs
@@ -0,0 +1,24 @@
+extern crate flate2;
+
+use std::io::prelude::*;
+use std::io;
+use flate2::Compression;
+use flate2::write::GzEncoder;
+use flate2::bufread::MultiGzDecoder;
+
+// Compress a sample string and print it after transformation.
+fn main() {
+    let mut e = GzEncoder::new(Vec::new(), Compression::Default);
+    e.write(b"Hello World").unwrap();
+    let bytes = e.finish().unwrap();
+    println!("{}", decode_reader(bytes).unwrap());
+}
+
+// Uncompresses a Gz Encoded vector of bytes and returns a string or error
+// Here &[u8] implements BufRead
+fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
+    let mut gz = MultiGzDecoder::new(&bytes[..])?;
+    let mut s = String::new();
+    gz.read_to_string(&mut s)?;
+    Ok(s)
+}
diff --git a/examples/gzmultidecoder-read.rs b/examples/gzmultidecoder-read.rs
new file mode 100644
index 000000000..9263292c9
--- /dev/null
+++ b/examples/gzmultidecoder-read.rs
@@ -0,0 +1,24 @@
+extern crate flate2;
+
+use std::io::prelude::*;
+use std::io;
+use flate2::Compression;
+use flate2::write::GzEncoder;
+use flate2::read::MultiGzDecoder;
+
+// Compress a sample string and print it after transformation.
+fn main() {
+    let mut e = GzEncoder::new(Vec::new(), Compression::Default);
+    e.write(b"Hello World").unwrap();
+    let bytes = e.finish().unwrap();
+    println!("{}", decode_reader(bytes).unwrap());
+}
+
+// Uncompresses a Gz Encoded vector of bytes and returns a string or error
+// Here &[u8] implements Read
+fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
+    let mut gz = MultiGzDecoder::new(&bytes[..])?;
+    let mut s = String::new();
+    gz.read_to_string(&mut s)?;
+    Ok(s)
+}
diff --git a/examples/hello_world.txt b/examples/hello_world.txt
new file mode 100644
index 000000000..557db03de
--- /dev/null
+++ b/examples/hello_world.txt
@@ -0,0 +1 @@
+Hello World
diff --git a/examples/zlibdecoder-bufread.rs b/examples/zlibdecoder-bufread.rs
new file mode 100644
index 000000000..7216f801e
--- /dev/null
+++ b/examples/zlibdecoder-bufread.rs
@@ -0,0 +1,24 @@
+extern crate flate2;
+
+use std::io::prelude::*;
+use std::io;
+use flate2::Compression;
+use flate2::write::ZlibEncoder;
+use flate2::bufread::ZlibDecoder;
+
+// Compress a sample string and print it after transformation.
+fn main() {
+    let mut e = ZlibEncoder::new(Vec::new(), Compression::Default);
+    e.write(b"Hello World").unwrap();
+    let bytes = e.finish().unwrap();
+    println!("{}", decode_bufreader(bytes).unwrap());
+}
+
+// Uncompresses a Zlib Encoded vector of bytes and returns a string or error
+// Here &[u8] implements BufRead
+fn decode_bufreader(bytes: Vec<u8>) -> io::Result<String> {
+    let mut z = ZlibDecoder::new(&bytes[..]);
+    let mut s = String::new();
+    z.read_to_string(&mut s)?;
+    Ok(s)
+}
diff --git a/examples/zlibdecoder-read.rs b/examples/zlibdecoder-read.rs
new file mode 100644
index 000000000..ab82413fb
--- /dev/null
+++ b/examples/zlibdecoder-read.rs
@@ -0,0 +1,24 @@
+extern crate flate2;
+
+use std::io::prelude::*;
+use std::io;
+use flate2::Compression;
+use flate2::write::ZlibEncoder;
+use flate2::read::ZlibDecoder;
+
+// Compress a sample string and print it after transformation.
+fn main() {
+    let mut e = ZlibEncoder::new(Vec::new(), Compression::Default);
+    e.write(b"Hello World").unwrap();
+    let bytes = e.finish().unwrap();
+    println!("{}", decode_reader(bytes).unwrap());
+}
+
+// Uncompresses a Zlib Encoded vector of bytes and returns a string or error
+// Here &[u8] implements Read
+fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
+    let mut z = ZlibDecoder::new(&bytes[..]);
+    let mut s = String::new();
+    z.read_to_string(&mut s)?;
+    Ok(s)
+}
diff --git a/examples/zlibdecoder-write.rs b/examples/zlibdecoder-write.rs
new file mode 100644
index 000000000..c70ded3c1
--- /dev/null
+++ b/examples/zlibdecoder-write.rs
@@ -0,0 +1,26 @@
+extern crate flate2;
+
+use std::io::prelude::*;
+use std::io;
+use flate2::Compression;
+use flate2::write::ZlibEncoder;
+use flate2::write::ZlibDecoder;
+
+// Compress a sample string and print it after transformation.
+fn main() {
+    let mut e = ZlibEncoder::new(Vec::new(), Compression::Default);
+    e.write(b"Hello World").unwrap();
+    let bytes = e.finish().unwrap();
+    println!("{}", decode_reader(bytes).unwrap());
+}
+
+// Uncompresses a Zlib Encoded vector of bytes and returns a string or error
+// Here Vec<u8> implements Write
+fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
+    let mut writer = Vec::new();
+    let mut z = ZlibDecoder::new(writer);
+    z.write(&bytes[..])?;
+    writer = z.finish()?;
+    let return_string = String::from_utf8(writer).expect("String parsing error");
+    Ok(return_string)
+}
diff --git a/examples/zlibencoder-bufread.rs b/examples/zlibencoder-bufread.rs
new file mode 100644
index 000000000..39d93611a
--- /dev/null
+++ b/examples/zlibencoder-bufread.rs
@@ -0,0 +1,24 @@
+extern crate flate2;
+
+use std::io::prelude::*;
+use std::io;
+use flate2::Compression;
+use flate2::bufread::ZlibEncoder;
+use std::fs::File;
+use std::io::BufReader;
+
+// Open file and debug print the contents compressed with zlib
+fn main() {
+    println!("{:?}", open_hello_world().unwrap());
+}
+
+// Opens sample file, compresses the contents and returns a Vector or error
+// File wrapped in a BufReader implements Bufread
+fn open_hello_world() -> io::Result<Vec<u8>> {
+    let f = File::open("examples/hello_world.txt")?;
+    let b = BufReader::new(f);
+    let mut z = ZlibEncoder::new(b, Compression::Fast);
+    let mut buffer = Vec::new();
+    z.read_to_end(&mut buffer)?;
+    Ok(buffer)
+}
diff --git a/examples/zlibencoder-read.rs b/examples/zlibencoder-read.rs
new file mode 100644
index 000000000..3aef92ca4
--- /dev/null
+++ b/examples/zlibencoder-read.rs
@@ -0,0 +1,21 @@
+extern crate flate2;
+
+use std::io::prelude::*;
+use flate2::Compression;
+use flate2::read::ZlibEncoder;
+use std::fs::File;
+
+// Open file and debug print the compressed contents
+fn main() {
+    println!("{:?}", open_hello_world().unwrap());
+}
+
+// Opens sample file, compresses the contents and returns a Vector or error
+// File implements Read
+fn open_hello_world() -> std::io::Result<Vec<u8>> {
+    let f = File::open("examples/hello_world.txt")?;
+    let mut z = ZlibEncoder::new(f, Compression::Fast);
+    let mut buffer = [0;50];
+    let byte_count = z.read(&mut buffer)?;
+    Ok(buffer[0..byte_count].to_vec())
+}
diff --git a/examples/zlibencoder-write.rs b/examples/zlibencoder-write.rs
new file mode 100644
index 000000000..9152b30ea
--- /dev/null
+++ b/examples/zlibencoder-write.rs
@@ -0,0 +1,12 @@
+extern crate flate2;
+
+use std::io::prelude::*;
+use flate2::Compression;
+use flate2::write::ZlibEncoder;
+
+// Vec<u8> implements Write to print the compressed bytes of sample string
+fn main() {
+    let mut e = ZlibEncoder::new(Vec::new(), Compression::Default);
+    e.write(b"Hello World").unwrap();
+    println!("{:?}", e.finish().unwrap());
+}
diff --git a/src/gz.rs b/src/gz.rs
index 7976c51e5..2f26d96f2 100644
--- a/src/gz.rs
+++ b/src/gz.rs
@@ -32,6 +32,22 @@ static FCOMMENT: u8 = 1 << 4;
 /// to the underlying writer `W`.
 ///
 /// [`Write`]: https://doc.rust-lang.org/std/io/trait.Write.html
+///
+/// # Examples
+///
+/// ```
+/// use std::io::prelude::*;
+/// use flate2::Compression;
+/// use flate2::write::GzEncoder;
+///
+/// // Vec<u8> implements Write to print the compressed bytes of sample string
+/// # fn main() {
+///
+/// let mut e = GzEncoder::new(Vec::new(), Compression::Default);
+/// e.write(b"Hello World").unwrap();
+/// println!("{:?}", e.finish().unwrap());
+/// # }
+/// ```
 #[derive(Debug)]
 pub struct EncoderWriter<W: Write> {
     inner: zio::Writer<W, Compress>,
@@ -47,6 +63,25 @@ pub struct EncoderWriter<W: Write> {
 /// interface.
 ///
 /// [`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html
+///
+/// # Examples
+///
+/// ```
+/// use std::io::prelude::*;
+/// use std::io;
+/// use flate2::Compression;
+/// use flate2::read::GzEncoder;
+///
+/// // Return a vector containing the GZ compressed version of hello world
+///
+/// fn gzencode_hello_world() -> io::Result<Vec<u8>> {
+///     let mut ret_vec = [0;100];
+///     let bytestring = b"hello world";
+///     let mut gz = GzEncoder::new(&bytestring[..], Compression::Fast);
+///     let count = gz.read(&mut ret_vec)?;
+///     Ok(ret_vec[0..count].to_vec())
+/// }
+/// ```
 #[derive(Debug)]
 pub struct EncoderReader<R> {
     inner: EncoderReaderBuf<BufReader<R>>,
@@ -54,11 +89,34 @@ pub struct EncoderReader<R> {
 
 /// A gzip streaming encoder
 ///
-/// This structure exposes a [`Read`] interface that will read uncompressed data
-/// from the underlying reader and expose the compressed version as a [`Read`]
+/// This structure exposes a [`BufRead`] interface that will read uncompressed data
+/// from the underlying reader and expose the compressed version as a [`BufRead`]
 /// interface.
 ///
-/// [`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html
+/// [`BufRead`]: https://doc.rust-lang.org/std/io/trait.BufRead.html
+///
+/// # Examples
+///
+/// ```
+/// use std::io::prelude::*;
+/// use std::io;
+/// use flate2::Compression;
+/// use flate2::bufread::GzEncoder;
+/// use std::fs::File;
+/// use std::io::BufReader;
+///
+/// // Opens sample file, compresses the contents and returns a Vector or error
+/// // File wrapped in a BufReader implements BufRead
+///
+/// fn open_hello_world() -> io::Result<Vec<u8>> {
+///     let f = File::open("examples/hello_world.txt")?;
+///     let b = BufReader::new(f);
+///     let mut gz = GzEncoder::new(b, Compression::Fast);
+///     let mut buffer = Vec::new();
+///     gz.read_to_end(&mut buffer)?;
+///     Ok(buffer)
+/// }
+/// ```
 #[derive(Debug)]
 pub struct EncoderReaderBuf<R> {
     inner: deflate::EncoderReaderBuf<CrcReader<R>>,
@@ -70,6 +128,29 @@ pub struct EncoderReaderBuf<R> {
 /// A builder structure to create a new gzip Encoder.
 ///
 /// This structure controls header configuration options such as the filename.
+///
+/// # Examples
+///
+/// ```
+/// use std::io::prelude::*;
+/// # use std::io;
+/// use std::fs::File;
+/// use flate2::GzBuilder;
+/// use flate2::Compression;
+///
+/// // GzBuilder opens a file and writes a sample string using Builder pattern
+///
+/// # fn sample_builder() -> Result<(), io::Error> {
+/// let f = File::create("examples/hello_world.gz")?;
+/// let mut gz = GzBuilder::new()
+///                 .filename("hello_world.txt")
+///                 .comment("test file, please delete")
+///                 .write(f, Compression::Default);
+/// gz.write(b"hello world")?;
+/// gz.finish()?;
+/// # Ok(())
+/// # }
+/// ```
 #[derive(Debug)]
 pub struct Builder {
     extra: Option<Vec<u8>>,
@@ -84,6 +165,34 @@ pub struct Builder {
 /// data from the underlying reader and emit uncompressed data.
 ///
 /// [`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html
+///
+/// # Examples
+///
+/// ```
+///
+/// use std::io::prelude::*;
+/// use std::io;
+/// # use flate2::Compression;
+/// # use flate2::write::GzEncoder;
+/// use flate2::read::GzDecoder;
+///
+/// # fn main() {
+/// #    let mut e = GzEncoder::new(Vec::new(), Compression::Default);
+/// #    e.write(b"Hello World").unwrap();
+/// #    let bytes = e.finish().unwrap();
+/// #    println!("{}", decode_reader(bytes).unwrap());
+/// # }
+/// #
+/// // Uncompresses a Gz Encoded vector of bytes and returns a string or error
+/// // Here &[u8] implements Read
+///
+/// fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
+///    let mut gz = GzDecoder::new(&bytes[..])?;
+///    let mut s = String::new();
+///    gz.read_to_string(&mut s)?;
+///    Ok(s)
+/// }
+/// ```
 #[derive(Debug)]
 pub struct DecoderReader<R> {
     inner: DecoderReaderBuf<BufReader<R>>,
@@ -102,6 +211,33 @@ pub struct DecoderReader<R> {
 /// from the underlying reader and emit uncompressed data.
 ///
 /// [`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html
+///
+/// # Examples
+///
+/// ```
+/// use std::io::prelude::*;
+/// use std::io;
+/// # use flate2::Compression;
+/// # use flate2::write::GzEncoder;
+/// use flate2::read::MultiGzDecoder;
+///
+/// # fn main() {
+/// #    let mut e = GzEncoder::new(Vec::new(), Compression::Default);
+/// #    e.write(b"Hello World").unwrap();
+/// #    let bytes = e.finish().unwrap();
+/// #    println!("{}", decode_reader(bytes).unwrap());
+/// # }
+/// #
+/// // Uncompresses a Gz Encoded vector of bytes and returns a string or error
+/// // Here &[u8] implements Read
+///
+/// fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
+///    let mut gz = MultiGzDecoder::new(&bytes[..])?;
+///    let mut s = String::new();
+///    gz.read_to_string(&mut s)?;
+///    Ok(s)
+/// }
+/// ```
 #[derive(Debug)]
 pub struct MultiDecoderReader<R> {
     inner: MultiDecoderReaderBuf<BufReader<R>>,
@@ -109,10 +245,37 @@ pub struct MultiDecoderReader<R> {
 
 /// A gzip streaming decoder
 ///
-/// This structure exposes a [`Read`] interface that will consume compressed
+/// This structure exposes a [`ReadBuf`] interface that will consume compressed
 /// data from the underlying reader and emit uncompressed data.
 ///
-/// [`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html
+/// [`ReadBuf`]: https://doc.rust-lang.org/std/io/trait.BufRead.html
+///
+/// # Examples
+///
+/// ```
+/// use std::io::prelude::*;
+/// use std::io;
+/// # use flate2::Compression;
+/// # use flate2::write::GzEncoder;
+/// use flate2::bufread::GzDecoder;
+///
+/// # fn main() {
+/// #   let mut e = GzEncoder::new(Vec::new(), Compression::Default);
+/// #   e.write(b"Hello World").unwrap();
+/// #   let bytes = e.finish().unwrap();
+/// #   println!("{}", decode_reader(bytes).unwrap());
+/// # }
+/// #
+/// // Uncompresses a Gz Encoded vector of bytes and returns a string or error
+/// // Here &[u8] implements BufRead
+///
+/// fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
+///    let mut gz = GzDecoder::new(&bytes[..])?;
+///    let mut s = String::new();
+///    gz.read_to_string(&mut s)?;
+///    Ok(s)
+/// }
+/// ```
 #[derive(Debug)]
 pub struct DecoderReaderBuf<R> {
     inner: CrcReader<deflate::DecoderReaderBuf<R>>,
@@ -129,10 +292,37 @@ pub struct DecoderReaderBuf<R> {
 /// the first gzip member. The multistream format is commonly used in
 /// bioinformatics, for example when using the BGZF compressed data.
 ///
-/// This structure exposes a [`Read`] interface that will consume all gzip members
+/// This structure exposes a [`BufRead`] interface that will consume all gzip members
 /// from the underlying reader and emit uncompressed data.
 ///
-/// [`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html
+/// [`BufRead`]: https://doc.rust-lang.org/std/io/trait.BufRead.html
+///
+/// # Examples
+///
+/// ```
+/// use std::io::prelude::*;
+/// use std::io;
+/// # use flate2::Compression;
+/// # use flate2::write::GzEncoder;
+/// use flate2::bufread::MultiGzDecoder;
+///
+/// # fn main() {
+/// #   let mut e = GzEncoder::new(Vec::new(), Compression::Default);
+/// #   e.write(b"Hello World").unwrap();
+/// #   let bytes = e.finish().unwrap();
+/// #   println!("{}", decode_reader(bytes).unwrap());
+/// # }
+/// #
+/// // Uncompresses a Gz Encoded vector of bytes and returns a string or error
+/// // Here &[u8] implements BufRead
+///
+/// fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
+///    let mut gz = MultiGzDecoder::new(&bytes[..])?;
+///    let mut s = String::new();
+///    gz.read_to_string(&mut s)?;
+///    Ok(s)
+/// }
+/// ```
 #[derive(Debug)]
 pub struct MultiDecoderReaderBuf<R> {
     inner: CrcReader<deflate::DecoderReaderBuf<R>>,
diff --git a/src/zlib.rs b/src/zlib.rs
index 86d2246a1..3a81f2fad 100644
--- a/src/zlib.rs
+++ b/src/zlib.rs
@@ -19,6 +19,23 @@ use {Compress, Decompress};
 /// uncompressed data, writing the compressed data to the wrapped writer.
 ///
 /// [`Write`]: https://doc.rust-lang.org/std/io/trait.Write.html
+///
+/// # Examples
+///
+/// ```
+/// use std::io::prelude::*;
+/// use flate2::Compression;
+/// use flate2::write::ZlibEncoder;
+///
+/// // Vec<u8> implements Write, assigning the compressed bytes of sample string
+///
+/// # fn zlib_encoding() -> std::io::Result<()> {
+/// let mut e = ZlibEncoder::new(Vec::new(), Compression::Default);
+/// e.write(b"Hello World")?;
+/// let compressed = e.finish()?;
+/// # Ok(())
+/// # }
+/// ```
 #[derive(Debug)]
 pub struct EncoderWriter<W: Write> {
     inner: zio::Writer<W, Compress>,
@@ -30,6 +47,25 @@ pub struct EncoderWriter<W: Write> {
 /// data from an underlying stream and emit a stream of compressed data.
 ///
 /// [`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html
+///
+/// # Examples
+///
+/// ```
+/// use std::io::prelude::*;
+/// use flate2::Compression;
+/// use flate2::read::ZlibEncoder;
+/// use std::fs::File;
+///
+/// // Open example file and compress the contents using Read interface
+///
+/// # fn open_hello_world() -> std::io::Result<Vec<u8>> {
+/// let f = File::open("examples/hello_world.txt")?;
+/// let mut z = ZlibEncoder::new(f, Compression::Fast);
+/// let mut buffer = [0;50];
+/// let byte_count = z.read(&mut buffer)?;
+/// # Ok(buffer[0..byte_count].to_vec())
+/// # }
+/// ```
 #[derive(Debug)]
 pub struct EncoderReader<R> {
     inner: EncoderReaderBuf<BufReader<R>>,
@@ -41,6 +77,27 @@ pub struct EncoderReader<R> {
 /// data from an underlying stream and emit a stream of compressed data.
 ///
 /// [`BufRead`]: https://doc.rust-lang.org/std/io/trait.BufRead.html
+///
+/// # Examples
+///
+/// ```
+/// use std::io::prelude::*;
+/// use flate2::Compression;
+/// use flate2::bufread::ZlibEncoder;
+/// use std::fs::File;
+/// use std::io::BufReader;
+///
+/// // Use a buffered file to compress contents into a Vec<u8>
+///
+/// # fn open_hello_world() -> std::io::Result<Vec<u8>> {
+/// let f = File::open("examples/hello_world.txt")?;
+/// let b = BufReader::new(f);
+/// let mut z = ZlibEncoder::new(b, Compression::Fast);
+/// let mut buffer = Vec::new();
+/// z.read_to_end(&mut buffer)?;
+/// # Ok(buffer)
+/// # }
+/// ```
 #[derive(Debug)]
 pub struct EncoderReaderBuf<R> {
     obj: R,
@@ -53,6 +110,33 @@ pub struct EncoderReaderBuf<R> {
 /// compressed data as input, providing the decompressed data when read from.
 ///
 /// [`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html
+///
+/// # Examples
+///
+/// ```
+/// use std::io::prelude::*;
+/// use std::io;
+/// # use flate2::Compression;
+/// # use flate2::write::ZlibEncoder;
+/// use flate2::read::ZlibDecoder;
+///
+/// # fn main() {
+/// # let mut e = ZlibEncoder::new(Vec::new(), Compression::Default);
+/// # e.write(b"Hello World").unwrap();
+/// # let bytes = e.finish().unwrap();
+/// # println!("{}", decode_reader(bytes).unwrap());
+/// # }
+/// #
+/// // Uncompresses a Zlib Encoded vector of bytes and returns a string or error
+/// // Here &[u8] implements Read
+///
+/// fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
+///     let mut z = ZlibDecoder::new(&bytes[..]);
+///     let mut s = String::new();
+///     z.read_to_string(&mut s)?;
+///     Ok(s)
+/// }
+/// ```
 #[derive(Debug)]
 pub struct DecoderReader<R> {
     inner: DecoderReaderBuf<BufReader<R>>,
@@ -64,6 +148,33 @@ pub struct DecoderReader<R> {
 /// compressed data as input, providing the decompressed data when read from.
 ///
 /// [`BufRead`]: https://doc.rust-lang.org/std/io/trait.BufRead.html
+///
+/// # Examples
+///
+/// ```
+/// use std::io::prelude::*;
+/// use std::io;
+/// # use flate2::Compression;
+/// # use flate2::write::ZlibEncoder;
+/// use flate2::bufread::ZlibDecoder;
+///
+/// # fn main() {
+/// # let mut e = ZlibEncoder::new(Vec::new(), Compression::Default);
+/// # e.write(b"Hello World").unwrap();
+/// # let bytes = e.finish().unwrap();
+/// # println!("{}", decode_bufreader(bytes).unwrap());
+/// # }
+/// #
+/// // Uncompresses a Zlib Encoded vector of bytes and returns a string or error
+/// // Here &[u8] implements BufRead
+///
+/// fn decode_bufreader(bytes: Vec<u8>) -> io::Result<String> {
+///     let mut z = ZlibDecoder::new(&bytes[..]);
+///     let mut s = String::new();
+///     z.read_to_string(&mut s)?;
+///     Ok(s)
+/// }
+/// ```
 #[derive(Debug)]
 pub struct DecoderReaderBuf<R> {
     obj: R,
@@ -76,6 +187,35 @@ pub struct DecoderReaderBuf<R> {
 /// data when fed a stream of compressed data.
 ///
 /// [`Write`]: https://doc.rust-lang.org/std/io/trait.Write.html
+///
+/// # Examples
+///
+/// ```
+/// use std::io::prelude::*;
+/// use std::io;
+/// # use flate2::Compression;
+/// # use flate2::write::ZlibEncoder;
+/// use flate2::write::ZlibDecoder;
+///
+/// # fn main() {
+/// #    let mut e = ZlibEncoder::new(Vec::new(), Compression::Default);
+/// #    e.write(b"Hello World").unwrap();
+/// #    let bytes = e.finish().unwrap();
+/// #    println!("{}", decode_reader(bytes).unwrap());
+/// # }
+/// #
+/// // Uncompresses a Zlib Encoded vector of bytes and returns a string or error
+/// // Here Vec<u8> implements Write
+///
+/// fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
+///    let mut writer = Vec::new();
+///    let mut z = ZlibDecoder::new(writer);
+///    z.write(&bytes[..])?;
+///    writer = z.finish()?;
+///    let return_string = String::from_utf8(writer).expect("String parsing error");
+///    Ok(return_string)
+/// }
+/// ```
 #[derive(Debug)]
 pub struct DecoderWriter<W: Write> {
     inner: zio::Writer<W, Decompress>,