Introduce `black_box` and `chain` in `widget::operation`

31 files changed, 232 insertions, 67 deletions

diff --git a/core/src/element.rs b/core/src/element.rs
index 385d8295..6ebb8a15 100644
--- a/core/src/element.rs
+++ b/core/src/element.rs
@@ -304,7 +304,7 @@ where
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn widget::Operation<()>,
+        operation: &mut dyn widget::Operation,
     ) {
         self.widget.operate(tree, layout, renderer, operation);
     }
@@ -440,7 +440,7 @@ where
         state: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn widget::Operation<()>,
+        operation: &mut dyn widget::Operation,
     ) {
         self.element
             .widget
diff --git a/core/src/overlay.rs b/core/src/overlay.rs
index 3b79970e..f09de831 100644
--- a/core/src/overlay.rs
+++ b/core/src/overlay.rs
@@ -41,7 +41,7 @@ where
         &mut self,
         _layout: Layout<'_>,
         _renderer: &Renderer,
-        _operation: &mut dyn widget::Operation<()>,
+        _operation: &mut dyn widget::Operation,
     ) {
     }
 
diff --git a/core/src/overlay/element.rs b/core/src/overlay/element.rs
index 61e75e8a..32e987a3 100644
--- a/core/src/overlay/element.rs
+++ b/core/src/overlay/element.rs
@@ -92,7 +92,7 @@ where
         &mut self,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn widget::Operation<()>,
+        operation: &mut dyn widget::Operation,
     ) {
         self.overlay.operate(layout, renderer, operation);
     }
@@ -144,7 +144,7 @@ where
         &mut self,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn widget::Operation<()>,
+        operation: &mut dyn widget::Operation,
     ) {
         self.content.operate(layout, renderer, operation);
     }
diff --git a/core/src/overlay/group.rs b/core/src/overlay/group.rs
index cd12eac9..6541d311 100644
--- a/core/src/overlay/group.rs
+++ b/core/src/overlay/group.rs
@@ -132,7 +132,7 @@ where
         &mut self,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn widget::Operation<()>,
