Remove allow(clippy::result_unit_err)

Unit error types do not implement core::error::Error which leads to some
ergonomic issues.

Author: newAM

CHANGELOG.md

@@ -44,6 +44,13 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Changed
 
+- Changed the error type of these methods from `()` to `CapacityError`.
+  - `String::push_str`
+  - `String::push`
+  - `Vec::extend_from_slice`
+  - `Vec::from_slice`
+  - `Vec::resize_default`
+  - `Vec::resize`
 - Changed `stable_deref_trait` to a platform-dependent dependency.
 
 ### Fixed

src/string/mod.rs

@@ -13,7 +13,7 @@ use core::{
 
 use crate::{
     storage::{OwnedStorage, Storage, ViewStorage},
-    vec::VecInner,
+    vec::{CapacityError, VecInner},
     Vec,
 };
 
@@ -28,20 +28,28 @@ pub use drain::Drain;
 #[derive(Debug)]
 pub enum FromUtf16Error {
     /// The capacity of the `String` is too small for the given operation.
-    Capacity,
+    Capacity(CapacityError),
     /// Error decoding UTF-16.
     DecodeUtf16Error(DecodeUtf16Error),
 }
 
 impl fmt::Display for FromUtf16Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::Capacity => "insufficient capacity".fmt(f),
+            Self::Capacity(e) => write!(f, "{}", e),
             Self::DecodeUtf16Error(e) => write!(f, "invalid UTF-16: {}", e),
         }
     }
 }
 
+impl core::error::Error for FromUtf16Error {}
+
+impl From<CapacityError> for FromUtf16Error {
+    fn from(e: CapacityError) -> Self {
+        FromUtf16Error::Capacity(e)
+    }
+}
+
 /// Base struct for [`String`] and [`StringView`], generic over the [`Storage`].
 ///
 /// In most cases you should use [`String`] or [`StringView`] directly. Only use this
