Merge pull request #3 from zeenix/error-type

zeenix · web-flow · commit 5f60fc75563a · 2025-04-01T19:25:34.000+02:00
🥅 Add Error type
diff --git a/src/error.rs b/src/error.rs
@@ -0,0 +1,41 @@
+/// The `Error` type for the `mayheap` crate.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Error {
+    /// Attempted to grow a collection beyond its capacity.
+    ///
+    /// This error can only occur when `heapless` feature is enabled.
+    BufferOverflow,
+    /// Invalid UTF-8 sequence.
+    Utf8Error(core::str::Utf8Error),
+}
+
+/// The Result type for the zlink crate.
+pub type Result<T> = core::result::Result<T, Error>;
+
+impl core::error::Error for Error {
+    fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
+        match self {
+            Error::BufferOverflow => None,
+            Error::Utf8Error(err) => Some(err),
+        }
+    }
+}
+
+impl core::fmt::Display for Error {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Error::BufferOverflow => {
+                write!(f, "Attempted to grow a collection beyond its capacity")
+            }
+            Error::Utf8Error(err) => {
+                write!(f, "Invalid UTF-8 sequence: {}", err)
+            }
+        }
+    }
+}
+
+impl From<core::str::Utf8Error> for Error {
+    fn from(err: core::str::Utf8Error) -> Self {
+        Error::Utf8Error(err)
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -21,6 +21,9 @@ pub use vec::Vec;
 pub mod string;
 pub use string::String;
 
+mod error;
+pub use error::{Error, Result};
+
 #[cfg(test)]
 mod tests {
     #[cfg(feature = "serde")]
diff --git a/src/string.rs b/src/string.rs
@@ -1,10 +1,6 @@
 //! A UTF-8–encoded, growable string.
 
-use core::{
-    cmp::Ordering,
-    fmt, hash, iter, ops,
-    str::{self, Utf8Error},
-};
+use core::{cmp::Ordering, fmt, hash, iter, ops, str};
 
 use crate::Vec;
 
@@ -42,15 +38,15 @@ impl<const N: usize> String<N> {
 
     /// Convert UTF-8 bytes into a `String`.
     #[inline]
-    pub fn from_utf8(vec: Vec<u8, N>) -> Result<Self, Utf8Error> {
+    pub fn from_utf8(vec: Vec<u8, N>) -> crate::Result<Self> {
         let res = Inner::from_utf8(vec.into_inner()).map(Self);
         #[cfg(feature = "alloc")]
         {
-            res.map_err(|e| e.utf8_error())
+            res.map_err(|e| e.utf8_error().into())
         }
         #[cfg(not(feature = "alloc"))]
         {
-            res
+            res.map_err(|e| e.into())
         }
     }
 
@@ -100,15 +96,17 @@ impl<const N: usize> String<N> {
 
     /// Appends a given string slice onto the end of this `String`.
     #[inline]
-    pub fn push_str(&mut self, string: &str) -> Result<(), ()> {
+    pub fn push_str(&mut self, string: &str) -> crate::Result<()> {
         #[cfg(feature = "alloc")]
         {
             self.0.push_str(string);
             Ok(())
         }
         #[cfg(not(feature = "alloc"))]
         {
-            self.0.push_str(string)
+            self.0
+                .push_str(string)
+                .map_err(|_| crate::Error::BufferOverflow)
         }
     }
 
@@ -122,15 +120,15 @@ impl<const N: usize> String<N> {
 
     /// Appends the given [`char`] to the end of this `String`.
     #[inline]
-    pub fn push(&mut self, c: char) -> Result<(), ()> {
+    pub fn push(&mut self, c: char) -> crate::Result<()> {
         #[cfg(feature = "alloc")]
         {
             self.0.push(c);
             Ok(())
         }
         #[cfg(not(feature = "alloc"))]
         {
-            self.0.push(c)
+            self.0.push(c).map_err(|_| crate::Error::BufferOverflow)
         }
     }
 
@@ -180,19 +178,21 @@ impl<const N: usize> Default for String<N> {
 }
 
 impl<'a, const N: usize> TryFrom<&'a str> for String<N> {
-    type Error = ();
+    type Error = crate::Error;
     #[inline]
     fn try_from(s: &'a str) -> Result<Self, Self::Error> {
-        <Self as core::str::FromStr>::from_str(s)
+        <Self as core::str::FromStr>::from_str(s).map_err(|_| crate::Error::BufferOverflow)
     }
 }
 
 impl<const N: usize> str::FromStr for String<N> {
-    type Err = ();
+    type Err = crate::Error;
 
     #[inline]
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Inner::from_str(s).map(Self).map_err(|_| ())
+        Inner::from_str(s)
+            .map(Self)
+            .map_err(|_| crate::Error::BufferOverflow)
     }
 }
 
@@ -352,7 +352,7 @@ impl<const N: usize> Ord for String<N> {
 macro_rules! impl_try_from_num {
     ($num:ty, $size:expr) => {
         impl<const N: usize> core::convert::TryFrom<$num> for String<N> {
-            type Error = ();
+            type Error = crate::Error;
             #[inline]
             fn try_from(s: $num) -> Result<Self, Self::Error> {
                 #[cfg(feature = "alloc")]
@@ -361,7 +361,9 @@ macro_rules! impl_try_from_num {
                 }
                 #[cfg(not(feature = "alloc"))]
                 {
-                    Inner::try_from(s).map(Self)
+                    Inner::try_from(s)
+                        .map(Self)
+                        .map_err(|_| crate::Error::BufferOverflow)
                 }
             }
         }
diff --git a/src/vec.rs b/src/vec.rs
@@ -35,7 +35,7 @@ impl<T, const N: usize> Vec<T, N> {
 
     /// Constructs a new vector with a capacity of `N` and fills it with the provided slice.
     #[inline]
-    pub fn from_slice(other: &[T]) -> Result<Self, ()>
+    pub fn from_slice(other: &[T]) -> crate::Result<Self>
     where
         T: Clone,
     {
@@ -113,7 +113,7 @@ impl<T, const N: usize> Vec<T, N> {
     /// Iterates over the slice `other`, clones each element, and then appends
     /// it to this `Vec`. The `other` vector is traversed in-order.
     #[inline]
-    pub fn extend_from_slice(&mut self, other: &[T]) -> Result<(), ()>
+    pub fn extend_from_slice(&mut self, other: &[T]) -> crate::Result<()>
     where
         T: Clone,
     {
@@ -125,7 +125,9 @@ impl<T, const N: usize> Vec<T, N> {
         }
         #[cfg(not(feature = "alloc"))]
         {
-            self.0.extend_from_slice(other)
+            self.0
+                .extend_from_slice(other)
+                .map_err(|_| crate::Error::BufferOverflow)
         }
     }
 
@@ -183,7 +185,7 @@ impl<T, const N: usize> Vec<T, N> {
     ///
     /// See also [`resize_default`](Self::resize_default).
     #[inline]
-    pub fn resize(&mut self, new_len: usize, value: T) -> Result<(), ()>
+    pub fn resize(&mut self, new_len: usize, value: T) -> crate::Result<()>
     where
         T: Clone,
     {
@@ -195,7 +197,9 @@ impl<T, const N: usize> Vec<T, N> {
         }
         #[cfg(not(feature = "alloc"))]
         {
-            self.0.resize(new_len, value)
+            self.0
+                .resize(new_len, value)
+                .map_err(|_| crate::Error::BufferOverflow)
         }
     }
 
@@ -207,7 +211,7 @@ impl<T, const N: usize> Vec<T, N> {
     ///
     /// See also [`resize`](Self::resize).
     #[inline]
-    pub fn resize_default(&mut self, new_len: usize) -> Result<(), ()>
+    pub fn resize_default(&mut self, new_len: usize) -> crate::Result<()>
     where
         T: Clone + Default,
     {
@@ -342,7 +346,7 @@ impl<const N: usize> fmt::Write for Vec<u8, N> {
 }
 
 impl<'a, T: Clone, const N: usize> TryFrom<&'a [T]> for Vec<T, N> {
-    type Error = ();
+    type Error = crate::Error;
 
     #[inline]
     fn try_from(slice: &'a [T]) -> Result<Self, Self::Error> {

Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,6 @@`
`1`	`1`	`//! A UTF-8–encoded, growable string.`
`2`	`2`
`3`		`-use core::{`
`4`		`- cmp::Ordering,`
`5`		`- fmt, hash, iter, ops,`
`6`		`- str::{self, Utf8Error},`
`7`		`-};`
	`3`	`+use core::{cmp::Ordering, fmt, hash, iter, ops, str};`
`8`	`4`
`9`	`5`	`use crate::Vec;`
`10`	`6`
`@@ -42,15 +38,15 @@ impl<const N: usize> String<N> {`
`42`	`38`
`43`	`39`	/// Convert UTF-8 bytes into a `String`.
`44`	`40`	`#[inline]`
`45`		`- pub fn from_utf8(vec: Vec<u8, N>) -> Result<Self, Utf8Error> {`
	`41`	`+ pub fn from_utf8(vec: Vec<u8, N>) -> crate::Result<Self> {`
`46`	`42`	`let res = Inner::from_utf8(vec.into_inner()).map(Self);`
`47`	`43`	`#[cfg(feature = "alloc")]`
`48`	`44`	`{`
`49`		`- res.map_err(\|e\| e.utf8_error())`
	`45`	`+ res.map_err(\|e\| e.utf8_error().into())`
`50`	`46`	`}`
`51`	`47`	`#[cfg(not(feature = "alloc"))]`
`52`	`48`	`{`
`53`		`- res`
	`49`	`+ res.map_err(\|e\| e.into())`
`54`	`50`	`}`
`55`	`51`	`}`
`56`	`52`
`@@ -100,15 +96,17 @@ impl<const N: usize> String<N> {`
`100`	`96`
`101`	`97`	/// Appends a given string slice onto the end of this `String`.
`102`	`98`	`#[inline]`
`103`		`- pub fn push_str(&mut self, string: &str) -> Result<(), ()> {`
	`99`	`+ pub fn push_str(&mut self, string: &str) -> crate::Result<()> {`
`104`	`100`	`#[cfg(feature = "alloc")]`
`105`	`101`	`{`
`106`	`102`	`self.0.push_str(string);`
`107`	`103`	`Ok(())`
`108`	`104`	`}`
`109`	`105`	`#[cfg(not(feature = "alloc"))]`
`110`	`106`	`{`
`111`		`- self.0.push_str(string)`
	`107`	`+ self.0`
	`108`	`+ .push_str(string)`
	`109`	`+ .map_err(\|_\| crate::Error::BufferOverflow)`
`112`	`110`	`}`
`113`	`111`	`}`
`114`	`112`
`@@ -122,15 +120,15 @@ impl<const N: usize> String<N> {`
`122`	`120`
`123`	`121`	/// Appends the given [`char`] to the end of this `String`.
`124`	`122`	`#[inline]`
`125`		`- pub fn push(&mut self, c: char) -> Result<(), ()> {`
	`123`	`+ pub fn push(&mut self, c: char) -> crate::Result<()> {`
`126`	`124`	`#[cfg(feature = "alloc")]`
`127`	`125`	`{`
`128`	`126`	`self.0.push(c);`
`129`	`127`	`Ok(())`
`130`	`128`	`}`
`131`	`129`	`#[cfg(not(feature = "alloc"))]`
`132`	`130`	`{`
`133`		`- self.0.push(c)`
	`131`	`+ self.0.push(c).map_err(\|_\| crate::Error::BufferOverflow)`
`134`	`132`	`}`
`135`	`133`	`}`
`136`	`134`
`@@ -180,19 +178,21 @@ impl<const N: usize> Default for String<N> {`
`180`	`178`	`}`
`181`	`179`
`182`	`180`	`impl<'a, const N: usize> TryFrom<&'a str> for String<N> {`
`183`		`- type Error = ();`
	`181`	`+ type Error = crate::Error;`
`184`	`182`	`#[inline]`
`185`	`183`	`fn try_from(s: &'a str) -> Result<Self, Self::Error> {`
`186`		`- <Self as core::str::FromStr>::from_str(s)`
	`184`	`+ <Self as core::str::FromStr>::from_str(s).map_err(\|_\| crate::Error::BufferOverflow)`
`187`	`185`	`}`
`188`	`186`	`}`
`189`	`187`
`190`	`188`	`impl<const N: usize> str::FromStr for String<N> {`
`191`		`- type Err = ();`
	`189`	`+ type Err = crate::Error;`
`192`	`190`
`193`	`191`	`#[inline]`
`194`	`192`	`fn from_str(s: &str) -> Result<Self, Self::Err> {`
`195`		`- Inner::from_str(s).map(Self).map_err(\|_\| ())`
	`193`	`+ Inner::from_str(s)`
	`194`	`+ .map(Self)`
	`195`	`+ .map_err(\|_\| crate::Error::BufferOverflow)`
`196`	`196`	`}`
`197`	`197`	`}`
`198`	`198`
`@@ -352,7 +352,7 @@ impl<const N: usize> Ord for String<N> {`
`352`	`352`	`macro_rules! impl_try_from_num {`
`353`	`353`	`($num:ty, $size:expr) => {`
`354`	`354`	`impl<const N: usize> core::convert::TryFrom<$num> for String<N> {`
`355`		`- type Error = ();`
	`355`	`+ type Error = crate::Error;`
`356`	`356`	`#[inline]`
`357`	`357`	`fn try_from(s: $num) -> Result<Self, Self::Error> {`
`358`	`358`	`#[cfg(feature = "alloc")]`
`@@ -361,7 +361,9 @@ macro_rules! impl_try_from_num {`
`361`	`361`	`}`
`362`	`362`	`#[cfg(not(feature = "alloc"))]`
`363`	`363`	`{`
`364`		`- Inner::try_from(s).map(Self)`
	`364`	`+ Inner::try_from(s)`
	`365`	`+ .map(Self)`
	`366`	`+ .map_err(\|_\| crate::Error::BufferOverflow)`
`365`	`367`	`}`
`366`	`368`	`}`
`367`	`369`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ impl<T, const N: usize> Vec<T, N> {`
`35`	`35`
`36`	`36`	/// Constructs a new vector with a capacity of `N` and fills it with the provided slice.
`37`	`37`	`#[inline]`
`38`		`- pub fn from_slice(other: &[T]) -> Result<Self, ()>`
	`38`	`+ pub fn from_slice(other: &[T]) -> crate::Result<Self>`
`39`	`39`	`where`
`40`	`40`	`T: Clone,`
`41`	`41`	`{`
`@@ -113,7 +113,7 @@ impl<T, const N: usize> Vec<T, N> {`
`113`	`113`	/// Iterates over the slice `other`, clones each element, and then appends
`114`	`114`	/// it to this `Vec`. The `other` vector is traversed in-order.
`115`	`115`	`#[inline]`
`116`		`- pub fn extend_from_slice(&mut self, other: &[T]) -> Result<(), ()>`
	`116`	`+ pub fn extend_from_slice(&mut self, other: &[T]) -> crate::Result<()>`
`117`	`117`	`where`
`118`	`118`	`T: Clone,`
`119`	`119`	`{`
`@@ -125,7 +125,9 @@ impl<T, const N: usize> Vec<T, N> {`
`125`	`125`	`}`
`126`	`126`	`#[cfg(not(feature = "alloc"))]`
`127`	`127`	`{`
`128`		`- self.0.extend_from_slice(other)`
	`128`	`+ self.0`
	`129`	`+ .extend_from_slice(other)`
	`130`	`+ .map_err(\|_\| crate::Error::BufferOverflow)`
`129`	`131`	`}`
`130`	`132`	`}`
`131`	`133`
`@@ -183,7 +185,7 @@ impl<T, const N: usize> Vec<T, N> {`
`183`	`185`	`///`
`184`	`186`	/// See also [`resize_default`](Self::resize_default).
`185`	`187`	`#[inline]`
`186`		`- pub fn resize(&mut self, new_len: usize, value: T) -> Result<(), ()>`
	`188`	`+ pub fn resize(&mut self, new_len: usize, value: T) -> crate::Result<()>`
`187`	`189`	`where`
`188`	`190`	`T: Clone,`
`189`	`191`	`{`
`@@ -195,7 +197,9 @@ impl<T, const N: usize> Vec<T, N> {`
`195`	`197`	`}`
`196`	`198`	`#[cfg(not(feature = "alloc"))]`
`197`	`199`	`{`
`198`		`- self.0.resize(new_len, value)`
	`200`	`+ self.0`
	`201`	`+ .resize(new_len, value)`
	`202`	`+ .map_err(\|_\| crate::Error::BufferOverflow)`
`199`	`203`	`}`
`200`	`204`	`}`
`201`	`205`
`@@ -207,7 +211,7 @@ impl<T, const N: usize> Vec<T, N> {`
`207`	`211`	`///`
`208`	`212`	/// See also [`resize`](Self::resize).
`209`	`213`	`#[inline]`
`210`		`- pub fn resize_default(&mut self, new_len: usize) -> Result<(), ()>`
	`214`	`+ pub fn resize_default(&mut self, new_len: usize) -> crate::Result<()>`
`211`	`215`	`where`
`212`	`216`	`T: Clone + Default,`
`213`	`217`	`{`
`@@ -342,7 +346,7 @@ impl<const N: usize> fmt::Write for Vec<u8, N> {`
`342`	`346`	`}`
`343`	`347`
`344`	`348`	`impl<'a, T: Clone, const N: usize> TryFrom<&'a [T]> for Vec<T, N> {`
`345`		`- type Error = ();`
	`349`	`+ type Error = crate::Error;`
`346`	`350`
`347`	`351`	`#[inline]`
`348`	`352`	`fn try_from(slice: &'a [T]) -> Result<Self, Self::Error> {`