add future support

.github/bors.toml

@@ -3,5 +3,5 @@ delete_merged_branches = true
 required_approvals = 1
 status = [
   "ci-linux (stable, x86_64-unknown-linux-gnu)",
-  "ci-linux (1.35.0, x86_64-unknown-linux-gnu)",
+  "ci-linux (1.39.0, x86_64-unknown-linux-gnu)",
 ]

.github/workflows/ci.yml

@@ -21,7 +21,7 @@ jobs:
 
         include:
           # Test MSRV
-          - rust: 1.35.0
+          - rust: 1.39.0
             TARGET: x86_64-unknown-linux-gnu
 
           # Test nightly but don't fail

Cargo.toml

@@ -10,4 +10,4 @@ homepage = "https://github.com/rust-embedded/nb"
 documentation = "https://docs.rs/nb"
 readme = "README.md"
 version = "1.0.0" # remember to update html_root_url
-edition = "2018"
+edition = "2018"

README.md

@@ -8,7 +8,7 @@ This project is developed and maintained by the [HAL team][team].
 
 ## Minimum Supported Rust Version (MSRV)
 
-This crate is guaranteed to compile on stable Rust 1.35 and up. It *might*
+This crate is guaranteed to compile on stable Rust 1.39 and up. It *might*
 compile with older versions but that may change in any new patch release.
 
 ## License

src/lib.rs

@@ -71,9 +71,11 @@
 //! ```
 //!
 //! Once your API uses [`nb::Result`] you can leverage the [`block!`], macro
-//! to adapt it for blocking operation, or handle scheduling yourself.
+//! to adapt it for blocking operation, or handle scheduling yourself. You can
+//! also use the [`fut!`] macro to use it in an async/await context
 //!
 //! [`block!`]: macro.block.html
+//! [`fut!`]: macro.fut.html
 //! [`nb::Result`]: type.Result.html
 //!
 //! # Examples
@@ -182,11 +184,52 @@
 //! #   }
 //! # }
 //! ```
+//! ## Future mode
+//!
+//! Turn on an LED for one second and *then* loops back serial data.
+//!
+//! ```
+//! use core::convert::Infallible;
+//! use nb::fut;
+//!
+//! use hal::{Led, Serial, Timer};
+//!
+//! # async fn run() -> Result<(), Infallible>{
+//! Led.on();
+//! fut!(Timer.wait()).await;
+//! Led.off();
+//! loop {
+//!     let byte = fut!(Serial.read()).await?;
+//!     fut!(Serial.write(byte)).await?;
+//! }
+//! # }
+//!
+//! # mod hal {
+//! #   use nb;
+//! #   use core::convert::Infallible;
+//! #   pub struct Led;
+//! #   impl Led {
+//! #       pub fn off(&self) {}
+//! #       pub fn on(&self) {}
+//! #   }
+//! #   pub struct Serial;
+//! #   impl Serial {
+//! #       pub fn read(&self) -> nb::Result<u8, Infallible> { Ok(0) }
+//! #       pub fn write(&self, _: u8) -> nb::Result<(), Infallible> { Ok(()) }
+//! #   }
+//! #   pub struct Timer;
+//! #   impl Timer {
+//! #       pub fn wait(&self) -> nb::Result<(), Infallible> { Ok(()) }
+//! #   }
+//! # }
 
 #![no_std]
 #![doc(html_root_url = "https://docs.rs/nb/1.0.0")]
 
 use core::fmt;
+use core::future::Future;
+use core::pin::Pin;
+use core::task::{Context, Poll};
 
 /// A non-blocking result
 pub type Result<T, E> = ::core::result::Result<T, Error<E>>;
@@ -265,3 +308,46 @@ macro_rules! block {
         }
     };
 }
+
+pub struct NbFuture<Ok, Err, Gen: FnMut() -> Result<Ok, Err>> {
+    gen: Gen,
+}
+
+impl<Ok, Err, Gen: FnMut() -> Result<Ok, Err>> From<Gen> for NbFuture<Ok, Err, Gen> {
+    fn from(gen: Gen) -> Self {
+        Self { gen }
+    }
+}
+
+impl<Ok, Err, Gen: FnMut() -> Result<Ok, Err>> Future for NbFuture<Ok, Err, Gen> {
+    type Output = core::result::Result<Ok, Err>;
+
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let gen = unsafe { &mut self.get_unchecked_mut().gen };
+        let res = gen();
+
+        match res {
+            Ok(res) => Poll::Ready(Ok(res)),
+            Err(Error::WouldBlock) => Poll::Pending,
+            Err(Error::Other(err)) => Poll::Ready(Err(err)),
+        }
+    }
+}
+
+/// The equivalent of [block], expect instead of blocking this creates a
+/// [Future] which can `.await`ed.
+///
+/// # Input
+///
+/// An expression `$e` that evaluates to `nb::Result<T, E>`
+///
+/// # Output
+///
+/// - `Ok(t)` if `$e` evaluates to `Ok(t)`
+/// - `Err(e)` if `$e` evaluates to `Err(nb::Error::Other(e))`
+#[macro_export]
+macro_rules! fut {
+    ($call:expr) => {{
+        nb::NbFuture::from(|| $call)
+    }};
+}