Fix some docs in the futures module

Author: lachlansneff

src/futures/delay.rs

@@ -8,6 +8,18 @@
 use core::{future::Future, time::Duration};
 
 /// Asynchronously wait a duration of time.
+///
+/// # Example
+/// ```rust
+/// # use embedded_hal::futures::delay::Delay;
+/// use core::time::Duration;
+///
+/// async fn wait_100_micros<D: Delay>(timer: &D) {
+///     timer.delay(Duration::from_micros(100))
+///         .await
+///         .expect("failed to await on timer");
+/// }
+/// ```
 pub trait Delay {
     /// Enumeration of `Delay` errors.
     type Error;

src/futures/digital.rs

@@ -14,14 +14,18 @@ use crate::blocking::digital::InputPin;
 /// where
 ///     P: AsyncInputPin,
 /// {
-///     ready_pin.until_high().await
+///     ready_pin
+///         .until_high()
+///         .await
+///         .expect("failed to await input pin")
 /// }
 /// ```
 ///
 /// ```rust,ignore
 /// # use embedded_hal::futures::digital::AsyncInputPin;
 /// # use embedded_hal::futures::delay::Delay;
-/// # use core::time::Duration;
+/// use core::time::Duration;
+///
 /// /// Wait until the `ready_pin` is high or timeout after 1 millisecond.
 /// /// Returns true is the pin became high or false if it timed-out.
 /// async fn wait_until_ready_or_timeout<P, D>(ready_pin: &P, delay: &mut D) -> bool
@@ -30,17 +34,20 @@ use crate::blocking::digital::InputPin;
 ///     D: Delay,
 /// {
 ///     futures::select_biased! {
-///         _ => ready_pin.until_high() => true,
-///         _ => delay.delay(Duration::from_millis(1)) => false,
+///         x => ready_pin.until_high() => {
+///             x.expect("failed to await input pin");
+///             true
+///         },
+///         _ => delay.delay(Duration::from_millis(1)) => false, // ignore the error
 ///     }
 /// }
 /// ```
 pub trait AsyncInputPin: InputPin {
     /// The future returned by the `until_high` function.
-    type UntilHighFuture<'a>: Future<Output=()> + 'a;
+    type UntilHighFuture<'a>: Future<Output=Result<(), Self::Error>> + 'a;
 
     /// The future returned by the `until_low` function.
-    type UntilLowFuture<'a>: Future<Output=()> + 'a;
+    type UntilLowFuture<'a>: Future<Output=Result<(), Self::Error>> + 'a;
 
     /// Returns a future that resolves when this pin becomes high.
     fn until_high<'a>(&self) -> Self::UntilHighFuture<'a>;