Unify Application and Program

Instead of creating a separate `multi_window::Program`, the new
`multi_window::Application` unifies both traits

src/multi_window/application.rs

@@ -132,7 +132,7 @@ pub trait Application: Sized {
             ..crate::renderer::Settings::from_env()
         };
 
-        Ok(crate::runtime::application::run::<
+        Ok(crate::runtime::multi_window::run::<
             Instance<Self>,
             Self::Executor,
             crate::renderer::window::Compositor<Self::Theme>,
@@ -142,27 +142,13 @@ pub trait Application: Sized {
 
 struct Instance<A: Application>(A);
 
-impl<A> iced_winit::Program for Instance<A>
+impl<A> crate::runtime::multi_window::Application for Instance<A>
-where
-    A: Application,
-{
-    type Renderer = crate::Renderer<A::Theme>;
-    type Message = A::Message;
-
-    fn update(&mut self, message: Self::Message) -> Command<Self::Message> {
-        self.0.update(message)
-    }
-
-    fn view(&self) -> Element<'_, Self::Message, Self::Renderer> {
-        self.0.view()
-    }
-}
-
-impl<A> crate::runtime::Application for Instance<A>
 where
     A: Application,
 {
     type Flags = A::Flags;
+    type Renderer = crate::Renderer<A::Theme>;
+    type Message = A::Message;
 
     fn new(flags: Self::Flags) -> (Self, Command<A::Message>) {
         let (app, command) = A::new(flags);
@@ -174,6 +160,14 @@ where
         self.0.title()
     }
 
+    fn update(&mut self, message: Self::Message) -> Command<Self::Message> {
+        self.0.update(message)
+    }
+
+    fn view(&self) -> Element<'_, Self::Message, Self::Renderer> {
+        self.0.view()
+    }
+
     fn theme(&self) -> A::Theme {
         self.0.theme()
     }

winit/src/multi_window.rs

@@ -9,15 +9,14 @@ use crate::mouse;
 use crate::renderer;
 use crate::widget::operation;
 use crate::{
-    Command, Debug, Error, Executor, Proxy, Runtime, Settings, Size,
+    Command, Debug, Element, Error, Executor, Proxy, Renderer, Runtime,
-    Subscription,
+    Settings, Size, Subscription,
 };
 
 use iced_futures::futures;
 use iced_futures::futures::channel::mpsc;
 use iced_graphics::compositor;
 use iced_graphics::window;
-use iced_native::program::Program;
 use iced_native::user_interface::{self, UserInterface};
 
 pub use iced_native::application::{Appearance, StyleSheet};
@@ -35,13 +34,34 @@ use std::mem::ManuallyDrop;
 ///
 /// When using an [`Application`] with the `debug` feature enabled, a debug view
 /// can be toggled by pressing `F12`.
-pub trait Application: Program
+pub trait Application: Sized
 where
     <Self::Renderer as crate::Renderer>::Theme: StyleSheet,
 {
     /// The data needed to initialize your [`Application`].
     type Flags;
 
+    /// The graphics backend to use to draw the [`Program`].
+    type Renderer: Renderer;
+
+    /// The type of __messages__ your [`Program`] will produce.
+    type Message: std::fmt::Debug + Send;
+
+    /// Handles a __message__ and updates the state of the [`Program`].
+    ///
+    /// This is where you define your __update logic__. All the __messages__,
+    /// produced by either user interactions or commands, will be handled by
+    /// this method.
+    ///
+    /// Any [`Command`] returned will be executed immediately in the
+    /// background by shells.
+    fn update(&mut self, message: Self::Message) -> Command<Self::Message>;
+
+    /// Returns the widgets to display in the [`Program`].
+    ///
+    /// These widgets can produce __messages__ based on user interaction.
+    fn view(&self) -> Element<'_, Self::Message, Self::Renderer>;
+
     /// Initializes the [`Application`] with the flags provided to
     /// [`run`] as part of the [`Settings`].
     ///