--- a/src/log.rs	Sun Feb 16 11:28:17 2020 +0100
+++ b/src/log.rs	Sun Feb 16 11:31:36 2020 +0100
@@ -60,7 +60,7 @@
 
             // Fill up block; go to next block.
             if space_left < HEADER_SIZE {
-                try!(self.dst.write(&vec![0, 0, 0, 0, 0, 0][0..space_left]));
+                self.dst.write(&vec![0, 0, 0, 0, 0, 0][0..space_left])?;
                 self.current_block_offset = 0;
             }
 
@@ -101,10 +101,10 @@
         let chksum = mask_crc(self.digest.sum32());
 
         let mut s = 0;
-        s += try!(self.dst.write(&chksum.encode_fixed_vec()));
-        s += try!(self.dst.write_fixedint(len as u16));
-        s += try!(self.dst.write(&[t as u8]));
-        s += try!(self.dst.write(&data[0..len]));
+        s += self.dst.write(&chksum.encode_fixed_vec())?;
+        s += self.dst.write_fixedint(len as u16)?;
+        s += self.dst.write(&[t as u8])?;
+        s += self.dst.write(&data[0..len])?;
 
         self.current_block_offset += s;
         Ok(s)
@@ -150,13 +150,13 @@
         loop {
             if self.blocksize - self.blk_off < HEADER_SIZE {
                 // skip to next block
-                try!(self
+                self
                     .src
-                    .read(&mut self.head_scratch[0..self.blocksize - self.blk_off]));
+                    .read(&mut self.head_scratch[0..self.blocksize - self.blk_off])?;
                 self.blk_off = 0;
             }
 
-            let mut bytes_read = try!(self.src.read(&mut self.head_scratch));
+            let mut bytes_read = self.src.read(&mut self.head_scratch)?;
 
             // EOF
             if bytes_read == 0 {
@@ -170,9 +170,9 @@
             typ = self.head_scratch[6];
 
             dst.resize(dst_offset + length as usize, 0);
-            bytes_read = try!(self
+            bytes_read = self
                 .src
-                .read(&mut dst[dst_offset..dst_offset + length as usize]));
+                .read(&mut dst[dst_offset..dst_offset + length as usize])?;
             self.blk_off += bytes_read;
 
             if self.checksums

--- a/src/table_block.rs	Sun Feb 16 11:28:17 2020 +0100
+++ b/src/table_block.rs	Sun Feb 16 11:31:36 2020 +0100
@@ -45,21 +45,21 @@
     // The block is denoted by offset and length in BlockHandle. A block in an encoded
     // table is followed by 1B compression type and 4B checksum.
     // The checksum refers to the compressed contents.
-    let buf = try!(read_bytes(f, location));
-    let compress = try!(read_bytes(
+    let buf = read_bytes(f, location)?;
+    let compress = read_bytes(
         f,
         &BlockHandle::new(
             location.offset() + location.size(),
             table_builder::TABLE_BLOCK_COMPRESS_LEN
         )
-    ));
-    let cksum = try!(read_bytes(
+    )?;
+    let cksum = read_bytes(
         f,
         &BlockHandle::new(
             location.offset() + location.size() + table_builder::TABLE_BLOCK_COMPRESS_LEN,
             table_builder::TABLE_BLOCK_CKSUM_LEN
         )
-    ));
+    )?;
 
     if !verify_table_block(&buf, compress[0], unmask_crc(u32::decode_fixed(&cksum))) {
         return err(

--- a/src/table_reader.rs	Sun Feb 16 11:28:17 2020 +0100
+++ b/src/table_reader.rs	Sun Feb 16 11:31:36 2020 +0100
@@ -40,17 +40,17 @@
 impl Table {
     /// Creates a new table reader operating on unformatted keys (i.e., UserKey).
     fn new_raw(opt: Options, file: Rc<Box<dyn RandomAccess>>, size: usize) -> Result<Table> {
-        let footer = try!(read_footer(file.as_ref().as_ref(), size));
-        let indexblock = try!(table_block::read_table_block(
+        let footer = read_footer(file.as_ref().as_ref(), size)?;
+        let indexblock = table_block::read_table_block(
             opt.clone(),
             file.as_ref().as_ref(),
             &footer.index
-        ));
-        let metaindexblock = try!(table_block::read_table_block(
+        )?;
+        let metaindexblock = table_block::read_table_block(
             opt.clone(),
             file.as_ref().as_ref(),
             &footer.meta_index
-        ));
+        )?;
 
         let filter_block_reader =
             Table::read_filter_block(&metaindexblock, file.as_ref().as_ref(), &opt)?;
@@ -126,11 +126,11 @@
         }
 
         // Two times as_ref(): First time to get a ref from Rc<>, then one from Box<>.
-        let b = try!(table_block::read_table_block(
+        let b = table_block::read_table_block(
             self.opt.clone(),
             self.file.as_ref().as_ref(),
             location
-        ));
+        )?;
 
         // insert a cheap copy (Rc).
         self.opt

--- a/src/version_edit.rs	Sun Feb 16 11:28:17 2020 +0100
+++ b/src/version_edit.rs	Sun Feb 16 11:31:36 2020 +0100
@@ -191,7 +191,7 @@
             if let Some(tag) = tag_to_enum(tag) {
                 match tag {
                     EditTag::Comparator => {
-                        let buf = try!(read_length_prefixed(&mut reader));
+                        let buf = read_length_prefixed(&mut reader)?;
                         if let Ok(c) = String::from_utf8(buf) {
                             ve.comparator = Some(c);
                         } else {
@@ -234,7 +234,7 @@
                     EditTag::CompactPointer => {
                         // Monads by indentation...
                         if let Ok(lvl) = reader.read_varint() {
-                            let key = try!(read_length_prefixed(&mut reader));
+                            let key = read_length_prefixed(&mut reader)?;
 
                             ve.compaction_ptrs.push(CompactionPointer {
                                 level: lvl,
@@ -261,8 +261,8 @@
                         if let Ok(lvl) = reader.read_varint() {
                             if let Ok(num) = reader.read_varint() {
                                 if let Ok(size) = reader.read_varint() {
-                                    let smallest = try!(read_length_prefixed(&mut reader));
-                                    let largest = try!(read_length_prefixed(&mut reader));
+                                    let smallest = read_length_prefixed(&mut reader)?;
+                                    let largest = read_length_prefixed(&mut reader)?;
                                     ve.new_files.push((
                                         lvl,
                                         FileMetaData {