Rename trait Io to ErrorType.

Author: Dirbaio

embedded-io-async/src/lib.rs

@@ -10,13 +10,13 @@ extern crate alloc;
 mod impls;
 
 pub use embedded_io::{
-    Error, ErrorKind, Io, ReadExactError, ReadReady, SeekFrom, WriteAllError, WriteReady,
+    Error, ErrorKind, ErrorType, ReadExactError, ReadReady, SeekFrom, WriteAllError, WriteReady,
 };
 
 /// Async reader.
 ///
 /// Semantics are the same as [`std::io::Read`], check its documentation for details.
-pub trait Read: Io {
+pub trait Read: ErrorType {
     /// Pull some bytes from this source into the specified buffer, returning how many bytes were read.
     async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>;
 
@@ -40,7 +40,7 @@ pub trait Read: Io {
 /// Async buffered reader.
 ///
 /// Semantics are the same as [`std::io::BufRead`], check its documentation for details.
-pub trait BufRead: Io {
+pub trait BufRead: ErrorType {
     /// Return the contents of the internal buffer, filling it with more data from the inner reader if it is empty.
     async fn fill_buf(&mut self) -> Result<&[u8], Self::Error>;
 
@@ -51,7 +51,7 @@ pub trait BufRead: Io {
 /// Async writer.
 ///
 /// Semantics are the same as [`std::io::Write`], check its documentation for details.
-pub trait Write: Io {
+pub trait Write: ErrorType {
     /// Write a buffer into this writer, returning how many bytes were written.
     async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error>;
 
@@ -77,7 +77,7 @@ pub trait Write: Io {
 /// Async seek within streams.
 ///
 /// Semantics are the same as [`std::io::Seek`], check its documentation for details.
-pub trait Seek: Io {
+pub trait Seek: ErrorType {
     /// Seek to an offset, in bytes, in a stream.
     async fn seek(&mut self, pos: SeekFrom) -> Result<u64, Self::Error>;
 

embedded-io/CHANGELOG.md

@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Moved `embedded_io::blocking` to the crate root.
 - Split async traits to the `embedded-io-async` crate.
 - Split async trait adapters to separate crates.
+- Rename trait `Io` to `ErrorKind`, for consistency with `embedded-hal`.
 
 ## 0.4.0 - 2022-11-25
 

embedded-io/src/adapters.rs

@@ -40,7 +40,7 @@ impl<T: ?Sized> FromStd<T> {
     }
 }
 
-impl<T: ?Sized> crate::Io for FromStd<T> {
+impl<T: ?Sized> crate::ErrorType for FromStd<T> {
     type Error = std::io::Error;
 }
 

embedded-io/src/impls/boxx.rs

@@ -1,8 +1,8 @@
-use crate::{BufRead, Io, Read, ReadReady, Seek, Write, WriteReady};
+use crate::{BufRead, ErrorType, Read, ReadReady, Seek, Write, WriteReady};
 use alloc::boxed::Box;
 
 #[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
-impl<T: ?Sized + Io> Io for Box<T> {
+impl<T: ?Sized + ErrorType> ErrorType for Box<T> {
     type Error = T::Error;
 }
 

embedded-io/src/impls/slice_mut.rs

@@ -1,7 +1,7 @@
-use crate::{Io, Write};
+use crate::{ErrorType, Write};
 use core::mem;
 
-impl Io for &mut [u8] {
+impl ErrorType for &mut [u8] {
     type Error = core::convert::Infallible;
 }
 

embedded-io/src/impls/slice_ref.rs

@@ -1,6 +1,6 @@
-use crate::{BufRead, Io, Read};
+use crate::{BufRead, ErrorType, Read};
 
-impl Io for &[u8] {
+impl ErrorType for &[u8] {
     type Error = core::convert::Infallible;
 }
 

embedded-io/src/impls/vec.rs

@@ -1,8 +1,8 @@
-use crate::{Io, Write};
+use crate::{ErrorType, Write};
 use alloc::vec::Vec;
 
 #[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
-impl Io for Vec<u8> {
+impl ErrorType for Vec<u8> {
     type Error = core::convert::Infallible;
 }
 

embedded-io/src/lib.rs

@@ -55,7 +55,7 @@ impl Error for ErrorKind {
     }
 }
 
-/// Base trait for all IO traits.
+/// Base trait for all IO traits, defining the error type.
 ///
 /// All IO operations of all traits return the error defined in this trait.
 ///
@@ -64,12 +64,12 @@ impl Error for ErrorKind {
 /// This is very convenient when writing generic code, it means you have to
 /// handle a single error type `T::Error`, instead of `<T as Read>::Error` and `<T as Write>::Error`
 /// which might be different types.
-pub trait Io {
+pub trait ErrorType {
     /// Error type of all the IO operations on this type.
     type Error: Error;
 }
 
-impl<T: ?Sized + crate::Io> crate::Io for &mut T {
+impl<T: ?Sized + crate::ErrorType> crate::ErrorType for &mut T {
     type Error = T::Error;
 }
 
@@ -150,7 +150,7 @@ impl<E: fmt::Debug> std::error::Error for WriteAllError<E> {}
 /// Blocking reader.
 ///
 /// Semantics are the same as [`std::io::Read`], check its documentation for details.
-pub trait Read: crate::Io {
+pub trait Read: crate::ErrorType {
     /// Pull some bytes from this source into the specified buffer, returning how many bytes were read.
     fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>;
 
@@ -174,7 +174,7 @@ pub trait Read: crate::Io {
 /// Blocking buffered reader.
 ///
 /// Semantics are the same as [`std::io::BufRead`], check its documentation for details.
-pub trait BufRead: crate::Io {
+pub trait BufRead: crate::ErrorType {
     /// Return the contents of the internal buffer, filling it with more data from the inner reader if it is empty.
     fn fill_buf(&mut self) -> Result<&[u8], Self::Error>;
 
@@ -185,7 +185,7 @@ pub trait BufRead: crate::Io {
 /// Blocking writer.
 ///
 /// Semantics are the same as [`std::io::Write`], check its documentation for details.
-pub trait Write: crate::Io {
+pub trait Write: crate::ErrorType {
     /// Write a buffer into this writer, returning how many bytes were written.
     fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error>;
 
@@ -246,7 +246,7 @@ pub trait Write: crate::Io {
 /// Blocking seek within streams.
 ///
 /// Semantics are the same as [`std::io::Seek`], check its documentation for details.
-pub trait Seek: crate::Io {
+pub trait Seek: crate::ErrorType {
     /// Seek to an offset, in bytes, in a stream.
     fn seek(&mut self, pos: crate::SeekFrom) -> Result<u64, Self::Error>;
 
@@ -266,7 +266,7 @@ pub trait Seek: crate::Io {
 ///
 /// This allows using a [`Read`] or [`BufRead`] in a nonblocking fashion, i.e. trying to read
 /// only when it is ready.
-pub trait ReadReady: crate::Io {
+pub trait ReadReady: crate::ErrorType {
     /// Get whether the reader is ready for immediately reading.
     ///
     /// This usually means that there is either some bytes have been received and are buffered and ready to be read,
@@ -280,7 +280,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 {
+pub trait WriteReady: crate::ErrorType {
     /// Get whether the writer is ready for immediately writing.
     ///
     /// This usually means that there is free space in the internal transmit buffer.