Merge pull request #68 from triblespace/codex/remove-anyhow-dependency-and-update-serializable-trait

Remove anyhow dependency and adopt crate errors

Author: somethingelseentirely

CHANGELOG.md

@@ -1,6 +1,8 @@
 # Changelog
 
 ## Unreleased
+- Removed the `anyhow` dependency in favor of crate-defined errors and updated
+  `Serializable` to expose an associated error type for reconstruction.
 - Prevent panic in `DacsByte::len` by handling empty level lists gracefully.
 - Embedded section handles in `BitVectorData` and added `BitVectorDataMeta` with
   `Serializable` support for both `BitVectorData` and `BitVector`, enabling

Cargo.toml

@@ -17,7 +17,6 @@ rust-version = "1.61.0"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-anyhow = "1.0"
 num-traits = "0.2.15"
 anybytes = { git = "https://github.com/triblespace/anybytes", features = ["zerocopy", "mmap"] }
 zerocopy = "0.8"

INVENTORY.md

@@ -23,6 +23,9 @@
   common builder use cases.
 - Audit remaining constructors for zero-capacity variants and decide whether to
   offer explicit `empty` helpers instead of `with_capacity(0)`.
+- Evaluate introducing more structured error types per module now that
+  `anyhow` has been removed, ensuring diagnostics remain precise without
+  relying on free-form strings.
 - Allocate temporary wavelet-matrix buffers from `ByteArea` to avoid
   intermediate `Vec` copies and ensure fully contiguous construction.
 - Provide a derive or macro to reduce boilerplate when implementing the

src/bit_vector/mod.rs

@@ -134,8 +134,7 @@ use anybytes::area::SectionWriter;
 use anybytes::Bytes;
 use anybytes::View;
 
-use anyhow::anyhow;
-use anyhow::Result;
+use crate::error::{Error, Result};
 
 /// Builder that collects raw bits into a zero-copy [`BitVector`].
 
