7 files changed, 217 insertions, 2 deletions

diff --git a/native/src/widget.rs b/native/src/widget.rs
index 9a4f373a..79f6ae3a 100644
--- a/native/src/widget.rs
+++ b/native/src/widget.rs
@@ -17,6 +17,7 @@ pub mod column;
 pub mod container;
 pub mod helpers;
 pub mod image;
+pub mod operation;
 pub mod pane_grid;
 pub mod pick_list;
 pub mod progress_bar;
@@ -26,6 +27,7 @@ pub mod rule;
 pub mod scrollable;
 pub mod slider;
 pub mod space;
+pub mod state;
 pub mod svg;
 pub mod text;
 pub mod text_input;
@@ -33,6 +35,9 @@ pub mod toggler;
 pub mod tooltip;
 pub mod tree;
 
+mod action;
+mod id;
+
 #[doc(no_inline)]
 pub use button::Button;
 #[doc(no_inline)]
@@ -76,6 +81,10 @@ pub use tooltip::Tooltip;
 #[doc(no_inline)]
 pub use tree::Tree;
 
+pub use action::Action;
+pub use id::Id;
+pub use operation::Operation;
+
 use crate::event::{self, Event};
 use crate::layout;
 use crate::mouse;
@@ -159,6 +168,14 @@ where
     /// Reconciliates the [`Widget`] with the provided [`Tree`].
     fn diff(&self, _tree: &mut Tree) {}
 
+    /// Applies an [`Operation`] to the [`Widget`].
+    fn operate(
+        &self,
+        _layout: Layout<'_>,
+        _operation: &mut dyn Operation<Message>,
+    ) {
+    }
+
     /// Processes a runtime [`Event`].
     ///
     /// By default, it does nothing.
diff --git a/native/src/widget/action.rs b/native/src/widget/action.rs
new file mode 100644
index 00000000..23ea4269
--- /dev/null
+++ b/native/src/widget/action.rs
@@ -0,0 +1,78 @@
+use crate::widget::state;
+use crate::widget::{Id, Operation};
+
+use iced_futures::MaybeSend;
+
+pub struct Action<T>(Box<dyn Operation<T>>);
+
+impl<T> Action<T> {
+    pub fn new(operation: impl Operation<T> + 'static) -> Self {
+        Self(Box::new(operation))
+    }
+
+    pub fn map<A>(
+        self,
+        f: impl Fn(T) -> A + 'static + MaybeSend + Sync,
+    ) -> Action<A>
+    where
+        T: 'static,
+        A: 'static,
+    {
+        Action(Box::new(Map {
+            operation: self.0,
+            f: Box::new(f),
+        }))
+    }
+
+    pub fn into_operation(self) -> Box<dyn Operation<T>> {
+        self.0
+    }
+}
+
+struct Map<A, B> {
+    operation: Box<dyn Operation<A>>,
+    f: Box<dyn Fn(A) -> B>,
+}
+
+impl<A, B> Operation<B> for Map<A, B>
+where
+    A: 'static,
+    B: 'static,
+{
+    fn container(
+        &mut self,
+        id: Option<&Id>,
+        operate_on_children: &dyn Fn(&mut dyn Operation<B>),
+    ) {
+        struct MapRef<'a, A, B> {
+            operation: &'a mut dyn Operation<A>,
+            f: &'a dyn Fn(A) -> B,
+        }
+
+        impl<'a, A, B> Operation<B> for MapRef<'a, A, B> {
+            fn container(
+                &mut self,
+                id: Option<&Id>,
+                operate_on_children: &dyn Fn(&mut dyn Operation<B>),
+            ) {
+                let Self { operation, f } = self;
+
+                operation.container(id, &|operation| {
+                    operate_on_children(&mut MapRef { operation, f });
+                });
+            }
+        }
+
+        let Self { operation, f } = self;
+
+        MapRef {
+            operation: operation.as_mut(),
+            f,
+        }
+        .container(id, operate_on_children);
+    }
+
+    fn focusable(&mut self, state: &mut dyn state::Focusable, id: Option<&Id>) {
+        self.operation.focusable(state, id);
+    }
+}
diff --git a/native/src/widget/helpers.rs b/native/src/widget/helpers.rs
index 518ac23b..a62448e9 100644
--- a/native/src/widget/helpers.rs
+++ b/native/src/widget/helpers.rs
@@ -49,8 +49,8 @@ where
 /// [`Column`]: widget::Column
 pub fn column<Message, Renderer>(
     children: Vec<Element<'_, Message, Renderer>>,
-) -> widget::Row<'_, Message, Renderer> {
-    widget::Row::with_children(children)
+) -> widget::Column<'_, Message, Renderer> {
+    widget::Column::with_children(children)
 }
 
 /// Creates a new [`Row`] with the given children.
