Introduce MaybeSend trait in iced_futures

It allows to clean up all the `trait_aliases` modules!

futures/src/executor.rs

@@ -33,6 +33,7 @@ pub use self::smol::Smol;
 #[cfg(target_arch = "wasm32")]
 pub use wasm_bindgen::WasmBindgen;
 
+use crate::MaybeSend;
 use futures::Future;
 
 /// A type that can run futures.
@@ -43,12 +44,7 @@ pub trait Executor: Sized {
         Self: Sized;
 
     /// Spawns a future in the [`Executor`].
-    #[cfg(not(target_arch = "wasm32"))]
-    fn spawn(&self, future: impl Future<Output = ()> + Send + 'static);
-
-    /// Spawns a local future in the [`Executor`].
-    #[cfg(target_arch = "wasm32")]
-    fn spawn(&self, future: impl Future<Output = ()> + 'static);
+    fn spawn(&self, future: impl Future<Output = ()> + MaybeSend + 'static);
 
     /// Runs the given closure inside the [`Executor`].
     ///

futures/src/lib.rs

@@ -14,6 +14,7 @@
 pub use futures;
 
 mod command;
+mod maybe_send;
 mod runtime;
 
 pub mod executor;
@@ -35,6 +36,7 @@ pub mod time;
 
 pub use command::Command;
 pub use executor::Executor;
+pub use maybe_send::MaybeSend;
 pub use platform::*;
 pub use runtime::Runtime;
 pub use subscription::Subscription;

futures/src/maybe_send.rs

@@ -0,0 +1,21 @@
+#[cfg(not(target_arch = "wasm32"))]
+mod platform {
+    /// An extension trait that enforces `Send` only on native platforms.
+    ///
+    /// Useful to write cross-platform async code!
+    pub trait MaybeSend: Send {}
+
+    impl<T> MaybeSend for T where T: Send {}
+}
+
+#[cfg(target_arch = "wasm32")]
+mod platform {
+    /// An extension trait that enforces `Send` only on native platforms.
+    ///
+    /// Useful to write cross-platform async code!
+    pub trait MaybeSend {}
+
+    impl<T> MaybeSend for T {}
+}
+
+pub use platform::MaybeSend;

futures/src/runtime.rs

@@ -1,54 +1,10 @@
 //! Run commands and keep track of subscriptions.
-use crate::BoxFuture;
-use crate::{subscription, Executor, Subscription};
+use crate::subscription;
+use crate::{BoxFuture, Executor, MaybeSend, Subscription};
 
 use futures::{channel::mpsc, Sink};
 use std::marker::PhantomData;
 
-#[cfg(not(target_arch = "wasm32"))]
-mod trait_aliases {
-    use super::*;
-
-    pub trait RuntimeMessage: Send + 'static {}
-
-    impl<T> RuntimeMessage for T where T: Send + 'static {}
-
-    pub trait RuntimeMessageSender<Message: RuntimeMessage>:
-        Sink<Message, Error = mpsc::SendError> + Unpin + Send + Clone + 'static
-    {
-    }
-
-    impl<Message: RuntimeMessage, T> RuntimeMessageSender<Message> for T where
-        T: Sink<Message, Error = mpsc::SendError>
-            + Unpin
-            + Send
-            + Clone
-            + 'static
-    {
-    }
-}
-
-#[cfg(target_arch = "wasm32")]
-mod trait_aliases {
-    use super::*;
-
-    pub trait RuntimeMessage: 'static {}
-
-    impl<T> RuntimeMessage for T where T: 'static {}
-
-    pub trait RuntimeMessageSender<Message: RuntimeMessage>:
-        Sink<Message, Error = mpsc::SendError> + Unpin + Clone + 'static
-    {
-    }
-
-    impl<Message: RuntimeMessage, T> RuntimeMessageSender<Message> for T where
-        T: Sink<Message, Error = mpsc::SendError> + Unpin + Clone + 'static
-    {
-    }
-}
-
-pub use trait_aliases::{RuntimeMessage, RuntimeMessageSender};
-
 /// A batteries-included runtime of commands and subscriptions.
 ///
 /// If you have an [`Executor`], a [`Runtime`] can be leveraged to run any
@@ -67,8 +23,12 @@ where
     Hasher: std::hash::Hasher + Default,
     Event: Send + Clone + 'static,
     Executor: self::Executor,
-    Sender: RuntimeMessageSender<Message>,
-    Message: RuntimeMessage,
+    Sender: Sink<Message, Error = mpsc::SendError>
+        + Unpin
+        + MaybeSend
+        + Clone
+        + 'static,
+    Message: MaybeSend + 'static,
 {
     /// Creates a new empty [`Runtime`].
     ///

futures/src/subscription/tracker.rs

@@ -1,52 +1,8 @@
-use crate::{BoxFuture, Subscription};
+use crate::{BoxFuture, MaybeSend, Subscription};
 
 use futures::{channel::mpsc, sink::Sink};
 use std::{collections::HashMap, marker::PhantomData};
 
-#[cfg(not(target_arch = "wasm32"))]
-mod trait_aliases {
-    use super::*;
-
-    pub trait TrackerMessage: Send + 'static {}
-
-    impl<T> TrackerMessage for T where T: Send + 'static {}
-
-    pub trait TrackerMessageReceiver<Message: TrackerMessage>:
-        Sink<Message, Error = mpsc::SendError> + Unpin + Send + Clone + 'static
-    {
-    }
-
-    impl<Message: TrackerMessage, T> TrackerMessageReceiver<Message> for T where
-        T: Sink<Message, Error = mpsc::SendError>
-            + Unpin
-            + Send
-            + Clone
-            + 'static
-    {
-    }
-}
-
-#[cfg(target_arch = "wasm32")]
-mod trait_aliases {
-    use super::*;
-
-    pub trait TrackerMessage: 'static {}
-
-    impl<T> TrackerMessage for T where T: 'static {}
-
-    pub trait TrackerMessageReceiver<Message: TrackerMessage>:
-        Sink<Message, Error = mpsc::SendError> + Unpin + Clone + 'static
-    {
-    }
-
-    impl<Message: TrackerMessage, T> TrackerMessageReceiver<Message> for T where
-        T: Sink<Message, Error = mpsc::SendError> + Unpin + Clone + 'static
-    {
-    }
-}
-
-pub use trait_aliases::{TrackerMessage, TrackerMessageReceiver};
-
 /// A registry of subscription streams.
 ///
 /// If you have an application that continuously returns a [`Subscription`],
@@ -101,8 +57,12 @@ where
         receiver: Receiver,
     ) -> Vec<BoxFuture<()>>
     where
-        Message: TrackerMessage,
-        Receiver: TrackerMessageReceiver<Message>,
+        Message: 'static + MaybeSend,
+        Receiver: 'static
+            + Sink<Message, Error = mpsc::SendError>
+            + Unpin
+            + MaybeSend
+            + Clone,
     {
         use futures::{future::FutureExt, stream::StreamExt};