Lint: Remove redundant returns.

  - https://rust-lang.github.io/rust-clippy/master/index.html#needless_return

9 files changed, 69 insertions, 70 deletions

diff --git a/buffered-reader/src/decompress_bzip2.rs b/buffered-reader/src/decompress_bzip2.rs
index febe37fc..d292390f 100644
--- a/buffered-reader/src/decompress_bzip2.rs
+++ b/buffered-reader/src/decompress_bzip2.rs
@@ -53,48 +53,48 @@ impl<R: BufferedReader<C>, C: fmt::Debug + Sync + Send> fmt::Display for Bzip<R,
 
 impl<R: BufferedReader<C>, C: fmt::Debug + Send + Sync> BufferedReader<C> for Bzip<R, C> {
     fn buffer(&self) -> &[u8] {
-        return self.reader.buffer();
+        self.reader.buffer()
     }
 
     fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.reader.data(amount);
+        self.reader.data(amount)
     }
 
     fn data_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.reader.data_hard(amount);
+        self.reader.data_hard(amount)
     }
 
     fn data_eof(&mut self) -> Result<&[u8], io::Error> {
-        return self.reader.data_eof();
+        self.reader.data_eof()
     }
 
     fn consume(&mut self, amount: usize) -> &[u8] {
-        return self.reader.consume(amount);
+        self.reader.consume(amount)
     }
 
     fn data_consume(&mut self, amount: usize)
                     -> Result<&[u8], io::Error> {
-        return self.reader.data_consume(amount);
+        self.reader.data_consume(amount)
     }
 
     fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.reader.data_consume_hard(amount);
+        self.reader.data_consume_hard(amount)
     }
 
     fn read_be_u16(&mut self) -> Result<u16, io::Error> {
-        return self.reader.read_be_u16();
+        self.reader.read_be_u16()
     }
 
     fn read_be_u32(&mut self) -> Result<u32, io::Error> {
-        return self.reader.read_be_u32();
+        self.reader.read_be_u32()
     }
 
     fn steal(&mut self, amount: usize) -> Result<Vec<u8>, io::Error> {
-        return self.reader.steal(amount);
+        self.reader.steal(amount)
     }
 
     fn steal_eof(&mut self) -> Result<Vec<u8>, io::Error> {
-        return self.reader.steal_eof();
+        self.reader.steal_eof()
     }
 
     fn get_mut(&mut self) -> Option<&mut dyn BufferedReader<C>> {
diff --git a/buffered-reader/src/decompress_deflate.rs b/buffered-reader/src/decompress_deflate.rs
index d1d1a16b..d713413a 100644
--- a/buffered-reader/src/decompress_deflate.rs
+++ b/buffered-reader/src/decompress_deflate.rs
@@ -54,48 +54,48 @@ impl<R: BufferedReader<C>, C: fmt::Debug + Sync + Send> fmt::Display for Deflate
 impl<R: BufferedReader<C>, C: fmt::Debug + Send + Sync> BufferedReader<C>
         for Deflate<R, C> {
     fn buffer(&self) -> &[u8] {
-        return self.reader.buffer();
+        self.reader.buffer()
     }
 
     fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.reader.data(amount);
+        self.reader.data(amount)
     }
 
     fn data_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.reader.data_hard(amount);
+        self.reader.data_hard(amount)
     }
 
     fn data_eof(&mut self) -> Result<&[u8], io::Error> {
-        return self.reader.data_eof();
+        self.reader.data_eof()
     }
 
     fn consume(&mut self, amount: usize) -> &[u8] {
-        return self.reader.consume(amount);
+        self.reader.consume(amount)
     }
 
     fn data_consume(&mut self, amount: usize)
                     -> Result<&[u8], io::Error> {
-        return self.reader.data_consume(amount);
+        self.reader.data_consume(amount)
     }
 
     fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.reader.data_consume_hard(amount);