+        operation: &mut dyn widget::Operation,
     ) {
         operation.container(None, layout.bounds(), &mut |operation| {
             self.children.iter_mut().zip(layout.children()).for_each(
diff --git a/core/src/widget.rs b/core/src/widget.rs
index 08cfa55b..c5beea54 100644
--- a/core/src/widget.rs
+++ b/core/src/widget.rs
@@ -105,7 +105,7 @@ where
         _state: &mut Tree,
         _layout: Layout<'_>,
         _renderer: &Renderer,
-        _operation: &mut dyn Operation<()>,
+        _operation: &mut dyn Operation,
     ) {
     }
 
diff --git a/core/src/widget/operation.rs b/core/src/widget/operation.rs
index 3e4ed618..741e1a5f 100644
--- a/core/src/widget/operation.rs
+++ b/core/src/widget/operation.rs
@@ -12,11 +12,12 @@ use crate::{Rectangle, Vector};
 
 use std::any::Any;
 use std::fmt;
+use std::marker::PhantomData;
 use std::sync::Arc;
 
 /// A piece of logic that can traverse the widget tree of an application in
 /// order to query or update some widget state.
-pub trait Operation<T>: Send {
+pub trait Operation<T = ()>: Send {
     /// Operates on a widget that contains other widgets.
     ///
     /// The `operate_on_children` function can be called to return control to
@@ -53,6 +54,46 @@ pub trait Operation<T>: Send {
     }
 }
 
+impl<T, O> Operation<O> for Box<T>
+where
+    T: Operation<O> + ?Sized,
+{
+    fn container(
+        &mut self,
+        id: Option<&Id>,
+        bounds: Rectangle,
+        operate_on_children: &mut dyn FnMut(&mut dyn Operation<O>),
+    ) {
+        self.as_mut().container(id, bounds, operate_on_children);
+    }
+
+    fn focusable(&mut self, state: &mut dyn Focusable, id: Option<&Id>) {
+        self.as_mut().focusable(state, id);
+    }
+
+    fn scrollable(
+        &mut self,
+        state: &mut dyn Scrollable,
+        id: Option<&Id>,
+        bounds: Rectangle,
+        translation: Vector,
+    ) {
+        self.as_mut().scrollable(state, id, bounds, translation);
+    }
+
+    fn text_input(&mut self, state: &mut dyn TextInput, id: Option<&Id>) {
+        self.as_mut().text_input(state, id);
+    }
+
+    fn custom(&mut self, state: &mut dyn Any, id: Option<&Id>) {
+        self.as_mut().custom(state, id);
+    }
+
+    fn finish(&self) -> Outcome<O> {
+        self.as_ref().finish()
+    }
+}
+
 /// The result of an [`Operation`].
 pub enum Outcome<T> {
     /// The [`Operation`] produced no result.
@@ -78,9 +119,62 @@ where
     }
 }
 
+/// Wraps the [`Operation`] in a black box, erasing its returning type.
+pub fn black_box<'a, T, O>(
+    operation: &'a mut dyn Operation<T>,
+) -> impl Operation<O> + 'a
+where
+    T: 'a,
+{
+    struct BlackBox<'a, T> {
+        operation: &'a mut dyn Operation<T>,
+    }
+
+    impl<'a, T, O> Operation<O> for BlackBox<'a, T> {
+        fn container(
+            &mut self,
+            id: Option<&Id>,
+            bounds: Rectangle,
+            operate_on_children: &mut dyn FnMut(&mut dyn Operation<O>),
+        ) {
+            self.operation.container(id, bounds, &mut |operation| {
+                operate_on_children(&mut BlackBox { operation });
+            });
+        }
+
+        fn focusable(&mut self, state: &mut dyn Focusable, id: Option<&Id>) {
+            self.operation.focusable(state, id);
+        }
+
+        fn scrollable(
+            &mut self,
+            state: &mut dyn Scrollable,
+            id: Option<&Id>,
+            bounds: Rectangle,
+            translation: Vector,
+        ) {
+            self.operation.scrollable(state, id, bounds, translation);
+        }
+
+        fn text_input(&mut self, state: &mut dyn TextInput, id: Option<&Id>) {
+            self.operation.text_input(state, id);
+        }
+
+        fn custom(&mut self, state: &mut dyn Any, id: Option<&Id>) {
+            self.operation.custom(state, id);
+        }
+
+        fn finish(&self) -> Outcome<O> {
+            Outcome::None
+        }
+    }
+
+    BlackBox { operation }
+}
+
 /// Maps the output of an [`Operation`] using the given function.
 pub fn map<A, B>(
-    operation: Box<dyn Operation<A>>,
+    operation: impl Operation<A>,
     f: impl Fn(A) -> B + Send + Sync + 'static,
 ) -> impl Operation<B>
 where
@@ -88,13 +182,14 @@ where
     B: 'static,
 {
     #[allow(missing_debug_implementations)]
-    struct Map<A, B> {
-        operation: Box<dyn Operation<A>>,
+    struct Map<O, A, B> {
+        operation: O,
         f: Arc<dyn Fn(A) -> B + Send + Sync>,
     }
 
-    impl<A, B> Operation<B> for Map<A, B>
+    impl<O, A, B> Operation<B> for Map<O, A, B>
     where
+        O: Operation<A>,
         A: 'static,
         B: 'static,
     {
@@ -155,10 +250,7 @@ where
 
             let Self { operation, .. } = self;
 
-            MapRef {
-                operation: operation.as_mut(),
-            }
-            .container(id, bounds, operate_on_children);
+            MapRef { operation }.container(id, bounds, operate_on_children);
         }
 
         fn focusable(&mut self, state: &mut dyn Focusable, id: Option<&Id>) {
@@ -201,6 +293,87 @@ where
     }
 }
 
+/// Chains the output of an [`Operation`] with the provided function to
+/// build a new [`Operation`].
+pub fn chain<A, B, O>(
+    operation: impl Operation<A> + 'static,
+    f: fn(A) -> O,
+) -> impl Operation<B>
+where
+    A: 'static,
+    B: Send + 'static,
+    O: Operation<B> + 'static,
+{
+    struct Chain<T, O, A, B>
+    where
+        T: Operation<A>,
+        O: Operation<B>,
+    {
+        operation: T,
+        next: fn(A) -> O,
+        _result: PhantomData<B>,
+    }
+
+    impl<T, O, A, B> Operation<B> for Chain<T, O, A, B>
+    where
+        T: Operation<A> + 'static,
+        O: Operation<B> + 'static,
+        A: 'static,
+        B: Send + 'static,
+    {
+        fn container(
+            &mut self,
+            id: Option<&Id>,
+            bounds: Rectangle,
+            operate_on_children: &mut dyn FnMut(&mut dyn Operation<B>),
+        ) {
+            self.operation.container(id, bounds, &mut |operation| {
+                operate_on_children(&mut black_box(operation));
+            });
+        }
+
+        fn focusable(&mut self, state: &mut dyn Focusable, id: Option<&Id>) {
+            self.operation.focusable(state, id);
+        }
+
+        fn scrollable(
+            &mut self,
+            state: &mut dyn Scrollable,
+            id: Option<&Id>,
+            bounds: Rectangle,
+            translation: crate::Vector,
+        ) {
+            self.operation.scrollable(state, id, bounds, translation);
+        }
+
+        fn text_input(&mut self, state: &mut dyn TextInput, id: Option<&Id>) {
+            self.operation.text_input(state, id);
+        }
+
+        fn custom(&mut self, state: &mut dyn std::any::Any, id: Option<&Id>) {
+            self.operation.custom(state, id);
+        }
+
+        fn finish(&self) -> Outcome<B> {
+            match self.operation.finish() {
+                Outcome::None => Outcome::None,
+                Outcome::Some(value) => {
+                    Outcome::Chain(Box::new((self.next)(value)))
+                }
+                Outcome::Chain(operation) => {
+                    Outcome::Chain(Box::new(chain(operation, self.next)))
+                }
+            }
+        }
+    }
+
+    Chain {
+        operation,
+        next: f,
+        _result: PhantomData,
+    }
+}
+
 /// Produces an [`Operation`] that applies the given [`Operation`] to the
 /// children of a container with the given [`Id`].
 pub fn scope<T: 'static>(
diff --git a/core/src/widget/operation/focusable.rs b/core/src/widget/operation/focusable.rs
index 68c22faa..0a6f2e96 100644
--- a/core/src/widget/operation/focusable.rs
+++ b/core/src/widget/operation/focusable.rs
@@ -1,5 +1,5 @@
 //! Operate on widgets that can be focused.
-use crate::widget::operation::{Operation, Outcome};
+use crate::widget::operation::{self, Operation, Outcome};
 use crate::widget::Id;
 use crate::Rectangle;
 
@@ -58,19 +58,12 @@ pub fn focus<T>(target: Id) -> impl Operation<T> {
 
 /// Produces an [`Operation`] that generates a [`Count`] and chains it with the
 /// provided function to build a new [`Operation`].
-pub fn count<T, O>(f: fn(Count) -> O) -> impl Operation<T>
-where
-    O: Operation<T> + 'static,
-{
-    struct CountFocusable<O> {
+pub fn count() -> impl Operation<Count> {
+    struct CountFocusable {
         count: Count,
-        next: fn(Count) -> O,
     }
 
-    impl<T, O> Operation<T> for CountFocusable<O>
-    where
-        O: Operation<T> + 'static,
-    {
+    impl Operation<Count> for CountFocusable {
         fn focusable(&mut self, state: &mut dyn Focusable, _id: Option<&Id>) {
             if state.is_focused() {
                 self.count.focused = Some(self.count.total);
@@ -83,26 +76,25 @@ where
             &mut self,
             _id: Option<&Id>,
             _bounds: Rectangle,
-            operate_on_children: &mut dyn FnMut(&mut dyn Operation<T>),
+            operate_on_children: &mut dyn FnMut(&mut dyn Operation<Count>),
         ) {
             operate_on_children(self);
         }
 
-        fn finish(&self) -> Outcome<T> {
-            Outcome::Chain(Box::new((self.next)(self.count)))
+        fn finish(&self) -> Outcome<Count> {
+            Outcome::Some(self.count)
         }
     }
 
     CountFocusable {
         count: Count::default(),
-        next: f,
     }
 }
 
 /// Produces an [`Operation`] that searches for the current focused widget, and
 /// - if found, focuses the previous focusable widget.
 /// - if not found, focuses the last focusable widget.
-pub fn focus_previous<T>() -> impl Operation<T> {
+pub fn focus_previous() -> impl Operation {
     struct FocusPrevious {
         count: Count,
         current: usize,
@@ -136,13 +128,13 @@ pub fn focus_previous<T>() -> impl Operation<T> {
         }
     }
 
-    count(|count| FocusPrevious { count, current: 0 })
+    operation::chain(count(), |count| FocusPrevious { count, current: 0 })
 }
 
 /// Produces an [`Operation`] that searches for the current focused widget, and
 /// - if found, focuses the next focusable widget.
 /// - if not found, focuses the first focusable widget.
-pub fn focus_next<T>() -> impl Operation<T> {
+pub fn focus_next() -> impl Operation {
     struct FocusNext {
         count: Count,
         current: usize,
@@ -170,7 +162,7 @@ pub fn focus_next<T>() -> impl Operation<T> {
         }
     }
 
-    count(|count| FocusNext { count, current: 0 })
+    operation::chain(count(), |count| FocusNext { count, current: 0 })
 }
 
 /// Produces an [`Operation`] that searches for the current focused widget
diff --git a/examples/toast/src/main.rs b/examples/toast/src/main.rs
index 040c19bd..8f6a836e 100644
--- a/examples/toast/src/main.rs
+++ b/examples/toast/src/main.rs
@@ -347,7 +347,7 @@ mod toast {
             state: &mut Tree,
             layout: Layout<'_>,
             renderer: &Renderer,
-            operation: &mut dyn Operation<()>,
+            operation: &mut dyn Operation,
         ) {
             operation.container(None, layout.bounds(), &mut |operation| {
                 self.content.as_widget().operate(
@@ -589,7 +589,7 @@ mod toast {
             &mut self,
             layout: Layout<'_>,
             renderer: &Renderer,
-            operation: &mut dyn widget::Operation<()>,
+            operation: &mut dyn widget::Operation,
         ) {
             operation.container(None, layout.bounds(), &mut |operation| {
                 self.toasts
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index f27657d1..7230fc73 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -59,7 +59,7 @@ pub enum Action<T> {
     },
 
     /// Run a widget operation.
-    Widget(Box<dyn widget::Operation<()>>),
+    Widget(Box<dyn widget::Operation>),
 
     /// Run a clipboard action.
     Clipboard(clipboard::Action),
@@ -79,7 +79,7 @@ pub enum Action<T> {
 
 impl<T> Action<T> {
     /// Creates a new [`Action::Widget`] with the given [`widget::Operation`].
-    pub fn widget(operation: impl widget::Operation<()> + 'static) -> Self {
+    pub fn widget(operation: impl widget::Operation + 'static) -> Self {
         Self::Widget(Box::new(operation))
     }
 
diff --git a/runtime/src/multi_window/state.rs b/runtime/src/multi_window/state.rs
index 72ce6933..0bec555f 100644
--- a/runtime/src/multi_window/state.rs
+++ b/runtime/src/multi_window/state.rs
@@ -205,7 +205,7 @@ where
     pub fn operate(
         &mut self,
         renderer: &mut P::Renderer,
-        operations: impl Iterator<Item = Box<dyn Operation<()>>>,
+        operations: impl Iterator<Item = Box<dyn Operation>>,
         bounds: Size,
         debug: &mut Debug,
     ) {
diff --git a/runtime/src/overlay/nested.rs b/runtime/src/overlay/nested.rs
index 11eee41c..da3e6929 100644
--- a/runtime/src/overlay/nested.rs
+++ b/runtime/src/overlay/nested.rs
@@ -131,13 +131,13 @@ where
         &mut self,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn widget::Operation<()>,
+        operation: &mut dyn widget::Operation,
     ) {
         fn recurse<Message, Theme, Renderer>(
             element: &mut overlay::Element<'_, Message, Theme, Renderer>,
             layout: Layout<'_>,
             renderer: &Renderer,
-            operation: &mut dyn widget::Operation<()>,
+            operation: &mut dyn widget::Operation,
         ) where
             Renderer: renderer::Renderer,
         {
diff --git a/runtime/src/program/state.rs b/runtime/src/program/state.rs
index e51ad0cb..c377814a 100644
--- a/runtime/src/program/state.rs
+++ b/runtime/src/program/state.rs
@@ -178,7 +178,7 @@ where
     pub fn operate(
         &mut self,
         renderer: &mut P::Renderer,
-        operations: impl Iterator<Item = Box<dyn Operation<()>>>,
+        operations: impl Iterator<Item = Box<dyn Operation>>,
         bounds: Size,
         debug: &mut Debug,
     ) {
diff --git a/runtime/src/user_interface.rs b/runtime/src/user_interface.rs
index 858b1a2d..11ebb381 100644
--- a/runtime/src/user_interface.rs
+++ b/runtime/src/user_interface.rs
@@ -566,7 +566,7 @@ where
     pub fn operate(
         &mut self,
         renderer: &Renderer,
-        operation: &mut dyn widget::Operation<()>,
+        operation: &mut dyn widget::Operation,
     ) {
         self.root.as_widget().operate(
             &mut self.state,
diff --git a/widget/src/button.rs b/widget/src/button.rs
index 64a639d2..eafa71b9 100644
--- a/widget/src/button.rs
+++ b/widget/src/button.rs
@@ -236,7 +236,7 @@ where
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn Operation<()>,
+        operation: &mut dyn Operation,
     ) {
         operation.container(None, layout.bounds(), &mut |operation| {
             self.content.as_widget().operate(
diff --git a/widget/src/column.rs b/widget/src/column.rs
index ae82ccaa..d3ea4cf7 100644
--- a/widget/src/column.rs
+++ b/widget/src/column.rs
@@ -222,7 +222,7 @@ where
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn Operation<()>,
+        operation: &mut dyn Operation,
     ) {
         operation.container(None, layout.bounds(), &mut |operation| {
             self.children
diff --git a/widget/src/container.rs b/widget/src/container.rs
index 9224f2ce..54043ad0 100644
--- a/widget/src/container.rs
+++ b/widget/src/container.rs
@@ -245,7 +245,7 @@ where
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn Operation<()>,
+        operation: &mut dyn Operation,
     ) {
         operation.container(
             self.id.as_ref().map(|id| &id.0),
diff --git a/widget/src/helpers.rs b/widget/src/helpers.rs
index 11dddfa8..6bf96c9e 100644
--- a/widget/src/helpers.rs
+++ b/widget/src/helpers.rs
@@ -289,7 +289,7 @@ where
             state: &mut Tree,
             layout: Layout<'_>,
             renderer: &Renderer,
-            operation: &mut dyn operation::Operation<()>,
+            operation: &mut dyn operation::Operation,
         ) {
             self.content
                 .as_widget()
@@ -491,7 +491,7 @@ where
             tree: &mut Tree,
             layout: Layout<'_>,
             renderer: &Renderer,
-            operation: &mut dyn operation::Operation<()>,
+            operation: &mut dyn operation::Operation,
         ) {
             let children = [&self.base, &self.top]
                 .into_iter()
diff --git a/widget/src/keyed/column.rs b/widget/src/keyed/column.rs
index 69991d1f..2c56c605 100644
--- a/widget/src/keyed/column.rs
+++ b/widget/src/keyed/column.rs
@@ -265,7 +265,7 @@ where
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn Operation<()>,
+        operation: &mut dyn Operation,
     ) {
         operation.container(None, layout.bounds(), &mut |operation| {
             self.children
diff --git a/widget/src/lazy.rs b/widget/src/lazy.rs
index 606da22d..4bcf8628 100644
--- a/widget/src/lazy.rs
+++ b/widget/src/lazy.rs
@@ -182,7 +182,7 @@ where
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn widget::Operation<()>,
+        operation: &mut dyn widget::Operation,
     ) {
         self.with_element(|element| {
             element.as_widget().operate(
diff --git a/widget/src/lazy/component.rs b/widget/src/lazy/component.rs
index f079c0df..1bf04195 100644
--- a/widget/src/lazy/component.rs
+++ b/widget/src/lazy/component.rs
@@ -59,7 +59,7 @@ pub trait Component<Message, Theme = crate::Theme, Renderer = crate::Renderer> {
     fn operate(
         &self,
         _state: &mut Self::State,
-        _operation: &mut dyn widget::Operation<()>,
+        _operation: &mut dyn widget::Operation,
     ) {
     }
 
@@ -172,7 +172,7 @@ where
 
     fn rebuild_element_with_operation(
         &self,
-        operation: &mut dyn widget::Operation<()>,
+        operation: &mut dyn widget::Operation,
     ) {
         let heads = self.state.borrow_mut().take().unwrap().into_heads();
 
@@ -358,7 +358,7 @@ where
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn widget::Operation<()>,
+        operation: &mut dyn widget::Operation,
     ) {
         self.rebuild_element_with_operation(operation);
 
diff --git a/widget/src/lazy/responsive.rs b/widget/src/lazy/responsive.rs
index 27f52617..2e24f2b3 100644
--- a/widget/src/lazy/responsive.rs
+++ b/widget/src/lazy/responsive.rs
@@ -161,7 +161,7 @@ where
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn widget::Operation<()>,
+        operation: &mut dyn widget::Operation,
     ) {
         let state = tree.state.downcast_mut::<State>();
         let mut content = self.content.borrow_mut();
diff --git a/widget/src/mouse_area.rs b/widget/src/mouse_area.rs
index 17cae53b..366335f4 100644
--- a/widget/src/mouse_area.rs
+++ b/widget/src/mouse_area.rs
@@ -178,7 +178,7 @@ where
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn Operation<()>,
+        operation: &mut dyn Operation,
     ) {
         self.content.as_widget().operate(
             &mut tree.children[0],
diff --git a/widget/src/pane_grid.rs b/widget/src/pane_grid.rs
index c3da3879..0aab1ab5 100644
--- a/widget/src/pane_grid.rs
+++ b/widget/src/pane_grid.rs
@@ -324,7 +324,7 @@ where
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn widget::Operation<()>,
+        operation: &mut dyn widget::Operation,
     ) {
         operation.container(None, layout.bounds(), &mut |operation| {
             self.contents
diff --git a/widget/src/pane_grid/content.rs b/widget/src/pane_grid/content.rs
index d45fc0cd..ec0676b1 100644
--- a/widget/src/pane_grid/content.rs
+++ b/widget/src/pane_grid/content.rs
@@ -214,7 +214,7 @@ where
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn widget::Operation<()>,
+        operation: &mut dyn widget::Operation,
     ) {
         let body_layout = if let Some(title_bar) = &self.title_bar {
             let mut children = layout.children();
diff --git a/widget/src/pane_grid/title_bar.rs b/widget/src/pane_grid/title_bar.rs
index c05f1252..791fab4a 100644
--- a/widget/src/pane_grid/title_bar.rs
+++ b/widget/src/pane_grid/title_bar.rs
@@ -278,7 +278,7 @@ where
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn widget::Operation<()>,
+        operation: &mut dyn widget::Operation,
     ) {
         let mut children = layout.children();
         let padded = children.next().unwrap();
diff --git a/widget/src/row.rs b/widget/src/row.rs
index fee2218a..85af912f 100644
--- a/widget/src/row.rs
+++ b/widget/src/row.rs
@@ -218,7 +218,7 @@ where
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn Operation<()>,
+        operation: &mut dyn Operation,
     ) {
         operation.container(None, layout.bounds(), &mut |operation| {
             self.children
@@ -470,7 +470,7 @@ where
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn Operation<()>,
+        operation: &mut dyn Operation,
     ) {
         self.row.operate(tree, layout, renderer, operation);
     }
diff --git a/widget/src/scrollable.rs b/widget/src/scrollable.rs
index 9ba8c39b..cf504eda 100644
--- a/widget/src/scrollable.rs
+++ b/widget/src/scrollable.rs
@@ -415,7 +415,7 @@ where
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn Operation<()>,
+        operation: &mut dyn Operation,
     ) {
         let state = tree.state.downcast_mut::<State>();
 
diff --git a/widget/src/stack.rs b/widget/src/stack.rs
index efa9711d..001376ac 100644
--- a/widget/src/stack.rs
+++ b/widget/src/stack.rs
@@ -189,7 +189,7 @@ where
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn Operation<()>,
+        operation: &mut dyn Operation,
     ) {
         operation.container(None, layout.bounds(), &mut |operation| {
             self.children
diff --git a/widget/src/text_editor.rs b/widget/src/text_editor.rs
index a264ba06..aac47b2d 100644
--- a/widget/src/text_editor.rs
+++ b/widget/src/text_editor.rs
@@ -885,7 +885,7 @@ where
         tree: &mut widget::Tree,
         _layout: Layout<'_>,
         _renderer: &Renderer,
-        operation: &mut dyn widget::Operation<()>,
+        operation: &mut dyn widget::Operation,
     ) {
         let state = tree.state.downcast_mut::<State<Highlighter>>();
 
diff --git a/widget/src/text_input.rs b/widget/src/text_input.rs
index 20e80ba5..173de136 100644
--- a/widget/src/text_input.rs
+++ b/widget/src/text_input.rs
@@ -542,7 +542,7 @@ where
         tree: &mut Tree,
         _layout: Layout<'_>,
         _renderer: &Renderer,
-        operation: &mut dyn Operation<()>,
+        operation: &mut dyn Operation,
     ) {
         let state = tree.state.downcast_mut::<State<Renderer::Paragraph>>();
 
diff --git a/widget/src/themer.rs b/widget/src/themer.rs
index 9eb47d84..499a9fe8 100644
--- a/widget/src/themer.rs
+++ b/widget/src/themer.rs
@@ -104,7 +104,7 @@ where
         tree: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn Operation<()>,
+        operation: &mut dyn Operation,
     ) {
         self.content
             .as_widget()
@@ -236,7 +236,7 @@ where
                 &mut self,
                 layout: Layout<'_>,
                 renderer: &Renderer,
-                operation: &mut dyn Operation<()>,
+                operation: &mut dyn Operation,
             ) {
                 self.content.operate(layout, renderer, operation);
             }