Allow pure widgets to borrow from Application data 🎉

pure/src/application.rs

@@ -1 +0,0 @@
-

pure/src/lib.rs

@@ -11,7 +11,8 @@ use iced_native::renderer;
 use iced_native::{Clipboard, Hasher, Length, Point, Rectangle, Shell};
 
 pub struct Pure<'a, Message, Renderer> {
-    state: &'a mut State<Message, Renderer>,
+    state: &'a mut State,
+    element: Element<'a, Message, Renderer>,
 }
 
 impl<'a, Message, Renderer> Pure<'a, Message, Renderer>
@@ -20,38 +21,32 @@ where
     Renderer: iced_native::Renderer + 'static,
 {
     pub fn new(
-        state: &'a mut State<Message, Renderer>,
+        state: &'a mut State,
-        content: impl Into<Element<Message, Renderer>>,
+        content: impl Into<Element<'a, Message, Renderer>>,
     ) -> Self {
-        let _ = state.diff(content.into());
+        let element = content.into();
+        let _ = state.diff(&element);
 
-        Self { state }
+        Self { state, element }
     }
 }
 
-pub struct State<Message, Renderer> {
+pub struct State {
-    state_tree: widget::Tree<Message, Renderer>,
+    state_tree: widget::Tree,
-    last_element: Element<Message, Renderer>,
 }
 
-impl<Message, Renderer> State<Message, Renderer>
+impl State {
-where
-    Message: 'static,
-    Renderer: iced_native::Renderer + 'static,
-{
     pub fn new() -> Self {
-        let last_element = Element::new(widget::Column::new());
-
         Self {
-            state_tree: widget::Tree::new(&last_element),
+            state_tree: widget::Tree::empty(),
-            last_element,
         }
     }
 
-    fn diff(&mut self, new_element: Element<Message, Renderer>) {
+    fn diff<Message, Renderer>(
-        self.state_tree.diff(&self.last_element, &new_element);
+        &mut self,
-
+        new_element: &Element<Message, Renderer>,
-        self.last_element = new_element;
+    ) {
+        self.state_tree.diff(new_element);
     }
 }
 
@@ -61,15 +56,15 @@ where
     Renderer: iced_native::Renderer,
 {
     fn width(&self) -> Length {
-        self.state.last_element.as_widget().width()
+        self.element.as_widget().width()
     }
 
     fn height(&self) -> Length {
-        self.state.last_element.as_widget().height()
+        self.element.as_widget().height()
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
-        self.state.last_element.as_widget().hash_layout(state)
+        self.element.as_widget().hash_layout(state)
     }
 
     fn layout(
@@ -77,7 +72,7 @@ where
         renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
-        self.state.last_element.as_widget().layout(renderer, limits)
+        self.element.as_widget().layout(renderer, limits)
     }
 
     fn on_event(
@@ -89,7 +84,7 @@ where
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
     ) -> event::Status {
-        self.state.last_element.as_widget_mut().on_event(
+        self.element.as_widget_mut().on_event(
             &mut self.state.state_tree,
             event,
             layout,
@@ -108,7 +103,7 @@ where
         cursor_position: Point,
         viewport: &Rectangle,
     ) {
-        self.state.last_element.as_widget().draw(
+        self.element.as_widget().draw(
             &self.state.state_tree,
             renderer,
             style,
@@ -125,7 +120,7 @@ where
         viewport: &Rectangle,
         renderer: &Renderer,
     ) -> mouse::Interaction {
-        self.state.last_element.as_widget().mouse_interaction(
+        self.element.as_widget().mouse_interaction(
             &self.state.state_tree,
             layout,
             cursor_position,
@@ -138,7 +133,8 @@ where
 impl<'a, Message, Renderer> Into<iced_native::Element<'a, Message, Renderer>>
     for Pure<'a, Message, Renderer>
 where
-    Renderer: iced_native::Renderer,
+    Message: 'a,
+    Renderer: iced_native::Renderer + 'a,
 {
     fn into(self) -> iced_native::Element<'a, Message, Renderer> {
         iced_native::Element::new(self)

pure/src/widget.rs

@@ -39,7 +39,7 @@ pub trait Widget<Message, Renderer> {
 
     fn draw(
         &self,
-        state: &Tree<Message, Renderer>,
+        state: &Tree,
         renderer: &mut Renderer,
         style: &renderer::Style,
         layout: Layout<'_>,
@@ -49,7 +49,7 @@ pub trait Widget<Message, Renderer> {
 
     fn mouse_interaction(
         &self,
-        _state: &Tree<Message, Renderer>,
+        _state: &Tree,
         _layout: Layout<'_>,
         _cursor_position: Point,
         _viewport: &Rectangle,
@@ -60,7 +60,7 @@ pub trait Widget<Message, Renderer> {
 
     fn on_event(
         &mut self,
-        _state: &mut Tree<Message, Renderer>,
+        _state: &mut Tree,
         _event: Event,
         _layout: Layout<'_>,
         _cursor_position: Point,
@@ -72,13 +72,13 @@ pub trait Widget<Message, Renderer> {
     }
 }
 
-pub fn column<Message, Renderer>() -> Column<Message, Renderer> {
+pub fn column<'a, Message, Renderer>() -> Column<'a, Message, Renderer> {
     Column::new()
 }
 
-pub fn button<Message, Renderer>(
+pub fn button<'a, Message, Renderer>(
-    content: impl Into<Element<Message, Renderer>>,
+    content: impl Into<Element<'a, Message, Renderer>>,
-) -> Button<Message, Renderer> {
+) -> Button<'a, Message, Renderer> {
     Button::new(content)
 }
 

pure/src/widget/button.rs

@@ -13,17 +13,17 @@ use iced_style::button::StyleSheet;
 
 use std::any::Any;
 
-pub struct Button<Message, Renderer> {
+pub struct Button<'a, Message, Renderer> {
-    content: Element<Message, Renderer>,
+    content: Element<'a, Message, Renderer>,
     on_press: Option<Message>,
-    style_sheet: Box<dyn StyleSheet>,
+    style_sheet: Box<dyn StyleSheet + 'a>,
     width: Length,
     height: Length,
     padding: Padding,
 }
 
-impl<Message, Renderer> Button<Message, Renderer> {
+impl<'a, Message, Renderer> Button<'a, Message, Renderer> {
-    pub fn new(content: impl Into<Element<Message, Renderer>>) -> Self {
+    pub fn new(content: impl Into<Element<'a, Message, Renderer>>) -> Self {
         Button {
             content: content.into(),
             on_press: None,
@@ -40,7 +40,8 @@ impl<Message, Renderer> Button<Message, Renderer> {
     }
 }
 
-impl<Message, Renderer> Widget<Message, Renderer> for Button<Message, Renderer>
+impl<'a, Message, Renderer> Widget<Message, Renderer>
+    for Button<'a, Message, Renderer>
 where
     Message: 'static + Clone,
     Renderer: 'static + iced_native::Renderer,
@@ -96,7 +97,7 @@ where
 
     fn on_event(
         &mut self,
-        tree: &mut Tree<Message, Renderer>,
+        tree: &mut Tree,
         event: Event,
         layout: Layout<'_>,
         cursor_position: Point,
@@ -162,7 +163,7 @@ where
 
     fn draw(
         &self,
-        tree: &Tree<Message, Renderer>,
+        tree: &Tree,
         renderer: &mut Renderer,
         _style: &renderer::Style,
         layout: Layout<'_>,
@@ -238,7 +239,7 @@ where
 
     fn mouse_interaction(
         &self,
-        _tree: &Tree<Message, Renderer>,
+        _tree: &Tree,
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
@@ -260,13 +261,13 @@ struct State {
     is_pressed: bool,
 }
 
-impl<Message, Renderer> Into<Element<Message, Renderer>>
+impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
-    for Button<Message, Renderer>
+    for Button<'a, Message, Renderer>
 where
     Message: Clone + 'static,
     Renderer: iced_native::Renderer + 'static,
 {
-    fn into(self) -> Element<Message, Renderer> {
+    fn into(self) -> Element<'a, Message, Renderer> {
         Element::new(self)
     }
 }

pure/src/widget/column.rs

@@ -11,21 +11,23 @@ use iced_native::{
 
 use std::any::{self, Any};
 
-pub struct Column<Message, Renderer> {
+pub struct Column<'a, Message, Renderer> {
     spacing: u16,
     padding: Padding,
     width: Length,
     height: Length,
     align_items: Alignment,
-    children: Vec<Element<Message, Renderer>>,
+    children: Vec<Element<'a, Message, Renderer>>,
 }
 
-impl<'a, Message, Renderer> Column<Message, Renderer> {
+impl<'a, Message, Renderer> Column<'a, Message, Renderer> {
     pub fn new() -> Self {
         Self::with_children(Vec::new())
     }
 
-    pub fn with_children(children: Vec<Element<Message, Renderer>>) -> Self {
+    pub fn with_children(
+        children: Vec<Element<'a, Message, Renderer>>,
+    ) -> Self {
         Column {
             spacing: 0,
             padding: Padding::ZERO,
@@ -63,14 +65,15 @@ impl<'a, Message, Renderer> Column<Message, Renderer> {
 
     pub fn push(
         mut self,
-        child: impl Into<Element<Message, Renderer>>,
+        child: impl Into<Element<'a, Message, Renderer>>,
     ) -> Self {
         self.children.push(child.into());
         self
     }
 }
 
-impl<Message, Renderer> Widget<Message, Renderer> for Column<Message, Renderer>
+impl<'a, Message, Renderer> Widget<Message, Renderer>
+    for Column<'a, Message, Renderer>
 where
     Renderer: iced_native::Renderer,
 {
@@ -115,7 +118,7 @@ where
 
     fn on_event(
         &mut self,
-        tree: &mut Tree<Message, Renderer>,
+        tree: &mut Tree,
         event: Event,
         layout: Layout<'_>,
         cursor_position: Point,
@@ -143,7 +146,7 @@ where
 
     fn mouse_interaction(
         &self,
-        tree: &Tree<Message, Renderer>,
+        tree: &Tree,
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
@@ -168,7 +171,7 @@ where
 
     fn draw(
         &self,
-        tree: &Tree<Message, Renderer>,
+        tree: &Tree,
         renderer: &mut Renderer,
         style: &renderer::Style,
         layout: Layout<'_>,
@@ -208,13 +211,13 @@ where
     }
 }
 
-impl<Message, Renderer> Into<Element<Message, Renderer>>
+impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
-    for Column<Message, Renderer>
+    for Column<'a, Message, Renderer>
 where
     Message: 'static,
     Renderer: iced_native::Renderer + 'static,
 {
-    fn into(self) -> Element<Message, Renderer> {
+    fn into(self) -> Element<'a, Message, Renderer> {
         Element::new(self)
     }
 }

pure/src/widget/element.rs

@@ -1,11 +1,11 @@
 use crate::Widget;
 
-pub struct Element<Message, Renderer> {
+pub struct Element<'a, Message, Renderer> {
-    widget: Box<dyn Widget<Message, Renderer>>,
+    widget: Box<dyn Widget<Message, Renderer> + 'a>,
 }
 
-impl<Message, Renderer> Element<Message, Renderer> {
+impl<'a, Message, Renderer> Element<'a, Message, Renderer> {
-    pub fn new(widget: impl Widget<Message, Renderer> + 'static) -> Self {
+    pub fn new(widget: impl Widget<Message, Renderer> + 'a) -> Self {
         Self {
             widget: Box::new(widget),
         }

pure/src/widget/text.rs

@@ -133,7 +133,7 @@ where
 
     fn draw(
         &self,
-        _tree: &Tree<Message, Renderer>,
+        _tree: &Tree,
         renderer: &mut Renderer,
         style: &renderer::Style,
         layout: Layout<'_>,
@@ -166,20 +166,22 @@ where
     }
 }
 
-impl<Message, Renderer> Into<Element<Message, Renderer>> for Text<Renderer>
+impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
+    for Text<Renderer>
 where
     Renderer: text::Renderer + 'static,
 {
-    fn into(self) -> Element<Message, Renderer> {
+    fn into(self) -> Element<'a, Message, Renderer> {
         Element::new(self)
     }
 }
 
-impl<Message, Renderer> Into<Element<Message, Renderer>> for &'static str
+impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
+    for &'static str
 where
     Renderer: text::Renderer + 'static,
 {
-    fn into(self) -> Element<Message, Renderer> {
+    fn into(self) -> Element<'a, Message, Renderer> {
         Text::new(self).into()
     }
 }

pure/src/widget/tree.rs

@@ -1,17 +1,27 @@
 use crate::widget::Element;
 
-use std::any::Any;
+use std::any::{self, Any};
-use std::marker::PhantomData;
 
-pub struct Tree<Message, Renderer> {
+pub struct Tree {
+    pub tag: any::TypeId,
     pub state: Box<dyn Any>,
-    pub children: Vec<Tree<Message, Renderer>>,
+    pub children: Vec<Tree>,
-    types_: PhantomData<(Message, Renderer)>,
 }
 
-impl<Message, Renderer> Tree<Message, Renderer> {
+impl Tree {
-    pub fn new(element: &Element<Message, Renderer>) -> Self {
+    pub fn empty() -> Self {
         Self {
+            tag: any::TypeId::of::<()>(),
+            state: Box::new(()),
+            children: Vec::new(),
+        }
+    }
+
+    pub fn new<Message, Renderer>(
+        element: &Element<'_, Message, Renderer>,
+    ) -> Self {
+        Self {
+            tag: element.as_widget().tag(),
             state: element.as_widget().state(),
             children: element
                 .as_widget()
@@ -19,36 +29,29 @@ impl<Message, Renderer> Tree<Message, Renderer> {
                 .iter()
                 .map(Self::new)
                 .collect(),
-            types_: PhantomData,
         }
     }
 
-    pub fn diff(
+    pub fn diff<Message, Renderer>(
         &mut self,
-        current: &Element<Message, Renderer>,
+        new: &Element<'_, Message, Renderer>,
-        new: &Element<Message, Renderer>,
     ) {
-        if current.as_widget().tag() == new.as_widget().tag() {
+        if self.tag == new.as_widget().tag() {
-            let current_children = current.as_widget().children();
             let new_children = new.as_widget().children();
 
-            if current_children.len() > new_children.len() {
+            if self.children.len() > new_children.len() {
                 self.children.truncate(new_children.len());
             }
 
-            for (child_state, (current, new)) in self
+            for (child_state, new) in
-                .children
+                self.children.iter_mut().zip(new_children.iter())
-                .iter_mut()
-                .zip(current_children.iter().zip(new_children.iter()))
             {
-                child_state.diff(current, new);
+                child_state.diff(new);
             }
 
-            if current_children.len() < new_children.len() {
+            if self.children.len() < new_children.len() {
                 self.children.extend(
-                    new_children[current_children.len()..]
+                    new_children[self.children.len()..].iter().map(Self::new),
-                        .iter()
-                        .map(Self::new),
                 );
             }
         } else {

src/pure.rs

@@ -20,7 +20,8 @@
 pub use iced_pure::{Element as _, *};
 
 /// A generic, pure [`Widget`].
-pub type Element<Message> = iced_pure::Element<Message, crate::Renderer>;
+pub type Element<'a, Message> =
+    iced_pure::Element<'a, Message, crate::Renderer>;
 
 mod application;
 mod sandbox;

src/pure/application.rs

@@ -66,7 +66,7 @@ pub trait Application: Sized {
     /// Returns the widgets to display in the [`Application`].
     ///
     /// These widgets can produce __messages__ based on user interaction.
-    fn view(&self) -> pure::Element<Self::Message>;
+    fn view(&self) -> pure::Element<'_, Self::Message>;
 
     /// Returns the current [`Application`] mode.
     ///
@@ -126,7 +126,7 @@ pub trait Application: Sized {
 
 struct Instance<A: Application> {
     application: A,
-    state: pure::State<A::Message, crate::Renderer>,
+    state: pure::State,
 }
 
 impl<A> crate::Application for Instance<A>

src/pure/sandbox.rs

@@ -32,7 +32,7 @@ pub trait Sandbox {
     /// Returns the widgets to display in the [`Sandbox`].
     ///
     /// These widgets can produce __messages__ based on user interaction.
-    fn view(&self) -> pure::Element<Self::Message>;
+    fn view(&self) -> pure::Element<'_, Self::Message>;
 
     /// Returns the background color of the [`Sandbox`].
     ///
@@ -101,7 +101,7 @@ where
         Subscription::none()
     }
 
-    fn view(&self) -> pure::Element<T::Message> {
+    fn view(&self) -> pure::Element<'_, T::Message> {
         T::view(self)
     }