Split iced_futures into different backend implementations

futures/src/backend/native/async_std.rs

@@ -0,0 +1,59 @@
+//! An `async-std` backend.
+use futures::Future;
+
+/// An `async-std` executor.
+#[derive(Debug)]
+pub struct Executor;
+
+impl crate::Executor for Executor {
+    fn new() -> Result<Self, futures::io::Error> {
+        Ok(Self)
+    }
+
+    fn spawn(&self, future: impl Future<Output = ()> + Send + 'static) {
+        let _ = async_std::task::spawn(future);
+    }
+}
+
+pub mod time {
+    //! Listen and react to time.
+    use crate::subscription::{self, Subscription};
+
+    /// Returns a [`Subscription`] that produces messages at a set interval.
+    ///
+    /// The first message is produced after a `duration`, and then continues to
+    /// produce more messages every `duration` after that.
+    pub fn every<H: std::hash::Hasher, E>(
+        duration: std::time::Duration,
+    ) -> Subscription<H, E, std::time::Instant> {
+        Subscription::from_recipe(Every(duration))
+    }
+
+    #[derive(Debug)]
+    struct Every(std::time::Duration);
+
+    impl<H, E> subscription::Recipe<H, E> for Every
+    where
+        H: std::hash::Hasher,
+    {
+        type Output = std::time::Instant;
+
+        fn hash(&self, state: &mut H) {
+            use std::hash::Hash;
+
+            std::any::TypeId::of::<Self>().hash(state);
+            self.0.hash(state);
+        }
+
+        fn stream(
+            self: Box<Self>,
+            _input: futures::stream::BoxStream<'static, E>,
+        ) -> futures::stream::BoxStream<'static, Self::Output> {
+            use futures::stream::StreamExt;
+
+            async_std::stream::interval(self.0)
+                .map(|_| std::time::Instant::now())
+                .boxed()
+        }
+    }
+}

futures/src/backend/native/smol.rs

@@ -0,0 +1,59 @@
+//! A `smol` backend.
+
+use futures::Future;
+
+/// A `smol` executor.
+#[cfg_attr(docsrs, doc(cfg(feature = "smol")))]
+#[derive(Debug)]
+pub struct Executor;
+
+impl crate::Executor for Executor {
+    fn new() -> Result<Self, futures::io::Error> {
+        Ok(Self)
+    }
+
+    fn spawn(&self, future: impl Future<Output = ()> + Send + 'static) {
+        smol::spawn(future).detach();
+    }
+}
+
+pub mod time {
+    //! Listen and react to time.
+    use crate::subscription::{self, Subscription};
+
+    /// Returns a [`Subscription`] that produces messages at a set interval.
+    ///
+    /// The first message is produced after a `duration`, and then continues to
+    /// produce more messages every `duration` after that.
+    pub fn every<H: std::hash::Hasher, E>(
+        duration: std::time::Duration,
+    ) -> Subscription<H, E, std::time::Instant> {
+        Subscription::from_recipe(Every(duration))
+    }
+
+    #[derive(Debug)]
+    struct Every(std::time::Duration);
+
+    impl<H, E> subscription::Recipe<H, E> for Every
+    where
+        H: std::hash::Hasher,
+    {
+        type Output = std::time::Instant;
+
+        fn hash(&self, state: &mut H) {
+            use std::hash::Hash;
+
+            std::any::TypeId::of::<Self>().hash(state);
+            self.0.hash(state);
+        }
+
+        fn stream(
+            self: Box<Self>,
+            _input: futures::stream::BoxStream<'static, E>,
+        ) -> futures::stream::BoxStream<'static, Self::Output> {
+            use futures::stream::StreamExt;
+
+            smol::Timer::interval(self.0).boxed()
+        }
+    }
+}

futures/src/backend/native/thread_pool.rs

@@ -0,0 +1,16 @@
+//! A `ThreadPool` backend.
+use futures::Future;
+
+/// A thread pool executor for futures.
+#[cfg_attr(docsrs, doc(cfg(feature = "thread-pool")))]
+pub type ThreadPool = futures::executor::ThreadPool;
+
+impl crate::Executor for futures::executor::ThreadPool {
+    fn new() -> Result<Self, futures::io::Error> {
+        futures::executor::ThreadPool::new()
+    }
+
+    fn spawn(&self, future: impl Future<Output = ()> + Send + 'static) {
+        self.spawn_ok(future);
+    }
+}

futures/src/backend/native/tokio.rs

@@ -0,0 +1,72 @@
+//! A `tokio` backend.
+use futures::Future;
+
+/// A `tokio` executor.
+pub type Executor = tokio::runtime::Runtime;
+
+impl crate::Executor for Executor {
+    fn new() -> Result<Self, futures::io::Error> {
+        tokio::runtime::Runtime::new()
+    }
+
+    fn spawn(&self, future: impl Future<Output = ()> + Send + 'static) {
+        let _ = tokio::runtime::Runtime::spawn(self, future);
+    }
+
+    fn enter<R>(&self, f: impl FnOnce() -> R) -> R {
+        let _guard = tokio::runtime::Runtime::enter(self);
+        f()
+    }
+}
+
+pub mod time {
+    //! Listen and react to time.
+    use crate::subscription::{self, Subscription};
+
+    /// Returns a [`Subscription`] that produces messages at a set interval.
+    ///
+    /// The first message is produced after a `duration`, and then continues to
+    /// produce more messages every `duration` after that.
+    pub fn every<H: std::hash::Hasher, E>(
+        duration: std::time::Duration,
+    ) -> Subscription<H, E, std::time::Instant> {
+        Subscription::from_recipe(Every(duration))
+    }
+
+    #[derive(Debug)]
+    struct Every(std::time::Duration);
+
+    impl<H, E> subscription::Recipe<H, E> for Every
+    where
+        H: std::hash::Hasher,
+    {
+        type Output = std::time::Instant;
+
+        fn hash(&self, state: &mut H) {
+            use std::hash::Hash;
+
+            std::any::TypeId::of::<Self>().hash(state);
+            self.0.hash(state);
+        }
+
+        fn stream(
+            self: Box<Self>,
+            _input: futures::stream::BoxStream<'static, E>,
+        ) -> futures::stream::BoxStream<'static, Self::Output> {
+            use futures::stream::StreamExt;
+
+            let start = tokio::time::Instant::now() + self.0;
+
+            let stream = {
+                futures::stream::unfold(
+                    tokio::time::interval_at(start, self.0),
+                    |mut interval| async move {
+                        Some((interval.tick().await, interval))
+                    },
+                )
+            };
+
+            stream.map(tokio::time::Instant::into_std).boxed()
+        }
+    }
+}