+        self.reader.data_consume_hard(amount)
     }
 
     fn read_be_u16(&mut self) -> Result<u16, io::Error> {
-        return self.reader.read_be_u16();
+        self.reader.read_be_u16()
     }
 
     fn read_be_u32(&mut self) -> Result<u32, io::Error> {
-        return self.reader.read_be_u32();
+        self.reader.read_be_u32()
     }
 
     fn steal(&mut self, amount: usize) -> Result<Vec<u8>, io::Error> {
-        return self.reader.steal(amount);
+        self.reader.steal(amount)
     }
 
     fn steal_eof(&mut self) -> Result<Vec<u8>, io::Error> {
-        return self.reader.steal_eof();
+        self.reader.steal_eof()
     }
 
     fn get_mut(&mut self) -> Option<&mut dyn BufferedReader<C>> {
@@ -180,48 +180,48 @@ impl<R: BufferedReader<C>, C: fmt::Debug + Sync + Send> fmt::Debug for Zlib<R, C
 impl<R: BufferedReader<C>, C: fmt::Debug + Send + Sync> BufferedReader<C>
         for Zlib<R, C> {
     fn buffer(&self) -> &[u8] {
-        return self.reader.buffer();
+        self.reader.buffer()
     }
 
     fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.reader.data(amount);
+        self.reader.data(amount)
     }
 
     fn data_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.reader.data_hard(amount);
+        self.reader.data_hard(amount)
     }
 
     fn data_eof(&mut self) -> Result<&[u8], io::Error> {
-        return self.reader.data_eof();
+        self.reader.data_eof()
     }
 
     fn consume(&mut self, amount: usize) -> &[u8] {
-        return self.reader.consume(amount);
+        self.reader.consume(amount)
     }
 
     fn data_consume(&mut self, amount: usize)
                     -> Result<&[u8], io::Error> {
-        return self.reader.data_consume(amount);
+        self.reader.data_consume(amount)
     }
 
     fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.reader.data_consume_hard(amount);
+        self.reader.data_consume_hard(amount)
     }
 
     fn read_be_u16(&mut self) -> Result<u16, io::Error> {
-        return self.reader.read_be_u16();
+        self.reader.read_be_u16()
     }
 
     fn read_be_u32(&mut self) -> Result<u32, io::Error> {
-        return self.reader.read_be_u32();
+        self.reader.read_be_u32()
     }
 
     fn steal(&mut self, amount: usize) -> Result<Vec<u8>, io::Error> {
-        return self.reader.steal(amount);
+        self.reader.steal(amount)
     }
 
     fn steal_eof(&mut self) -> Result<Vec<u8>, io::Error> {
-        return self.reader.steal_eof();
+        self.reader.steal_eof()
     }
 
     fn get_mut(&mut self) -> Option<&mut dyn BufferedReader<C>> {
diff --git a/buffered-reader/src/dup.rs b/buffered-reader/src/dup.rs
index d5ef6624..df4a6e2f 100644
--- a/buffered-reader/src/dup.rs
+++ b/buffered-reader/src/dup.rs
@@ -57,7 +57,7 @@ impl<T: BufferedReader<C>, C: fmt::Debug + Sync + Send> Dup<T, C> {
 
     /// Returns the number of bytes that this reader has consumed.
     pub fn total_out(&self) -> usize {
-        return self.cursor;
+        self.cursor
     }
 
     /// Resets the cursor to the beginning of the stream.
diff --git a/buffered-reader/src/eof.rs b/buffered-reader/src/eof.rs
index b0312630..6298b52b 100644
--- a/buffered-reader/src/eof.rs
+++ b/buffered-reader/src/eof.rs
@@ -40,26 +40,26 @@ impl<C> EOF<C> {
 
 impl<C> Read for EOF<C> {
     fn read(&mut self, _buf: &mut [u8]) -> Result<usize, io::Error> {
-        return Ok(0);
+        Ok(0)
     }
 }
 
 impl<C: fmt::Debug + Sync + Send> BufferedReader<C> for EOF<C> {
     fn buffer(&self) -> &[u8] {
-        return &b""[..];
+        &b""[..]
     }
 
     fn data(&mut self, _amount: usize) -> Result<&[u8], io::Error> {
-        return Ok(&b""[..]);
+        Ok(&b""[..])
     }
 
     fn consume(&mut self, amount: usize) -> &[u8] {
         assert_eq!(amount, 0);
-        return &b""[..];
+        &b""[..]
     }
 
     fn data_consume(&mut self, _amount: usize) -> Result<&[u8], io::Error> {
-        return Ok(&b""[..]);
+        Ok(&b""[..])
     }
 
     fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
@@ -73,17 +73,17 @@ impl<C: fmt::Debug + Sync + Send> BufferedReader<C> for EOF<C> {
     fn into_inner<'a>(self: Box<Self>) -> Option<Box<dyn BufferedReader<C> + 'a>>
         where Self: 'a
     {
-        return None;
+        None
     }
 
     fn get_mut(&mut self) -> Option<&mut dyn BufferedReader<C>>
     {
-        return None;
+        None
     }
 
     fn get_ref(&self) -> Option<&dyn BufferedReader<C>>
     {
-        return None;
+        None
     }
 
 
diff --git a/buffered-reader/src/generic.rs b/buffered-reader/src/generic.rs
index 8d6ec104..19f799eb 100644
--- a/buffered-reader/src/generic.rs
+++ b/buffered-reader/src/generic.rs
@@ -213,7 +213,7 @@ impl<T: io::Read + Send + Sync, C: fmt::Debug + Sync + Send> Generic<T, C> {
 
 impl<T: io::Read + Send + Sync, C: fmt::Debug + Sync + Send> io::Read for Generic<T, C> {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
-        return buffered_reader_generic_read_impl(self, buf);
+        buffered_reader_generic_read_impl(self, buf)
     }
 }
 
@@ -227,11 +227,11 @@ impl<T: io::Read + Send + Sync, C: fmt::Debug + Sync + Send> BufferedReader<C> f
     }
 
     fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.data_helper(amount, false, false);
+        self.data_helper(amount, false, false)
     }
 
     fn data_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.data_helper(amount, true, false);
+        self.data_helper(amount, true, false)
     }
 
     // Note:
@@ -257,16 +257,16 @@ impl<T: io::Read + Send + Sync, C: fmt::Debug + Sync + Send> BufferedReader<C> f
             return &self.buffer.as_ref().unwrap()[self.cursor - amount..];
         } else {
             assert_eq!(amount, 0);
-            return &b""[..];
+            &b""[..]
         }
     }
 
     fn data_consume(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.data_helper(amount, false, true);
+        self.data_helper(amount, false, true)
     }
 
     fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.data_helper(amount, true, true);
