Remove generic `Hasher` and `Event` from `subscription::Recipe`

4 files changed, 2 insertions, 265 deletions

diff --git a/native/src/lib.rs b/native/src/lib.rs
index 0fc4f324..2d2e5b38 100644
--- a/native/src/lib.rs
+++ b/native/src/lib.rs
@@ -48,14 +48,11 @@ pub mod command;
 pub mod font;
 pub mod keyboard;
 pub mod program;
-pub mod subscription;
 pub mod system;
 pub mod user_interface;
 pub mod widget;
 pub mod window;
 
-mod runtime;
-
 // We disable debug capabilities on release builds unless the `debug` feature
 // is explicitly enabled.
 #[cfg(feature = "debug")]
@@ -72,6 +69,4 @@ pub use command::Command;
 pub use debug::Debug;
 pub use font::Font;
 pub use program::Program;
-pub use runtime::Runtime;
-pub use subscription::Subscription;
 pub use user_interface::UserInterface;
diff --git a/native/src/runtime.rs b/native/src/runtime.rs
deleted file mode 100644
index 1b81314f..00000000
--- a/native/src/runtime.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//! Run commands and subscriptions.
-use iced_core::event::{self, Event};
-use iced_core::Hasher;
-
-/// A native runtime with a generic executor and receiver of results.
-///
-/// It can be used by shells to easily spawn a [`Command`] or track a
-/// [`Subscription`].
-///
-/// [`Command`]: crate::Command
-/// [`Subscription`]: crate::Subscription
-pub type Runtime<Executor, Receiver, Message> = iced_futures::Runtime<
-    Hasher,
-    (Event, event::Status),
-    Executor,
-    Receiver,
-    Message,
->;
diff --git a/native/src/subscription.rs b/native/src/subscription.rs
index b16bcb03..d4176ab5 100644
--- a/native/src/subscription.rs
+++ b/native/src/subscription.rs
@@ -3,247 +3,7 @@ use crate::core::event::{self, Event};
 use crate::core::window;
 use crate::core::Hasher;
 use crate::futures::futures::{self, Future, Stream};
+use crate::futures::subscription::{EventStream, Recipe, Subscription};
 use crate::futures::{BoxStream, MaybeSend};
 
 use std::hash::Hash;
