Improve error handling

- `Error::context`: mark the inner error as the error source. This
  allows a downstream error handler (e.g. anyhow) to format the error
  chain nicely.
- Rename `Error::Shape` to `Error::MatrixShape` to narrow down the scope
  of the variant. Mark the shape error as the error source.
- Split `Error::Io` into `Error::{read, write}`. Mark the wrapped
  `io::Error` as the error source.
- Do not use debug representations of values in errors, we want their
  string representations instead.
- Remove the `Error` suffix from some variants. They are part of an
  error enum, we know that they are errors :^).

Author: danieldk

src/chunks/io.rs

@@ -34,7 +34,7 @@ impl ChunkIdentifier {
     {
         let chunk_id = read
             .read_u32::<LittleEndian>()
-            .map_err(|e| Error::io_error("Cannot read chunk identifier", e))?;
+            .map_err(|e| Error::read_error("Cannot read chunk identifier", e))?;
         let chunk_id = ChunkIdentifier::try_from(chunk_id)?;
         if chunk_id != identifier {
             return Err(Error::Format(format!(
@@ -107,7 +107,7 @@ macro_rules! typeid_impl {
             {
                 let type_id = read
                     .read_u32::<LittleEndian>()
-                    .map_err(|e| Error::io_error("Cannot read type identifier", e))?;
+                    .map_err(|e| Error::read_error("Cannot read type identifier", e))?;
                 if type_id != Self::type_id() {
                     return Err(Error::Format(format!(
                         "Invalid type, expected: {}, got: {}",
@@ -187,18 +187,18 @@ impl WriteChunk for Header {
     {
         write
             .write_all(&MAGIC)
-            .map_err(|e| Error::io_error("Cannot write magic", e))?;
+            .map_err(|e| Error::write_error("Cannot write magic", e))?;
         write
             .write_u32::<LittleEndian>(MODEL_VERSION)
-            .map_err(|e| Error::io_error("Cannot write model version", e))?;
+            .map_err(|e| Error::write_error("Cannot write model version", e))?;
         write
             .write_u32::<LittleEndian>(self.chunk_identifiers.len() as u32)
-            .map_err(|e| Error::io_error("Cannot write chunk identifiers length", e))?;
+            .map_err(|e| Error::write_error("Cannot write chunk identifiers length", e))?;
 
         for &identifier in &self.chunk_identifiers {
             write
                 .write_u32::<LittleEndian>(identifier as u32)
-                .map_err(|e| Error::io_error("Cannot write chunk identifier", e))?;
+                .map_err(|e| Error::write_error("Cannot write chunk identifier", e))?;
         }
 
         Ok(())
@@ -213,7 +213,7 @@ impl ReadChunk for Header {
         // Magic and version ceremony.
         let mut magic = [0u8; 4];
         read.read_exact(&mut magic)
-            .map_err(|e| Error::io_error("Cannot read magic", e))?;
+            .map_err(|e| Error::read_error("Cannot read magic", e))?;
 
         if magic != MAGIC {
             return Err(Error::Format(format!(
@@ -224,7 +224,7 @@ impl ReadChunk for Header {
 
         let version = read
             .read_u32::<LittleEndian>()
-            .map_err(|e| Error::io_error("Cannot read model version", e))?;
+            .map_err(|e| Error::read_error("Cannot read model version", e))?;
         if version != MODEL_VERSION {
             return Err(Error::Format(format!(
                 "Unknown finalfusion version: {}",
@@ -235,13 +235,13 @@ impl ReadChunk for Header {
         // Read chunk identifiers.
         let chunk_identifiers_len = read
             .read_u32::<LittleEndian>()
-            .map_err(|e| Error::io_error("Cannot read chunk identifiers length", e))?
+            .map_err(|e| Error::read_error("Cannot read chunk identifiers length", e))?
             as usize;
         let mut chunk_identifiers = Vec::with_capacity(chunk_identifiers_len);
         for _ in 0..chunk_identifiers_len {
             let identifier = read
                 .read_u32::<LittleEndian>()
-                .map_err(|e| Error::io_error("Cannot read chunk identifier", e))?;
+                .map_err(|e| Error::read_error("Cannot read chunk identifier", e))?;
             let chunk_identifier = ChunkIdentifier::try_from(identifier)?;
             chunk_identifiers.push(chunk_identifier);
         }

src/chunks/metadata.rs

@@ -53,14 +53,15 @@ impl ReadChunk for Metadata {
         ChunkIdentifier::ensure_chunk_type(read, ChunkIdentifier::Metadata)?;
 
         // Read chunk length.
-        let chunk_len =
-            read.read_u64::<LittleEndian>()
-                .map_err(|e| Error::io_error("Cannot read chunk length", e))? as usize;
+        let chunk_len = read
+            .read_u64::<LittleEndian>()
+            .map_err(|e| Error::read_error("Cannot read chunk length", e))?
+            as usize;
 
         // Read TOML data.
         let mut buf = vec![0; chunk_len];
         read.read_exact(&mut buf)
-            .map_err(|e| Error::io_error("Cannot read TOML metadata", e))?;
+            .map_err(|e| Error::read_error("Cannot read TOML metadata", e))?;
         let buf_str = String::from_utf8(buf)
             .map_err(|e| Error::Format(format!("TOML metadata contains invalid UTF-8: {}", e)))
             .map_err(Error::from)?;
@@ -87,13 +88,13 @@ impl WriteChunk for Metadata {
 
         write
             .write_u32::<LittleEndian>(self.chunk_identifier() as u32)
-            .map_err(|e| Error::io_error("Cannot write metadata chunk identifier", e))?;
+            .map_err(|e| Error::write_error("Cannot write metadata chunk identifier", e))?;
         write
             .write_u64::<LittleEndian>(metadata_str.len() as u64)
-            .map_err(|e| Error::io_error("Cannot write metadata length", e))?;
+            .map_err(|e| Error::write_error("Cannot write metadata length", e))?;
         write
             .write_all(metadata_str.as_bytes())
-            .map_err(|e| Error::io_error("Cannot write metadata", e))?;
+            .map_err(|e| Error::write_error("Cannot write metadata", e))?;
 
         Ok(())
     }

src/chunks/norms.rs

@@ -59,26 +59,26 @@ impl ReadChunk for NdNorms {
 
         // Read and discard chunk length.
         read.read_u64::<LittleEndian>()
-            .map_err(|e| Error::io_error("Cannot read norms chunk length", e))?;
+            .map_err(|e| Error::read_error("Cannot read norms chunk length", e))?;
 
         let len = read
             .read_u64::<LittleEndian>()
-            .map_err(|e| Error::io_error("Cannot read norms vector length", e))?
+            .map_err(|e| Error::read_error("Cannot read norms vector length", e))?
             .try_into()
             .map_err(|_| Error::Overflow)?;
 
         f32::ensure_data_type(read)?;
 
         let n_padding =
             padding::<f32>(read.seek(SeekFrom::Current(0)).map_err(|e| {
-                Error::io_error("Cannot get file position for computing padding", e)
+                Error::read_error("Cannot get file position for computing padding", e)
             })?);
         read.seek(SeekFrom::Current(n_padding as i64))
-            .map_err(|e| Error::io_error("Cannot skip padding", e))?;
+            .map_err(|e| Error::read_error("Cannot skip padding", e))?;
 
         let mut data = Array1::zeros((len,));
         read.read_f32_into::<LittleEndian>(data.as_slice_mut().unwrap())
-            .map_err(|e| Error::io_error("Cannot read norms", e))?;
+            .map_err(|e| Error::read_error("Cannot read norms", e))?;
 
         Ok(NdNorms::new(data))
     }
@@ -95,11 +95,10 @@ impl WriteChunk for NdNorms {
     {
         write
             .write_u32::<LittleEndian>(ChunkIdentifier::NdNorms as u32)
-            .map_err(|e| Error::io_error("Cannot write norms chunk identifier", e))?;
-        let n_padding =
-            padding::<f32>(write.seek(SeekFrom::Current(0)).map_err(|e| {
-                Error::io_error("Cannot get file position for computing padding", e)
-            })?);
+            .map_err(|e| Error::write_error("Cannot write norms chunk identifier", e))?;
+        let n_padding = padding::<f32>(write.seek(SeekFrom::Current(0)).map_err(|e| {
+            Error::write_error("Cannot get file position for computing padding", e)
+        })?);
 
         // Chunk size: len (u64), type id (u32), padding ([0,4) bytes), vector.
         let chunk_len = size_of::<u64>()
@@ -108,23 +107,23 @@ impl WriteChunk for NdNorms {
             + (self.len() * size_of::<f32>());
         write
             .write_u64::<LittleEndian>(chunk_len as u64)
-            .map_err(|e| Error::io_error("Cannot write norms chunk length", e))?;
+            .map_err(|e| Error::write_error("Cannot write norms chunk length", e))?;
         write
             .write_u64::<LittleEndian>(self.len() as u64)
-            .map_err(|e| Error::io_error("Cannot write norms vector length", e))?;
+            .map_err(|e| Error::write_error("Cannot write norms vector length", e))?;
         write
             .write_u32::<LittleEndian>(f32::type_id())
-            .map_err(|e| Error::io_error("Cannot write norms vector type identifier", e))?;
+            .map_err(|e| Error::write_error("Cannot write norms vector type identifier", e))?;
 
         let padding = vec![0; n_padding as usize];
         write
             .write_all(&padding)
-            .map_err(|e| Error::io_error("Cannot write padding", e))?;
+            .map_err(|e| Error::write_error("Cannot write padding", e))?;
 
         for &val in self.iter() {
             write
                 .write_f32::<LittleEndian>(val)
-                .map_err(|e| Error::io_error("Cannot write norm", e))?;
+                .map_err(|e| Error::write_error("Cannot write norm", e))?;
         }
 
         Ok(())

src/chunks/storage/array.rs

@@ -116,33 +116,33 @@ mod mmap {
 
             // Read and discard chunk length.
             read.read_u64::<LittleEndian>()
-                .map_err(|e| Error::io_error("Cannot read embedding matrix chunk length", e))?;
+                .map_err(|e| Error::read_error("Cannot read embedding matrix chunk length", e))?;
 
             let rows = read
                 .read_u64::<LittleEndian>()
                 .map_err(|e| {
-                    Error::io_error("Cannot read number of rows of the embedding matrix", e)
+                    Error::read_error("Cannot read number of rows of the embedding matrix", e)
                 })?
                 .try_into()
                 .map_err(|_| Error::Overflow)?;
             let cols = read.read_u32::<LittleEndian>().map_err(|e| {
-                Error::io_error("Cannot read number of columns of the embedding matrix", e)
+                Error::read_error("Cannot read number of columns of the embedding matrix", e)
             })? as usize;
             let shape = Ix2(rows, cols);
 
             // The components of the embedding matrix should be of type f32.
             f32::ensure_data_type(read)?;
 
             let n_padding = padding::<f32>(read.seek(SeekFrom::Current(0)).map_err(|e| {
-                Error::io_error("Cannot get file position for computing padding", e)
+                Error::read_error("Cannot get file position for computing padding", e)
             })?);
             read.seek(SeekFrom::Current(n_padding as i64))
-                .map_err(|e| Error::io_error("Cannot skip padding", e))?;
+                .map_err(|e| Error::read_error("Cannot skip padding", e))?;
 
             // Set up memory mapping.
             let matrix_len = shape.size() * size_of::<f32>();
             let offset = read.seek(SeekFrom::Current(0)).map_err(|e| {
-                Error::io_error(
+                Error::read_error(
                     "Cannot get file position for memory mapping embedding matrix",
                     e,
                 )
@@ -153,12 +153,12 @@ mod mmap {
                     .offset(offset)
                     .len(matrix_len)
                     .map(&*read.get_ref())
-                    .map_err(|e| Error::io_error("Cannot memory map embedding matrix", e))?
+                    .map_err(|e| Error::read_error("Cannot memory map embedding matrix", e))?
             };
 
             // Position the reader after the matrix.
             read.seek(SeekFrom::Current(matrix_len as i64))
-                .map_err(|e| Error::io_error("Cannot skip embedding matrix", e))?;
+                .map_err(|e| Error::read_error("Cannot skip embedding matrix", e))?;
 
             Ok(MmapArray { map, shape })
         }
@@ -199,11 +199,10 @@ impl NdArray {
     {
         write
             .write_u32::<LittleEndian>(ChunkIdentifier::NdArray as u32)
-            .map_err(|e| Error::io_error("Cannot write embedding matrix chunk identifier", e))?;
-        let n_padding =
-            padding::<f32>(write.seek(SeekFrom::Current(0)).map_err(|e| {
-                Error::io_error("Cannot get file position for computing padding", e)
-            })?);
+            .map_err(|e| Error::write_error("Cannot write embedding matrix chunk identifier", e))?;
+        let n_padding = padding::<f32>(write.seek(SeekFrom::Current(0)).map_err(|e| {
+            Error::write_error("Cannot get file position for computing padding", e)
+        })?);
         // Chunk size: rows (u64), columns (u32), type id (u32),
         //             padding ([0,4) bytes), matrix.
         let chunk_len = size_of::<u64>()
@@ -213,20 +212,20 @@ impl NdArray {
             + (data.nrows() * data.ncols() * size_of::<f32>());
         write
             .write_u64::<LittleEndian>(chunk_len as u64)
-            .map_err(|e| Error::io_error("Cannot write embedding matrix chunk length", e))?;
+            .map_err(|e| Error::write_error("Cannot write embedding matrix chunk length", e))?;
         write
             .write_u64::<LittleEndian>(data.nrows() as u64)
             .map_err(|e| {
-                Error::io_error("Cannot write number of rows of the embedding matrix", e)
+                Error::write_error("Cannot write number of rows of the embedding matrix", e)
             })?;
         write
             .write_u32::<LittleEndian>(data.ncols() as u32)
             .map_err(|e| {
-                Error::io_error("Cannot write number of columns of the embedding matrix", e)
+                Error::write_error("Cannot write number of columns of the embedding matrix", e)
             })?;
         write
             .write_u32::<LittleEndian>(f32::type_id())
-            .map_err(|e| Error::io_error("Cannot write embedding matrix type identifier", e))?;
+            .map_err(|e| Error::write_error("Cannot write embedding matrix type identifier", e))?;
 
         // Write padding, such that the embedding matrix starts on at
         // a multiple of the size of f32 (4 bytes). This is necessary
@@ -242,13 +241,13 @@ impl NdArray {
         let padding = vec![0; n_padding as usize];
         write
             .write_all(&padding)
-            .map_err(|e| Error::io_error("Cannot write padding", e))?;
+            .map_err(|e| Error::write_error("Cannot write padding", e))?;
 
         for row in data.outer_iter() {
             for col in row.iter() {
-                write
-                    .write_f32::<LittleEndian>(*col)
-                    .map_err(|e| Error::io_error("Cannot write embedding matrix component", e))?;
+                write.write_f32::<LittleEndian>(*col).map_err(|e| {
+                    Error::write_error("Cannot write embedding matrix component", e)
+                })?;
             }
         }
 
@@ -311,30 +310,32 @@ impl ReadChunk for NdArray {
 
         // Read and discard chunk length.
         read.read_u64::<LittleEndian>()
-            .map_err(|e| Error::io_error("Cannot read embedding matrix chunk length", e))?;
+            .map_err(|e| Error::read_error("Cannot read embedding matrix chunk length", e))?;
 
         let rows = read
             .read_u64::<LittleEndian>()
-            .map_err(|e| Error::io_error("Cannot read number of rows of the embedding matrix", e))?
+            .map_err(|e| {
+                Error::read_error("Cannot read number of rows of the embedding matrix", e)
+            })?
             .try_into()
             .map_err(|_| Error::Overflow)?;
         let cols = read.read_u32::<LittleEndian>().map_err(|e| {
-            Error::io_error("Cannot read number of columns of the embedding matrix", e)
+            Error::read_error("Cannot read number of columns of the embedding matrix", e)
         })? as usize;
 
         // The components of the embedding matrix should be of type f32.
         f32::ensure_data_type(read)?;
 
         let n_padding =
             padding::<f32>(read.seek(SeekFrom::Current(0)).map_err(|e| {
-                Error::io_error("Cannot get file position for computing padding", e)
+                Error::read_error("Cannot get file position for computing padding", e)
             })?);
         read.seek(SeekFrom::Current(n_padding as i64))
-            .map_err(|e| Error::io_error("Cannot skip padding", e))?;
+            .map_err(|e| Error::read_error("Cannot skip padding", e))?;
 
         let mut data = Array2::zeros((rows, cols));
         read.read_f32_into::<LittleEndian>(data.as_slice_mut().unwrap())
-            .map_err(|e| Error::io_error("Cannot read embedding matrix", e))?;
+            .map_err(|e| Error::read_error("Cannot read embedding matrix", e))?;
 
         Ok(NdArray { inner: data })
     }