+        self.data_helper(amount, true, true)
     }
 
     fn get_mut(&mut self) -> Option<&mut dyn BufferedReader<C>> {
diff --git a/buffered-reader/src/lib.rs b/buffered-reader/src/lib.rs
index 29a2afc2..18fdbaee 100644
--- a/buffered-reader/src/lib.rs
+++ b/buffered-reader/src/lib.rs
@@ -402,7 +402,7 @@ pub trait BufferedReader<C> : io::Read + fmt::Debug + fmt::Display + Send + Sync
                                       "unexpected EOF"));
             }
         }
-        return result;
+        result
     }
 
     /// Returns all of the data until EOF.  Like `data()`, this does not
@@ -472,7 +472,7 @@ pub trait BufferedReader<C> : io::Read + fmt::Debug + fmt::Display + Send + Sync
 
         let buffer = self.buffer();
         assert_eq!(buffer.len(), s);
-        return Ok(buffer);
+        Ok(buffer)
     }
 
     /// Consumes some of the data.
@@ -747,7 +747,7 @@ pub trait BufferedReader<C> : io::Read + fmt::Debug + fmt::Display + Send + Sync
         };
 
         self.consume(position);
-        return Ok(total + position);
+        Ok(total + position)
     }
 
     /// Discards the input until one of the bytes in `terminals` is
@@ -785,7 +785,7 @@ pub trait BufferedReader<C> : io::Read + fmt::Debug + fmt::Display + Send + Sync
         if data.len() > amount {
             data = &data[..amount];
         }
-        return Ok(data.to_vec());
+        Ok(data.to_vec())
     }
 
     /// Like `steal()`, but instead of stealing a fixed number of
@@ -793,7 +793,7 @@ pub trait BufferedReader<C> : io::Read + fmt::Debug + fmt::Display + Send + Sync
     fn steal_eof(&mut self) -> Result<Vec<u8>, std::io::Error> {
         let len = self.data_eof()?.len();
         let data = self.steal(len)?;
-        return Ok(data);
+        Ok(data)
     }
 
     /// Like `steal_eof()`, but instead of returning the data, the
@@ -912,14 +912,13 @@ pub trait BufferedReader<C> : io::Read + fmt::Debug + fmt::Display + Send + Sync
 /// implementations of trait `std::io::Read` for type `&mut _`").
 pub fn buffered_reader_generic_read_impl<T: BufferedReader<C>, C: fmt::Debug + Sync + Send>
         (bio: &mut T, buf: &mut [u8]) -> Result<usize, io::Error> {
-    match bio.data_consume(buf.len()) {
-        Ok(inner) => {
+    bio
+        .data_consume(buf.len())
+        .map(|inner| {
             let amount = cmp::min(buf.len(), inner.len());
             buf[0..amount].copy_from_slice(&inner[0..amount]);
-            return Ok(amount);
-        },
-        Err(err) => return Err(err),
-    }
+            amount
+        })
 }
 
 /// Make a `Box<BufferedReader>` look like a BufferedReader.