@@ -189,10 +188,10 @@ impl<'a> BitVectorBuilder<'a> {
     /// Returns the `pos`-th bit.
     pub fn get_bit(&self, pos: usize) -> Result<bool> {
         if self.len <= pos {
-            return Err(anyhow!(
+            return Err(Error::invalid_argument(format!(
                 "pos must be no greater than self.len()={}, but got {pos}.",
                 self.len
-            ));
+            )));
         }
         let word = pos / WORD_LEN;
         let pos_in_word = pos % WORD_LEN;
@@ -202,10 +201,10 @@ impl<'a> BitVectorBuilder<'a> {
     /// Sets the `pos`-th bit to `bit`.
     pub fn set_bit(&mut self, pos: usize, bit: bool) -> Result<()> {
         if self.len <= pos {
-            return Err(anyhow!(
+            return Err(Error::invalid_argument(format!(
                 "pos must be no greater than self.len()={}, but got {pos}.",
                 self.len
-            ));
+            )));
         }
         let word = pos / WORD_LEN;
         let pos_in_word = pos % WORD_LEN;
@@ -217,11 +216,10 @@ impl<'a> BitVectorBuilder<'a> {
     /// Sets all bits in `range` to `bit`.
     pub fn set_bits(&mut self, range: std::ops::Range<usize>, bit: bool) -> Result<()> {
         if range.end > self.len {
-            return Err(anyhow!(
+            return Err(Error::invalid_argument(format!(
                 "range end must be no greater than self.len()={}, but got {}.",
-                self.len,
-                range.end
-            ));
+                self.len, range.end
+            )));
         }
         if range.is_empty() {
             return Ok(());
@@ -250,10 +248,10 @@ impl<'a> BitVectorBuilder<'a> {
     /// Swaps bits at positions `a` and `b`.
     pub fn swap_bits(&mut self, a: usize, b: usize) -> Result<()> {
         if a >= self.len || b >= self.len {
-            return Err(anyhow!(
+            return Err(Error::invalid_argument(format!(
                 "positions must be less than self.len()={}, but got {a} and {b}.",
                 self.len
-            ));
+            )));
         }
         if a == b {
             return Ok(());
@@ -284,11 +282,10 @@ impl<'a> BitVectorBuilder<'a> {
         I: Iterator<Item = bool>,
     {
         if start > self.len {
-            return Err(anyhow!(
+            return Err(Error::invalid_argument(format!(
                 "start must be no greater than self.len()={}, but got {}.",
-                self.len,
-                start
-            ));
+                self.len, start
+            )));
         }
         let mut pos = start;
         while pos < self.len {
@@ -390,7 +387,7 @@ impl BitVectorData {
 
     /// Reconstructs the data from zero-copy [`Bytes`] and its metadata.
     pub fn from_bytes(meta: BitVectorDataMeta, bytes: Bytes) -> Result<Self> {
-        let words = meta.handle.view(&bytes).map_err(|e| anyhow::anyhow!(e))?;
+        let words = meta.handle.view(&bytes)?;
         Ok(Self {
             words,
             len: meta.len,
@@ -439,6 +436,7 @@ impl BitVectorData {
 
 impl Serializable for BitVectorData {
     type Meta = BitVectorDataMeta;
+    type Error = Error;
 
     fn metadata(&self) -> Self::Meta {
         BitVectorData::metadata(self)
@@ -700,6 +698,7 @@ impl<I: BitVectorIndex> BitVector<I> {
 
 impl<I: BitVectorIndex> Serializable for BitVector<I> {
     type Meta = BitVectorDataMeta;
+    type Error = Error;
 
     fn metadata(&self) -> Self::Meta {
         self.data.metadata()

src/bit_vector/rank9sel/inner.rs

@@ -4,10 +4,9 @@
 use anybytes::Bytes;
 use anybytes::View;
 
-use anyhow::Result;
-
 use crate::bit_vector::BitVectorData;
 use crate::broadword;
+use crate::error::{Error, Result};
 
 const BLOCK_LEN: usize = 8;
 const SELECT_ONES_PER_HINT: usize = 64 * BLOCK_LEN * 2;
@@ -443,49 +442,25 @@ impl<const SELECT1: bool, const SELECT0: bool> Rank9SelIndex<SELECT1, SELECT0> {
 impl<const SELECT1: bool, const SELECT0: bool> Rank9SelIndex<SELECT1, SELECT0> {
     /// Reconstructs the index from zero-copy [`Bytes`].
     pub fn from_bytes(mut bytes: Bytes) -> Result<Self> {
-        let len = *bytes
-            .view_prefix::<usize>()
-            .map_err(|e| anyhow::anyhow!(e))?;
-        let brp_len = *bytes
-            .view_prefix::<usize>()
-            .map_err(|e| anyhow::anyhow!(e))?;
-        let block_rank_pairs = bytes
-            .view_prefix_with_elems::<[usize]>(brp_len)
-            .map_err(|e| anyhow::anyhow!(e))?;
-        let has_select1 = *bytes
-            .view_prefix::<usize>()
-            .map_err(|e| anyhow::anyhow!(e))?
-            != 0;
+        let len = *bytes.view_prefix::<usize>()?;
+        let brp_len = *bytes.view_prefix::<usize>()?;
+        let block_rank_pairs = bytes.view_prefix_with_elems::<[usize]>(brp_len)?;
+        let has_select1 = *bytes.view_prefix::<usize>()? != 0;
         let select1_hints = if has_select1 {
-            let l = *bytes
-                .view_prefix::<usize>()
-                .map_err(|e| anyhow::anyhow!(e))?;
-            Some(
-                bytes
-                    .view_prefix_with_elems::<[usize]>(l)
-                    .map_err(|e| anyhow::anyhow!(e))?,
-            )
+            let l = *bytes.view_prefix::<usize>()?;
+            Some(bytes.view_prefix_with_elems::<[usize]>(l)?)
         } else {
             None
         };
-        let has_select0 = *bytes
-            .view_prefix::<usize>()
-            .map_err(|e| anyhow::anyhow!(e))?
-            != 0;
+        let has_select0 = *bytes.view_prefix::<usize>()? != 0;
         let select0_hints = if has_select0 {
-            let l = *bytes
-                .view_prefix::<usize>()
-                .map_err(|e| anyhow::anyhow!(e))?;
-            Some(
-                bytes
-                    .view_prefix_with_elems::<[usize]>(l)
-                    .map_err(|e| anyhow::anyhow!(e))?,
-            )
+            let l = *bytes.view_prefix::<usize>()?;
+            Some(bytes.view_prefix_with_elems::<[usize]>(l)?)
         } else {
             None
         };
         if has_select1 != SELECT1 || has_select0 != SELECT0 {
-            return Err(anyhow::anyhow!("mismatched hint flags"));
+            return Err(Error::MismatchedHintFlags);
         }
         Ok(Self {
             len,

src/char_sequences/wavelet_matrix.rs

@@ -11,8 +11,7 @@ use anybytes::area::SectionHandle;
 use anybytes::area::SectionWriter;
 use anybytes::Bytes;
 
-use anyhow::anyhow;
-use anyhow::Result;
+use crate::error::{Error, Result};
 
 use crate::bit_vector::Access;
 use crate::bit_vector::BitVector;
@@ -120,7 +119,7 @@ impl<'a> WaveletMatrixBuilder<'a> {
         writer: &mut SectionWriter<'a>,
     ) -> Result<Self> {
         if len == 0 {
-            return Err(anyhow!("seq must not be empty."));
+            return Err(Error::invalid_argument("seq must not be empty."));
         }
         let alph_width = utils::needed_bits(alph_size);
         let mut handles = writer.reserve::<SectionHandle<u64>>(alph_width)?;
@@ -142,13 +141,16 @@ impl<'a> WaveletMatrixBuilder<'a> {
     /// Sets the `pos`-th integer to `val`.
     pub fn set_int(&mut self, pos: usize, val: usize) -> Result<()> {
         if self.len <= pos {
-            return Err(anyhow!(
+            return Err(Error::invalid_argument(format!(
                 "pos must be no greater than self.len()={}, but got {pos}.",
                 self.len
-            ));
+            )));
         }
         if val >= self.alph_size {
-            return Err(anyhow!("value {} out of range 0..{}", val, self.alph_size));
+            return Err(Error::invalid_argument(format!(
+                "value {} out of range 0..{}",
+                val, self.alph_size
+            )));
         }
         for (layer_idx, layer) in self.layers.iter_mut().enumerate() {
             let shift = self.alph_width - 1 - layer_idx;
@@ -166,11 +168,10 @@ impl<'a> WaveletMatrixBuilder<'a> {
         I: Iterator<Item = usize>,
     {
         if start > self.len {
-            return Err(anyhow!(
+            return Err(Error::invalid_argument(format!(
                 "start must be no greater than self.len()={}, but got {}.",
-                self.len,
-                start
-            ));
+                self.len, start
+            )));
         }
         let mut pos = start;
         while pos < self.len {
@@ -806,6 +807,7 @@ where
 
 impl<I: BitVectorIndex> Serializable for WaveletMatrix<I> {
     type Meta = WaveletMatrixMeta;
+    type Error = Error;
 
     fn metadata(&self) -> Self::Meta {
         WaveletMatrixMeta {
@@ -817,7 +819,7 @@ impl<I: BitVectorIndex> Serializable for WaveletMatrix<I> {
     }
 
     fn from_bytes(meta: Self::Meta, bytes: Bytes) -> Result<Self> {
-        let handles_view = meta.layers.view(&bytes).map_err(anyhow::Error::from)?;
+        let handles_view = meta.layers.view(&bytes)?;
         let mut layers = Vec::with_capacity(meta.alph_width);
         for h in handles_view.as_ref() {
             let data = BitVectorData::from_bytes(

src/data.rs

@@ -9,12 +9,13 @@ pub struct IntVectorData {
 
 impl IntVectorData {
     /// Creates integer vector data from a slice of values.
-    pub fn from_slice<T: num_traits::ToPrimitive>(vals: &[T]) -> anyhow::Result<Self> {
+    pub fn from_slice<T: num_traits::ToPrimitive>(vals: &[T]) -> crate::error::Result<Self> {
         let mut ints = Vec::with_capacity(vals.len());
         for v in vals {
             ints.push(
-                v.to_usize()
-                    .ok_or_else(|| anyhow::anyhow!("vals must be castable"))?,
+                v.to_usize().ok_or_else(|| {
+                    crate::error::Error::invalid_argument("vals must be castable")
+                })?,
             );
         }
         Ok(Self { ints })

src/error.rs

@@ -0,0 +1,71 @@
+//! Common error types used throughout the crate.
+
+use std::fmt;
+
+use anybytes::view::ViewError;
+
+/// Result type used across the crate.
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+/// Error type covering failures across Jerky data structures.
+#[derive(Debug)]
+pub enum Error {
+    /// An argument violated preconditions.
+    InvalidArgument(String),
+    /// Deserialized metadata was malformed or inconsistent.
+    InvalidMetadata(String),
+    /// A mismatch between serialized hint flags and the requested type.
+    MismatchedHintFlags,
+    /// Wrapper around [`std::io::Error`] values.
+    Io(std::io::Error),
+    /// Wrapper around [`anybytes::ViewError`] values.
+    View(ViewError),
+}
+
+impl Error {
+    /// Creates an [`Error::InvalidArgument`] with the provided message.
+    pub fn invalid_argument(msg: impl Into<String>) -> Self {
+        Self::InvalidArgument(msg.into())
+    }
+
+    /// Creates an [`Error::InvalidMetadata`] with the provided message.
+    pub fn invalid_metadata(msg: impl Into<String>) -> Self {
+        Self::InvalidMetadata(msg.into())
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::InvalidArgument(msg) => write!(f, "{msg}"),
+            Error::InvalidMetadata(msg) => write!(f, "{msg}"),
+            Error::MismatchedHintFlags => write!(f, "mismatched hint flags"),
+            Error::Io(err) => write!(f, "I/O error: {err}"),
+            Error::View(err) => write!(f, "view error: {err}"),
+        }
+    }
+}
+
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Error::InvalidArgument(_) | Error::InvalidMetadata(_) | Error::MismatchedHintFlags => {
+                None
+            }
+            Error::Io(err) => Some(err),
+            Error::View(err) => Some(err),
+        }
+    }
+}
+
+impl From<std::io::Error> for Error {
+    fn from(err: std::io::Error) -> Self {
+        Error::Io(err)
+    }
+}
+
+impl From<ViewError> for Error {
+    fn from(err: ViewError) -> Self {
+        Error::View(err)
+    }
+}