@@ -168,7 +176,7 @@ impl<const N: usize> String<N> {
         for c in char::decode_utf16(v.iter().cloned()) {
             match c {
                 Ok(c) => {
-                    s.push(c).map_err(|_| FromUtf16Error::Capacity)?;
+                    s.push(c)?;
                 }
                 Err(err) => {
                     return Err(FromUtf16Error::DecodeUtf16Error(err));
@@ -257,7 +265,7 @@ impl<const N: usize> String<N> {
     /// assert!(b.len() == 2);
     ///
     /// assert_eq!(&[b'a', b'b'], &b[..]);
-    /// # Ok::<(), ()>(())
+    /// # Ok::<(), heapless::vec::CapacityError>(())
     /// ```
     #[inline]
     pub fn into_bytes(self) -> Vec<u8, N> {
@@ -364,7 +372,7 @@ impl<S: Storage> StringInner<S> {
     ///
     /// let _s = s.as_str();
     /// // s.push('c'); // <- cannot borrow `s` as mutable because it is also borrowed as immutable
-    /// # Ok::<(), ()>(())
+    /// # Ok::<(), heapless::vec::CapacityError>(())
     /// ```
     #[inline]
     pub fn as_str(&self) -> &str {
@@ -383,7 +391,7 @@ impl<S: Storage> StringInner<S> {
     /// let mut s: String<4> = String::try_from("ab")?;
     /// let s = s.as_mut_str();
     /// s.make_ascii_uppercase();
-    /// # Ok::<(), ()>(())
+    /// # Ok::<(), heapless::vec::CapacityError>(())
     /// ```
     #[inline]
     pub fn as_mut_str(&mut self) -> &mut str {
@@ -415,7 +423,7 @@ impl<S: Storage> StringInner<S> {
     ///     vec.reverse();
     /// }
     /// assert_eq!(s, "olleh");
-    /// # Ok::<(), ()>(())
+    /// # Ok::<(), heapless::vec::CapacityError>(())
     /// ```
     pub unsafe fn as_mut_vec(&mut self) -> &mut VecInner<u8, S> {
         &mut self.vec
@@ -437,11 +445,10 @@ impl<S: Storage> StringInner<S> {
     /// assert_eq!("foobar", s);
     ///
     /// assert!(s.push_str("tender").is_err());
-    /// # Ok::<(), ()>(())
+    /// # Ok::<(), heapless::vec::CapacityError>(())
     /// ```
     #[inline]
-    #[allow(clippy::result_unit_err)]
-    pub fn push_str(&mut self, string: &str) -> Result<(), ()> {
+    pub fn push_str(&mut self, string: &str) -> Result<(), CapacityError> {
         self.vec.extend_from_slice(string.as_bytes())
     }
 
@@ -480,13 +487,12 @@ impl<S: Storage> StringInner<S> {
     /// assert!("abc123" == s.as_str());
     ///
     /// assert_eq!("abc123", s);
-    /// # Ok::<(), ()>(())
+    /// # Ok::<(), heapless::vec::CapacityError>(())
     /// ```
     #[inline]
-    #[allow(clippy::result_unit_err)]
-    pub fn push(&mut self, c: char) -> Result<(), ()> {
+    pub fn push(&mut self, c: char) -> Result<(), CapacityError> {
         match c.len_utf8() {
-            1 => self.vec.push(c as u8).map_err(|_| {}),
+            1 => self.vec.push(c as u8).map_err(|_| CapacityError {}),
             _ => self
                 .vec
                 .extend_from_slice(c.encode_utf8(&mut [0; 4]).as_bytes()),
@@ -517,7 +523,7 @@ impl<S: Storage> StringInner<S> {
     /// s.truncate(2);
     ///
     /// assert_eq!("he", s);
-    /// # Ok::<(), ()>(())
+    /// # Ok::<(), heapless::vec::CapacityError>(())
     /// ```
     #[inline]
     pub fn truncate(&mut self, new_len: usize) {
@@ -545,7 +551,7 @@ impl<S: Storage> StringInner<S> {
     /// assert_eq!(s.pop(), Some('f'));
     ///
     /// assert_eq!(s.pop(), None);
-    /// Ok::<(), ()>(())
+    /// # Ok::<(), heapless::vec::CapacityError>(())
     /// ```
     pub fn pop(&mut self) -> Option<char> {
         let ch = self.chars().next_back()?;
@@ -577,11 +583,12 @@ impl<S: Storage> StringInner<S> {
     /// ```
     /// use heapless::String;
     ///
-    /// let mut s: String<8> = String::try_from("foo").unwrap();
+    /// let mut s: String<8> = String::try_from("foo")?;
     ///
     /// assert_eq!(s.remove(0), 'f');
     /// assert_eq!(s.remove(1), 'o');
     /// assert_eq!(s.remove(0), 'o');
+    /// # Ok::<(), heapless::vec::CapacityError>(())
     /// ```
     #[inline]
     pub fn remove(&mut self, index: usize) -> char {
@@ -619,7 +626,7 @@ impl<S: Storage> StringInner<S> {
     /// assert!(s.is_empty());
     /// assert_eq!(0, s.len());
     /// assert_eq!(8, s.capacity());
-    /// Ok::<(), ()>(())
+    /// # Ok::<(), heapless::vec::CapacityError>(())
     /// ```
     #[inline]
     pub fn clear(&mut self) {
@@ -634,7 +641,7 @@ impl<const N: usize> Default for String<N> {
 }
 
 impl<'a, const N: usize> TryFrom<&'a str> for String<N> {
-    type Error = ();
+    type Error = CapacityError;
     fn try_from(s: &'a str) -> Result<Self, Self::Error> {
         let mut new = String::new();
         new.push_str(s)?;
@@ -643,7 +650,7 @@ impl<'a, const N: usize> TryFrom<&'a str> for String<N> {
 }
 
 impl<const N: usize> str::FromStr for String<N> {
-    type Err = ();
+    type Err = CapacityError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let mut new = String::new();
@@ -912,7 +919,7 @@ impl_try_from_num!(u64, 20);
 
 #[cfg(test)]
 mod tests {
-    use crate::{String, Vec};
+    use crate::{vec::CapacityError, String, Vec};
 
     #[test]
     fn static_new() {
@@ -980,7 +987,7 @@ mod tests {
         assert!(s.len() == 3);
         assert_eq!(s, "123");
 
-        let _: () = String::<2>::try_from("123").unwrap_err();
+        let _: CapacityError = String::<2>::try_from("123").unwrap_err();
     }
 
     #[test]
@@ -991,7 +998,7 @@ mod tests {
         assert!(s.len() == 3);
         assert_eq!(s, "123");
 
-        let _: () = String::<2>::from_str("123").unwrap_err();
+        let _: CapacityError = String::<2>::from_str("123").unwrap_err();
     }
 
     #[test]

src/ufmt.rs

@@ -1,15 +1,19 @@
-use crate::{storage::Storage, string::StringInner, vec::VecInner};
+use crate::{
+    storage::Storage,
+    string::StringInner,
+    vec::{CapacityError, VecInner},
+};
 use ufmt_write::uWrite;
 
 impl<S: Storage> uWrite for StringInner<S> {
-    type Error = ();
+    type Error = CapacityError;
     fn write_str(&mut self, s: &str) -> Result<(), Self::Error> {
         self.push_str(s)
     }
 }
 
 impl<S: Storage> uWrite for VecInner<u8, S> {
-    type Error = ();
+    type Error = CapacityError;
     fn write_str(&mut self, s: &str) -> Result<(), Self::Error> {
         self.extend_from_slice(s.as_bytes())
     }

src/vec/mod.rs

@@ -16,6 +16,18 @@ use crate::storage::{OwnedStorage, Storage, ViewStorage};
 mod drain;
 pub use drain::Drain;
 
+/// The error type for fallible [`Vec`] and [`String`](crate::String) methods.
+#[derive(Debug)]
+pub struct CapacityError;
+
+impl fmt::Display for CapacityError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("insufficient capacity")
+    }
+}
+
+impl core::error::Error for CapacityError {}
+
 /// Base struct for [`Vec`] and [`VecView`], generic over the [`Storage`].
 ///
 /// In most cases you should use [`Vec`] or [`VecView`] directly. Only use this
@@ -122,8 +134,7 @@ impl<T, const N: usize> Vec<T, N> {
     /// let mut v: Vec<u8, 16> = Vec::new();
     /// v.extend_from_slice(&[1, 2, 3]).unwrap();
     /// ```
-    #[allow(clippy::result_unit_err)]
-    pub fn from_slice(other: &[T]) -> Result<Self, ()>
+    pub fn from_slice(other: &[T]) -> Result<Self, CapacityError>
     where
         T: Clone,
     {
@@ -453,22 +464,21 @@ impl<T, S: Storage> VecInner<T, S> {
     /// vec.extend_from_slice(&[2, 3, 4]).unwrap();
     /// assert_eq!(*vec, [1, 2, 3, 4]);
     /// ```
-    #[allow(clippy::result_unit_err)]
-    pub fn extend_from_slice(&mut self, other: &[T]) -> Result<(), ()>
+    pub fn extend_from_slice(&mut self, other: &[T]) -> Result<(), CapacityError>
     where
         T: Clone,
     {
         pub fn extend_from_slice_inner<T>(
             len: &mut usize,
             buf: &mut [MaybeUninit<T>],
             other: &[T],
-        ) -> Result<(), ()>
+        ) -> Result<(), CapacityError>
         where
             T: Clone,
         {
             if *len + other.len() > buf.len() {
                 // won't fit in the `Vec`; don't modify anything and return an error
-                Err(())
+                Err(CapacityError {})
             } else {
                 for elem in other {
                     unsafe { *buf.get_unchecked_mut(*len) = MaybeUninit::new(elem.clone()) }
@@ -563,13 +573,12 @@ impl<T, S: Storage> VecInner<T, S> {
     /// new_len is less than len, the Vec is simply truncated.
     ///
     /// See also [`resize_default`](Self::resize_default).
-    #[allow(clippy::result_unit_err)]
-    pub fn resize(&mut self, new_len: usize, value: T) -> Result<(), ()>
+    pub fn resize(&mut self, new_len: usize, value: T) -> Result<(), CapacityError>
     where
         T: Clone,
     {
         if new_len > self.storage_capacity() {
-            return Err(());
+            return Err(CapacityError {});
         }
 
         if new_len > self.len {
@@ -590,8 +599,7 @@ impl<T, S: Storage> VecInner<T, S> {
     /// If `new_len` is less than `len`, the `Vec` is simply truncated.
     ///
     /// See also [`resize`](Self::resize).
-    #[allow(clippy::result_unit_err)]
-    pub fn resize_default(&mut self, new_len: usize) -> Result<(), ()>
+    pub fn resize_default(&mut self, new_len: usize) -> Result<(), CapacityError>
     where
         T: Clone + Default,
     {
@@ -1148,7 +1156,7 @@ impl<T, S: Storage> Drop for VecInner<T, S> {
 }
 
 impl<'a, T: Clone, const N: usize> TryFrom<&'a [T]> for Vec<T, N> {
-    type Error = ();
+    type Error = CapacityError;
 
     fn try_from(slice: &'a [T]) -> Result<Self, Self::Error> {
         Vec::from_slice(slice)