diff --git a/buffered-reader/src/limitor.rs b/buffered-reader/src/limitor.rs
index 539dee74..c20edced 100644
--- a/buffered-reader/src/limitor.rs
+++ b/buffered-reader/src/limitor.rs
@@ -76,11 +76,11 @@ impl<T: BufferedReader<C>, C: fmt::Debug + Sync + Send> BufferedReader<C> for Li
         match result {
             Ok(ref buffer) =>
                 if buffer.len() as u64 > self.limit {
-                    return Ok(&buffer[0..self.limit as usize]);
+                    Ok(&buffer[0..self.limit as usize])
                 } else {
-                    return Ok(buffer);
+                    Ok(buffer)
                 },
-            Err(err) => return Err(err),
+            Err(err) => Err(err),
         }
     }
 
@@ -88,7 +88,7 @@ impl<T: BufferedReader<C>, C: fmt::Debug + Sync + Send> BufferedReader<C> for Li
         assert!(amount as u64 <= self.limit);
         self.limit -= amount as u64;
         let data = self.reader.consume(amount);
-        return &data[..cmp::min(self.limit + amount as u64, data.len() as u64) as usize];
+        &data[..cmp::min(self.limit + amount as u64, data.len() as u64) as usize]
     }
 
     fn data_consume(&mut self, amount: usize) -> Result<&[u8], io::Error> {
@@ -100,7 +100,7 @@ impl<T: BufferedReader<C>, C: fmt::Debug + Sync + Send> BufferedReader<C> for Li
             return Ok(&buffer[
                 ..cmp::min(buffer.len() as u64, self.limit + amount as u64) as usize]);
         }
-        return result;
+        result
     }
 
     fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
@@ -114,7 +114,7 @@ impl<T: BufferedReader<C>, C: fmt::Debug + Sync + Send> BufferedReader<C> for Li
             return Ok(&buffer[
                 ..cmp::min(buffer.len() as u64, self.limit + amount as u64) as usize]);
         }
-        return result;
+        result
     }
 
     fn consummated(&mut self) -> bool {
diff --git a/buffered-reader/src/memory.rs b/buffered-reader/src/memory.rs
index b469a652..a177c6c0 100644
--- a/buffered-reader/src/memory.rs
+++ b/buffered-reader/src/memory.rs
@@ -56,7 +56,7 @@ impl<'a, C: fmt::Debug + Sync + Send> Memory<'a, C> {
     /// Returns the number of bytes that have been consumed by this
     /// reader.
     pub fn total_out(&self) -> usize {
-        return self.cursor;
+        self.cursor
     }
 
     #[allow(dead_code)]
@@ -71,7 +71,7 @@ impl<'a, C: fmt::Debug + Sync + Send> io::Read for Memory<'a, C> {
         buf[0..amount].copy_from_slice(
                 &self.buffer[self.cursor..self.cursor+amount]);
         self.consume(amount);
-        return Ok(amount);
+        Ok(amount)
     }
 }
 
@@ -82,7 +82,7 @@ impl<'a, C: fmt::Debug + Sync + Send> BufferedReader<C> for Memory<'a, C> {
 
     fn data(&mut self, _amount: usize) -> Result<&[u8], io::Error> {
         assert!(self.cursor <= self.buffer.len());
-        return Ok(&self.buffer[self.cursor..]);
+        Ok(&self.buffer[self.cursor..])
     }
 
     fn consume(&mut self, amount: usize) -> &[u8] {
@@ -92,7 +92,7 @@ impl<'a, C: fmt::Debug + Sync + Send> BufferedReader<C> for Memory<'a, C> {
                 amount, self.buffer.len() - self.cursor);
         self.cursor += amount;
         assert!(self.cursor <= self.buffer.len());
-        return &self.buffer[self.cursor - amount..];
+        &self.buffer[self.cursor - amount..]
     }
 
     fn data_consume(&mut self, amount: usize) -> Result<&[u8], io::Error> {
diff --git a/buffered-reader/src/reserve.rs b/buffered-reader/src/reserve.rs
index 6de46627..937abbae 100644
--- a/buffered-reader/src/reserve.rs
+++ b/buffered-reader/src/reserve.rs
@@ -66,7 +66,7 @@ impl<T: BufferedReader<C>, C: fmt::Debug + Sync + Send> io::Read for Reserve<T,
 
         let to_read = cmp::min(buf.len(), to_read);
 
-        return self.reader.read(&mut buf[..to_read]);
+        self.reader.read(&mut buf[..to_read])
     }
 }