Change some associated future trait type names

Author: lachlansneff

src/futures/digital.rs

@@ -42,7 +42,7 @@ use core::future::Future;
 /// Asynchronously wait for a pin to be high.
 pub trait WaitForHigh {
     /// The future returned by the `wait_for_high` function.
-    type WaitForHigh<'a>: Future<Output=()> + 'a
+    type HighFuture<'a>: Future<Output=()> + 'a
     where
         Self: 'a;
 
@@ -52,13 +52,13 @@ pub trait WaitForHigh {
     /// # Note for implementers
     /// The pin may have switched back to low before the task was run after
     /// being woken. The future should still resolve in that case.
-    fn wait_for_high<'a>(&'a mut self) -> Self::WaitForHigh<'a>;
+    fn wait_for_high<'a>(&'a mut self) -> Self::HighFuture<'a>;
 }
 
 /// Asynchronously wait for a pin to be low.
 pub trait WaitForLow {
     /// The future returned by `wait_for_low`.
-    type WaitForLow<'a>: Future<Output = ()> + 'a
+    type LowFuture<'a>: Future<Output = ()> + 'a
     where
         Self: 'a;
 
@@ -68,39 +68,39 @@ pub trait WaitForLow {
     /// # Note for implementers
     /// The pin may have switched back to high before the task was run after
     /// being woken. The future should still resolve in that case.
-    fn wait_for_low<'a>(&'a mut self) -> Self::WaitForLow<'a>;
+    fn wait_for_low<'a>(&'a mut self) -> Self::LowFuture<'a>;
 }
 
 /// Wait for a rising edge (transition from low to high).
 pub trait WaitForRisingEdge {
     /// The future returned from `wait_for_rising_edge`.
-    type WaitForRisingEdgeFuture<'a>: Future<Output = ()> + 'a
+    type RisingFuture<'a>: Future<Output = ()> + 'a
     where
         Self: 'a;
 
     /// Returns a future that resolves when this pin transitions from low to high.
-    fn wait_for_rising_edge<'a>(&'a mut self) -> Self::WaitForRisingEdgeFuture<'a>;
+    fn wait_for_rising_edge<'a>(&'a mut self) -> Self::RisingFuture<'a>;
 }
 
 /// Wait for a falling edge (transition from high to low).
 pub trait WaitForFallingEdge {
     /// The future returned from `wait_for_falling_edge`.
-    type WaitForFallingEdgeFuture<'a>: Future<Output = ()> + 'a
+    type FallingFuture<'a>: Future<Output = ()> + 'a
     where
         Self: 'a;
 
     /// Returns a future that resolves when this pin transitions from high to low.
-    fn wait_for_falling_edge<'a>(&'a mut self) -> Self::WaitForFallingEdgeFuture<'a>;
+    fn wait_for_falling_edge<'a>(&'a mut self) -> Self::FallingFuture<'a>;
 }
 
 /// Wait for any edge (transition from low to high OR high to low).
 pub trait WaitForAnyEdge {
     /// The future returned from `wait_for_any_edge`.
-    type WaitForAnyEdgeFuture<'a>: Future<Output = ()> + 'a
+    type EdgeFuture<'a>: Future<Output = ()> + 'a
     where
         Self: 'a;
 
     /// Returns a future that resolves when this pin undergoes any transition, e.g.
     /// low to high OR high to low.
-    fn wait_for_any_edge<'a>(&'a mut self) -> Self::WaitForAnyEdgeFuture<'a>;
+    fn wait_for_any_edge<'a>(&'a mut self) -> Self::EdgeFuture<'a>;
 }