fix: simplify the no-std error code

As the no-std `Error` is a trimmed down version specifically for this
library, it can be simplified.

Also add some doc comments back in.

Author: vmx

src/no_std_io/error.rs

@@ -3,28 +3,14 @@ use core::{fmt, result};
 pub(super) type Result<T> = result::Result<T, Error>;
 
 /// A minimal backfill of the [`std::io::Error`] for `no_std` environments.
-pub struct Error {
-    repr: Repr,
-}
-
-impl core::error::Error for Error {}
-
-impl fmt::Debug for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Debug::fmt(&self.repr, f)
-    }
-}
-
-enum Repr {
-    Custom(Custom),
-}
-
 #[derive(Debug)]
-struct Custom {
+pub struct Error {
     kind: ErrorKind,
     error: &'static str,
 }
 
+impl core::error::Error for Error {}
+
 /// A list specifying general categories of I/O error.
 ///
 /// This list is intended to grow over time and it is not recommended to
@@ -66,35 +52,17 @@ impl Error {
     /// originate from the OS itself. The `error` argument is an arbitrary
     /// payload which will be contained in this [`Error`].
     pub(super) fn new(kind: ErrorKind, error: &'static str) -> Error {
-        Self::_new(kind, error)
-    }
-
-    fn _new(kind: ErrorKind, error: &'static str) -> Error {
-        Error {
-            repr: Repr::Custom(Custom { kind, error }),
-        }
+        Error { kind, error }
     }
 
     /// Returns the corresponding [`ErrorKind`] for this error.
     pub(super) fn kind(&self) -> ErrorKind {
-        match self.repr {
-            Repr::Custom(ref c) => c.kind,
-        }
-    }
-}
-
-impl fmt::Debug for Repr {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {
-            Repr::Custom(ref c) => fmt::Debug::fmt(&c, fmt),
-        }
+        self.kind
     }
 }
 
 impl fmt::Display for Error {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self.repr {
-            Repr::Custom(ref c) => c.error.fmt(fmt),
-        }
+        self.error.fmt(fmt)
     }
 }

src/no_std_io/impls.rs

@@ -1,5 +1,3 @@
-//! Ported from <https://docs.rs/crate/core2/0.4.0/source/src/io/impls.rs>
-
 use super::error::{Error, ErrorKind, Result};
 use super::traits::{Read, Write};
 
@@ -22,6 +20,10 @@ impl<W: Write + ?Sized> Write for &mut W {
     }
 }
 
+/// Read is implemented for `&[u8]` by copying from the slice.
+///
+/// Note that reading updates the slice to point to the yet unread part.
+/// The slice will be empty when EOF is reached.
 impl Read for &[u8] {
     #[inline]
     fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
@@ -65,6 +67,11 @@ impl Read for &[u8] {
     }
 }
 
+/// Write is implemented for `&mut [u8]` by copying into the slice, overwriting
+/// its data.
+///
+/// Note that writing updates the slice to point to the yet unwritten part.
+/// The slice will be empty when it has been completely overwritten.
 impl Write for &mut [u8] {
     #[inline]
     fn write(&mut self, data: &[u8]) -> Result<usize> {
@@ -88,6 +95,8 @@ impl Write for &mut [u8] {
     }
 }
 
+/// Write is implemented for `Vec<u8>` by appending to the vector.
+/// The vector will grow as needed.
 #[cfg(feature = "alloc")]
 impl Write for alloc::vec::Vec<u8> {
     #[inline]