Apply suggestions from code review

Co-authored-by: Diego Barrios Romero <[email protected]>

Author: Dirbaio

embedded-io/CHANGELOG.md

@@ -7,7 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
-- Added `ReadReady`, `WriteReady` traits. They allow peeking whether the i/o handle is ready to read/write, so they allow using the traits in a non-blocking way.
+- Added `ReadReady`, `WriteReady` traits. They allow peeking whether the I/O handle is ready to read/write, so they allow using the traits in a non-blocking way.
 - Moved `embedded_io::blocking` to the crate root.
 - Split async traits to the `embedded-io-async` crate.
 - Split async trait adapters to separate crates.

embedded-io/README.md

@@ -6,7 +6,7 @@
 
 This project is developed and maintained by the [HAL team](https://github.com/rust-embedded/wg#the-hal-team).
 
-IO traits for embedded systems.
+Input/Output traits for embedded systems.
 
 Rust's `std::io` traits are not available in `no_std` targets, mainly because `std::io::Error`
 requires allocation. This crate contains replacement equivalent traits, usable in `no_std`

embedded-io/src/adapters.rs

@@ -3,9 +3,9 @@
 //! To interoperate with `std::io`, wrap a type in one of these
 //! adapters.
 //!
-//! There's no separate adapters for Read/ReadBuf/Write traits. Instead, a single
+//! There are no separate adapters for `Read`/`ReadBuf`/`Write` traits. Instead, a single
 //! adapter implements the right traits based on what the inner type implements.
-//! This allows adapting a `Read+Write`, for example.
+//! This allows using these adapters when using `Read+Write`, for example.
 
 use crate::SeekFrom;
 
@@ -107,26 +107,26 @@ impl<T: ?Sized> ToStd<T> {
 
 impl<T: crate::Read + ?Sized> std::io::Read for ToStd<T> {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize, std::io::Error> {
-        self.inner.read(buf).map_err(to_io_error)
+        self.inner.read(buf).map_err(to_std_error)
     }
 }
 
 impl<T: crate::Write + ?Sized> std::io::Write for ToStd<T> {
     fn write(&mut self, buf: &[u8]) -> Result<usize, std::io::Error> {
-        self.inner.write(buf).map_err(to_io_error)
+        self.inner.write(buf).map_err(to_std_error)
     }
     fn flush(&mut self) -> Result<(), std::io::Error> {
-        self.inner.flush().map_err(to_io_error)
+        self.inner.flush().map_err(to_std_error)
     }
 }
 
 impl<T: crate::Seek + ?Sized> std::io::Seek for ToStd<T> {
     fn seek(&mut self, pos: std::io::SeekFrom) -> Result<u64, std::io::Error> {
-        self.inner.seek(pos.into()).map_err(to_io_error)
+        self.inner.seek(pos.into()).map_err(to_std_error)
     }
 }
 
-fn to_io_error<T: core::fmt::Debug>(err: T) -> std::io::Error {
+fn to_std_error<T: core::fmt::Debug>(err: T) -> std::io::Error {
     let kind = std::io::ErrorKind::Other;
     std::io::Error::new(kind, format!("{:?}", err))
 }

embedded-io/src/lib.rs

@@ -281,7 +281,7 @@ pub trait ReadReady: crate::Io {
 /// This allows using a [`Write`] in a nonblocking fashion, i.e. trying to write
 /// only when it is ready.
 pub trait WriteReady: crate::Io {
-    /// Get whether the writer is ready for immediately writeing.
+    /// Get whether the writer is ready for immediately writing.
     ///
     /// This usually means that there is free space in the internal transmit buffer.
     ///