Merge #431

431: gpio: add ErrorKind. r=Dirbaio a=Dirbaio

This adds an `ErrorKind` to the GPIO `Error` associated type, just like all the other drivers. It has just a single `Other` variant for now. 

The reason to have it is future-proofness: Even if we don't have ideas for ErrorKind variants for now, we might have them in the future.

- If we have `ErrorKind`, we can add more variants in the future backwards-compatibly after the 1.0 launch, thanks to `ErrorKind` being marked `#[non_exhaustive]`.
- If we *don't* have `ErrorKind`, adding it in the future would be a breaking change, because HALs would have to add support for it.

Co-authored-by: Dario Nieuwenhuis <[email protected]>

Author: bors[bot]

embedded-hal/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+### Changed
+- gpio: add `ErrorKind` enum for consistency with other traits and for future extensibility. No kinds are defined for now.
 
 ## [v1.0.0-alpha.9] - 2022-09-28
 

embedded-hal/src/digital.rs

@@ -2,17 +2,63 @@
 
 use core::{convert::From, ops::Not};
 
-/// GPIO error type trait
+/// Error
+pub trait Error: core::fmt::Debug {
+    /// Convert error to a generic error kind
+    ///
+    /// By using this method, errors freely defined by HAL implementations
+    /// can be converted to a set of generic errors upon which generic
+    /// code can act.
+    fn kind(&self) -> ErrorKind;
+}
+
+impl Error for core::convert::Infallible {
+    fn kind(&self) -> ErrorKind {
+        match *self {}
+    }
+}
+
+/// Error kind
+///
+/// This represents a common set of operation errors. HAL implementations are
+/// free to define more specific or additional error types. However, by providing
+/// a mapping to these common errors, generic code can still react to them.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[non_exhaustive]
+pub enum ErrorKind {
+    /// A different error occurred. The original error may contain more information.
+    Other,
+}
+
+impl Error for ErrorKind {
+    fn kind(&self) -> ErrorKind {
+        *self
+    }
+}
+
+impl core::fmt::Display for ErrorKind {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Other => write!(
+                f,
+                "A different error occurred. The original error may contain more information"
+            ),
+        }
+    }
+}
+
+/// Error type trait
 ///
 /// This just defines the error type, to be used by the other traits.
 pub trait ErrorType {
     /// Error type
-    type Error: core::fmt::Debug;
+    type Error: Error;
 }
 
 impl<T: ErrorType> ErrorType for &T {
     type Error = T::Error;
 }
+
 impl<T: ErrorType> ErrorType for &mut T {
     type Error = T::Error;
 }