diff --git a/native/src/widget/id.rs b/native/src/widget/id.rs
new file mode 100644
index 00000000..4c0ab999
--- /dev/null
+++ b/native/src/widget/id.rs
@@ -0,0 +1,38 @@
+use std::borrow;
+use std::sync::atomic::{self, AtomicUsize};
+
+static NEXT_ID: AtomicUsize = AtomicUsize::new(0);
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Id(Internal);
+
+impl Id {
+    pub fn new(id: impl Into<borrow::Cow<'static, str>>) -> Self {
+        Self(Internal::Custom(id.into()))
+    }
+
+    pub fn unique() -> Self {
+        let id = NEXT_ID.fetch_add(1, atomic::Ordering::Relaxed);
+
+        Self(Internal::Unique(id))
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum Internal {
+    Unique(usize),
+    Custom(borrow::Cow<'static, str>),
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Id;
+
+    #[test]
+    fn unique_generates_different_ids() {
+        let a = Id::unique();
+        let b = Id::unique();
+
+        assert_ne!(a, b);
+    }
+}
diff --git a/native/src/widget/operation.rs b/native/src/widget/operation.rs
new file mode 100644
index 00000000..b6c108e0
--- /dev/null
+++ b/native/src/widget/operation.rs
@@ -0,0 +1,62 @@
+use crate::widget::state;
+use crate::widget::Id;
+
+pub trait Operation<T> {
+    fn container(
+        &mut self,
+        id: Option<&Id>,
+        operate_on_children: &dyn Fn(&mut dyn Operation<T>),
+    );
+
+    fn focusable(
+        &mut self,
+        _state: &mut dyn state::Focusable,
+        _id: Option<&Id>,
+    ) {
+    }
+
+    fn finish(&self) -> Outcome<T> {
+        Outcome::None
+    }
+}
+
+pub enum Outcome<T> {
+    None,
+    Some(T),
+    Chain(Box<dyn Operation<T>>),
+}
+
+pub fn focus<T>(target: Id) -> impl Operation<T> {
+    struct Focus {
+        target: Id,
+    }
+
+    impl<T> Operation<T> for Focus {
+        fn focusable(
+            &mut self,
+            state: &mut dyn state::Focusable,
+            id: Option<&Id>,
+        ) {
+            if state.is_focused() {
+                match id {
+                    Some(id) if id == &self.target => {
+                        state.focus();
+                    }
+                    _ => {
+                        state.unfocus();
+                    }
+                }
+            }
+        }
+
+        fn container(
+            &mut self,
+            _id: Option<&Id>,
+            operate_on_children: &dyn Fn(&mut dyn Operation<T>),
+        ) {
+            operate_on_children(self)
+        }
+    }
+
+    Focus { target }
+}
diff --git a/native/src/widget/state.rs b/native/src/widget/state.rs
new file mode 100644
index 00000000..d1984a71
--- /dev/null
+++ b/native/src/widget/state.rs
@@ -0,0 +1,5 @@
+pub trait Focusable {
+    fn is_focused(&self) -> bool;
+    fn focus(&mut self);
+    fn unfocus(&mut self);
+}
diff --git a/native/src/widget/text_input.rs b/native/src/widget/text_input.rs
index 4ef9e11b..1dbb8d6b 100644
--- a/native/src/widget/text_input.rs
+++ b/native/src/widget/text_input.rs
@@ -19,6 +19,7 @@ use crate::mouse::{self, click};
 use crate::renderer;
 use crate::text::{self, Text};
 use crate::touch;
+use crate::widget::state;
 use crate::widget::tree::{self, Tree};
 use crate::{
     Clipboard, Color, Element, Layout, Length, Padding, Point, Rectangle,
@@ -942,6 +943,20 @@ impl State {
     }
 }
 
+impl state::Focusable for State {
+    fn is_focused(&self) -> bool {
+        State::is_focused(self)
+    }
+
+    fn focus(&mut self) {
+        State::focus(self)
+    }
+
+    fn unfocus(&mut self) {
+        State::unfocus(self)
+    }
+}
+
 mod platform {
     use crate::keyboard;