-
-/// A request to listen to external events.
-///
-/// Besides performing async actions on demand with [`Command`], most
-/// applications also need to listen to external events passively.
-///
-/// A [`Subscription`] is normally provided to some runtime, like a [`Command`],
-/// and it will generate events as long as the user keeps requesting it.
-///
-/// For instance, you can use a [`Subscription`] to listen to a WebSocket
-/// connection, keyboard presses, mouse events, time ticks, etc.
-///
-/// [`Command`]: crate::Command
-pub type Subscription<T> =
-    iced_futures::Subscription<Hasher, (Event, event::Status), T>;
-
-/// A stream of runtime events.
-///
-/// It is the input of a [`Subscription`] in the native runtime.
-pub type EventStream = BoxStream<(Event, event::Status)>;
-
-/// A native [`Subscription`] tracker.
-pub type Tracker =
-    iced_futures::subscription::Tracker<Hasher, (Event, event::Status)>;
-
-pub use iced_futures::subscription::Recipe;
-
-/// Returns a [`Subscription`] to all the ignored runtime events.
-///
-/// This subscription will notify your application of any [`Event`] that was
-/// not captured by any widget.
-pub fn events() -> Subscription<Event> {
-    events_with(|event, status| match status {
-        event::Status::Ignored => Some(event),
-        event::Status::Captured => None,
-    })
-}
-
-/// Returns a [`Subscription`] that filters all the runtime events with the
-/// provided function, producing messages accordingly.
-///
-/// This subscription will call the provided function for every [`Event`]
-/// handled by the runtime. If the function:
-///
-/// - Returns `None`, the [`Event`] will be discarded.
-/// - Returns `Some` message, the `Message` will be produced.
-pub fn events_with<Message>(
-    f: fn(Event, event::Status) -> Option<Message>,
-) -> Subscription<Message>
-where
-    Message: 'static + MaybeSend,
-{
-    #[derive(Hash)]
-    struct EventsWith;
-
-    Subscription::from_recipe(Runner {
-        id: (EventsWith, f),
-        spawn: move |events| {
-            use futures::future;
-            use futures::stream::StreamExt;
-
-            events.filter_map(move |(event, status)| {
-                future::ready(match event {
-                    Event::Window(window::Event::RedrawRequested(_)) => None,
-                    _ => f(event, status),
-                })
-            })
-        },
-    })
-}
-
-pub(crate) fn raw_events<Message>(
-    f: fn(Event, event::Status) -> Option<Message>,
-) -> Subscription<Message>
-where
-    Message: 'static + MaybeSend,
-{
-    #[derive(Hash)]
-    struct RawEvents;
-
-    Subscription::from_recipe(Runner {
-        id: (RawEvents, f),
-        spawn: move |events| {
-            use futures::future;
-            use futures::stream::StreamExt;
-
-            events.filter_map(move |(event, status)| {
-                future::ready(f(event, status))
-            })
-        },
-    })
-}
-
-/// Returns a [`Subscription`] that will call the given function to create and
-/// asynchronously run the given [`Stream`].
-pub fn run<S, Message>(builder: fn() -> S) -> Subscription<Message>
-where
-    S: Stream<Item = Message> + MaybeSend + 'static,
-    Message: 'static,
-{
-    Subscription::from_recipe(Runner {
-        id: builder,
-        spawn: move |_| builder(),
-    })
-}
-
-/// Returns a [`Subscription`] that will create and asynchronously run the
-/// given [`Stream`].
-///
-/// The `id` will be used to uniquely identify the [`Subscription`].
-pub fn run_with_id<I, S, Message>(id: I, stream: S) -> Subscription<Message>
-where
-    I: Hash + 'static,
-    S: Stream<Item = Message> + MaybeSend + 'static,
-    Message: 'static,
-{
-    Subscription::from_recipe(Runner {
-        id,
-        spawn: move |_| stream,
-    })
-}
-
-/// Returns a [`Subscription`] that will create and asynchronously run a
-/// [`Stream`] that will call the provided closure to produce every `Message`.
-///
-/// The `id` will be used to uniquely identify the [`Subscription`].
-///
-/// # Creating an asynchronous worker with bidirectional communication
-/// You can leverage this helper to create a [`Subscription`] that spawns
-/// an asynchronous worker in the background and establish a channel of
-/// communication with an `iced` application.
-///
-/// You can achieve this by creating an `mpsc` channel inside the closure
-/// and returning the `Sender` as a `Message` for the `Application`:
-///
-/// ```
-/// use iced_native::subscription::{self, Subscription};
-/// use iced_native::futures::futures;
-///
-/// use futures::channel::mpsc;
-///
-/// pub enum Event {
-///     Ready(mpsc::Sender<Input>),
-///     WorkFinished,
-///     // ...
-/// }
-///
-/// enum Input {
-///     DoSomeWork,
-///     // ...
-/// }
-///
-/// enum State {
-///     Starting,
-///     Ready(mpsc::Receiver<Input>),
-/// }
-///
-/// fn some_worker() -> Subscription<Event> {
-///     struct SomeWorker;
-///
-///     subscription::unfold(std::any::TypeId::of::<SomeWorker>(), State::Starting, |state| async move {
-///         match state {
-///             State::Starting => {
-///                 // Create channel
-///                 let (sender, receiver) = mpsc::channel(100);
-///
-///                 (Some(Event::Ready(sender)), State::Ready(receiver))
-///             }
-///             State::Ready(mut receiver) => {
-///                 use futures::StreamExt;
-///
-///                 // Read next input sent from `Application`
-///                 let input = receiver.select_next_some().await;
-///
-///                 match input {
-///                     Input::DoSomeWork => {
-///                         // Do some async work...
-///
-///                         // Finally, we can optionally return a message to tell the
-///                         // `Application` the work is done
-///                         (Some(Event::WorkFinished), State::Ready(receiver))
-///                     }
-///                 }
-///             }
-///         }
-///     })
-/// }
-/// ```
-///
-/// Check out the [`websocket`] example, which showcases this pattern to maintain a WebSocket
-/// connection open.
-///
-/// [`websocket`]: https://github.com/iced-rs/iced/tree/0.8/examples/websocket
-pub fn unfold<I, T, Fut, Message>(
-    id: I,
-    initial: T,
-    mut f: impl FnMut(T) -> Fut + MaybeSend + Sync + 'static,
-) -> Subscription<Message>
-where
-    I: Hash + 'static,
-    T: MaybeSend + 'static,
-    Fut: Future<Output = (Option<Message>, T)> + MaybeSend + 'static,
-    Message: 'static + MaybeSend,
-{
-    use futures::future::{self, FutureExt};
-    use futures::stream::StreamExt;
-
-    run_with_id(
-        id,
-        futures::stream::unfold(initial, move |state| f(state).map(Some))
-            .filter_map(future::ready),
-    )
-}
-
-struct Runner<I, F, S, Message>
-where
-    F: FnOnce(EventStream) -> S,
-    S: Stream<Item = Message>,
-{
-    id: I,
-    spawn: F,
-}
-
-impl<I, S, F, Message> Recipe<Hasher, (Event, event::Status)>
-    for Runner<I, F, S, Message>
-where
-    I: Hash + 'static,
-    F: FnOnce(EventStream) -> S,
-    S: Stream<Item = Message> + MaybeSend + 'static,
-{
-    type Output = Message;
-
-    fn hash(&self, state: &mut Hasher) {
-        std::any::TypeId::of::<I>().hash(state);
-        self.id.hash(state);
-    }
-
-    fn stream(self: Box<Self>, input: EventStream) -> BoxStream<Self::Output> {
-        iced_futures::boxed_stream((self.spawn)(input))
-    }
-}
diff --git a/native/src/window.rs b/native/src/window.rs
index 97a96e54..aa3f35c7 100644
--- a/native/src/window.rs
+++ b/native/src/window.rs
@@ -5,7 +5,7 @@ pub use action::Action;
 
 use crate::core::time::Instant;
 use crate::core::window::Event;
-use crate::subscription::{self, Subscription};
+use crate::futures::subscription::{self, Subscription};
 
 /// Subscribes to the frames of the window of the running application.
 ///