diff --git a/xilem/src/view/button.rs b/xilem/src/view/button.rs
index 24d1681b6..2e7c64fe6 100644
--- a/xilem/src/view/button.rs
+++ b/xilem/src/view/button.rs
@@ -2,10 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{core::View, Pod};
-use masonry::{
-    widget::{self, WidgetMut},
-    ArcStr,
-};
+use masonry::{widget, ArcStr};
+use xilem_core::Mut;
 
 use crate::{MessageResult, ViewCtx, ViewId};
 
@@ -35,24 +33,25 @@ where
         ctx.with_leaf_action_widget(|_| Pod::new(widget::Button::new(self.label.clone())))
     }
 
-    fn rebuild(
+    fn rebuild<'el>(
         &self,
         prev: &Self,
         _: &mut Self::ViewState,
         ctx: &mut ViewCtx,
-        mut element: WidgetMut<widget::Button>,
-    ) {
+        mut element: Mut<'el, Self::Element>,
+    ) -> Mut<'el, Self::Element> {
         if prev.label != self.label {
             element.set_text(self.label.clone());
             ctx.mark_changed();
         }
+        element
     }
 
     fn teardown(
         &self,
         _: &mut Self::ViewState,
         ctx: &mut ViewCtx,
-        element: <Self::Element as xilem_core::ViewElement>::Mut<'_>,
+        element: Mut<'_, Self::Element>,
     ) {
         ctx.teardown_leaf(element);
     }
diff --git a/xilem/src/view/checkbox.rs b/xilem/src/view/checkbox.rs
index bcad6a0df..34d6ef55c 100644
--- a/xilem/src/view/checkbox.rs
+++ b/xilem/src/view/checkbox.rs
@@ -1,10 +1,8 @@
 // Copyright 2024 the Xilem Authors
 // SPDX-License-Identifier: Apache-2.0
 
-use masonry::{
-    widget::{self, WidgetMut},
-    ArcStr,
-};
+use masonry::{widget, ArcStr};
+use xilem_core::Mut;
 
 use crate::{MessageResult, Pod, View, ViewCtx, ViewId};
 
@@ -45,13 +43,13 @@ where
         })
     }
 
-    fn rebuild(
+    fn rebuild<'el>(
         &self,
         prev: &Self,
         (): &mut Self::ViewState,
         ctx: &mut ViewCtx,
-        mut element: WidgetMut<'_, widget::Checkbox>,
-    ) {
+        mut element: Mut<'el, Self::Element>,
+    ) -> Mut<'el, Self::Element> {
         if prev.label != self.label {
             element.set_text(self.label.clone());
             ctx.mark_changed();
@@ -60,13 +58,14 @@ where
             element.set_checked(self.checked);
             ctx.mark_changed();
         }
+        element
     }
 
     fn teardown(
         &self,
         (): &mut Self::ViewState,
         ctx: &mut ViewCtx,
-        element: WidgetMut<'_, widget::Checkbox>,
+        element: Mut<'_, Self::Element>,
     ) {
         ctx.teardown_leaf(element);
     }
diff --git a/xilem/src/view/flex.rs b/xilem/src/view/flex.rs
index c41d326c0..9536360cf 100644
--- a/xilem/src/view/flex.rs
+++ b/xilem/src/view/flex.rs
@@ -7,7 +7,7 @@ use masonry::{
     widget::{self, Axis, CrossAxisAlignment, MainAxisAlignment, WidgetMut},
     Widget,
 };
-use xilem_core::{AppendVec, ElementSplice, View, ViewSequence};
+use xilem_core::{AppendVec, ElementSplice, Mut, View, ViewSequence};
 
 use crate::{Pod, ViewCtx};
 
@@ -75,13 +75,13 @@ where
         (Pod::new(widget), seq_state)
     }
 
-    fn rebuild(
+    fn rebuild<'el>(
         &self,
         prev: &Self,
         view_state: &mut Self::ViewState,
         ctx: &mut ViewCtx,
-        mut element: WidgetMut<widget::Flex>,
-    ) {
+        mut element: Mut<'el, Self::Element>,
+    ) -> Mut<'el, Self::Element> {
         if prev.axis != self.axis {
             element.set_direction(self.axis);
             ctx.mark_changed();
@@ -102,24 +102,25 @@ where
         let mut splice = FlexSplice {
             // Skip the initial spacer which is always present
             ix: 1,
-            element,
+            element: &mut element,
             scratch: AppendVec::default(),
         };
         self.sequence
             .seq_rebuild(&prev.sequence, view_state, ctx, &mut splice);
         debug_assert!(splice.scratch.into_inner().is_empty());
+        element
     }
 
     fn teardown(
         &self,
         view_state: &mut Self::ViewState,
         ctx: &mut ViewCtx,
-        element: <Self::Element as xilem_core::ViewElement>::Mut<'_>,
+        mut element: Mut<'_, Self::Element>,
     ) {
         let mut splice = FlexSplice {
             // Skip the initial spacer which is always present
             ix: 1,
-            element,
+            element: &mut element,
             scratch: AppendVec::default(),
         };
         self.sequence.seq_teardown(view_state, ctx, &mut splice);
@@ -138,13 +139,13 @@ where
     }
 }
 
-struct FlexSplice<'w> {
+struct FlexSplice<'f, 'w> {
     ix: usize,
-    element: WidgetMut<'w, widget::Flex>,
+    element: &'f mut WidgetMut<'w, widget::Flex>,
     scratch: AppendVec<Pod<Box<dyn Widget>>>,
 }
 
-impl ElementSplice<Pod<Box<dyn Widget>>> for FlexSplice<'_> {
+impl<'f> ElementSplice<Pod<Box<dyn Widget>>> for FlexSplice<'f, '_> {
     fn insert(&mut self, element: Pod<Box<dyn masonry::Widget>>) {
         self.element.insert_child_pod(self.ix, element.inner);
         // Insert a spacer after the child
diff --git a/xilem/src/view/label.rs b/xilem/src/view/label.rs
index a2fc671f9..d20934b93 100644
--- a/xilem/src/view/label.rs
+++ b/xilem/src/view/label.rs
@@ -1,10 +1,8 @@
 // Copyright 2024 the Xilem Authors
 // SPDX-License-Identifier: Apache-2.0
 
-use masonry::{
-    widget::{self, WidgetMut},
-    ArcStr,
-};
+use masonry::{widget, ArcStr};
+use xilem_core::Mut;
 
 use crate::{Color, MessageResult, Pod, TextAlignment, View, ViewCtx, ViewId};
 
@@ -55,13 +53,13 @@ impl<State, Action> View<State, Action, ViewCtx> for Label {
         (widget_pod, ())
     }
 
-    fn rebuild(
+    fn rebuild<'el>(
         &self,
         prev: &Self,
         (): &mut Self::ViewState,
         ctx: &mut ViewCtx,
-        mut element: WidgetMut<'_, widget::Label>,
-    ) {
+        mut element: Mut<'el, Self::Element>,
+    ) -> Mut<'el, Self::Element> {
         if prev.label != self.label {
             element.set_text(self.label.clone());
             ctx.mark_changed();
@@ -78,10 +76,10 @@ impl<State, Action> View<State, Action, ViewCtx> for Label {
             element.set_alignment(self.alignment);
             ctx.mark_changed();
         }
+        element
     }
 
-    fn teardown(&self, (): &mut Self::ViewState, _: &mut ViewCtx, _: WidgetMut<'_, widget::Label>) {
-    }
+    fn teardown(&self, (): &mut Self::ViewState, _: &mut ViewCtx, _: Mut<'_, Self::Element>) {}
 
     fn message(
         &self,
diff --git a/xilem/src/view/prose.rs b/xilem/src/view/prose.rs
index d19d5f28c..546a7cde5 100644
--- a/xilem/src/view/prose.rs
+++ b/xilem/src/view/prose.rs
@@ -1,11 +1,8 @@
 // Copyright 2024 the Xilem Authors
 // SPDX-License-Identifier: Apache-2.0
 
-use masonry::{
-    text2::TextBrush,
-    widget::{self, WidgetMut},
-    ArcStr,
-};
+use masonry::{text2::TextBrush, widget, ArcStr};
+use xilem_core::Mut;
 
 use crate::{Color, MessageResult, Pod, TextAlignment, View, ViewCtx, ViewId};
 
@@ -57,13 +54,13 @@ impl<State, Action> View<State, Action, ViewCtx> for Prose {
         (widget_pod, ())
     }
 
-    fn rebuild(
+    fn rebuild<'el>(
         &self,
         prev: &Self,
         (): &mut Self::ViewState,
         ctx: &mut ViewCtx,
-        mut element: WidgetMut<'_, widget::Prose>,
-    ) {
+        mut element: Mut<'el, Self::Element>,
+    ) -> Mut<'el, Self::Element> {
         if prev.label != self.label {
             element.set_text(self.label.clone());
             ctx.mark_changed();
@@ -76,10 +73,10 @@ impl<State, Action> View<State, Action, ViewCtx> for Prose {
             element.set_alignment(self.alignment);
             ctx.mark_changed();
         }
+        element
     }
 
-    fn teardown(&self, (): &mut Self::ViewState, _: &mut ViewCtx, _: WidgetMut<'_, widget::Prose>) {
-    }
+    fn teardown(&self, (): &mut Self::ViewState, _: &mut ViewCtx, _: Mut<'_, Self::Element>) {}
 
     fn message(
         &self,
diff --git a/xilem/src/view/textbox.rs b/xilem/src/view/textbox.rs
index 91c3f2ce4..fd2b046b7 100644
--- a/xilem/src/view/textbox.rs
+++ b/xilem/src/view/textbox.rs
@@ -1,11 +1,8 @@
 // Copyright 2024 the Xilem Authors
 // SPDX-License-Identifier: Apache-2.0
 
-use masonry::{
-    text2::TextBrush,
-    widget::{self, WidgetMut},
-};
-use xilem_core::View;
+use masonry::{text2::TextBrush, widget};
+use xilem_core::{Mut, View};
 
 use crate::{Color, MessageResult, Pod, TextAlignment, ViewCtx, ViewId};
 
@@ -80,13 +77,13 @@ impl<State: 'static, Action: 'static> View<State, Action, ViewCtx> for Textbox<S
         })
     }
 
-    fn rebuild(
+    fn rebuild<'el>(
         &self,
         prev: &Self,
         _: &mut Self::ViewState,
         ctx: &mut ViewCtx,
-        mut element: WidgetMut<widget::Textbox>,
-    ) {
+        mut element: Mut<'el, Self::Element>,
+    ) -> Mut<'el, Self::Element> {
         // Unlike the other properties, we don't compare to the previous value;
         // instead, we compare directly to the element's text. This is to handle
         // cases like "Previous data says contents is 'fooba', user presses 'r',
@@ -107,13 +104,14 @@ impl<State: 'static, Action: 'static> View<State, Action, ViewCtx> for Textbox<S
             element.set_alignment(self.alignment);
             ctx.mark_changed();
         }
+        element
     }
 
     fn teardown(
         &self,
         _: &mut Self::ViewState,
         ctx: &mut ViewCtx,
-        element: <Self::Element as xilem_core::ViewElement>::Mut<'_>,
+        element: Mut<'_, Self::Element>,
     ) {
         ctx.teardown_leaf(element);
     }
diff --git a/xilem_core/examples/filesystem.rs b/xilem_core/examples/filesystem.rs
index da8d8b49e..a87a4743c 100644
--- a/xilem_core/examples/filesystem.rs
+++ b/xilem_core/examples/filesystem.rs
@@ -3,7 +3,9 @@
 
 use std::{io::stdin, path::PathBuf};
 
-use xilem_core::{AnyElement, AnyView, SuperElement, View, ViewElement, ViewId, ViewPathTracker};
+use xilem_core::{
+    AnyElement, AnyView, Mut, SuperElement, View, ViewElement, ViewId, ViewPathTracker,
+};
 
 #[derive(Debug)]
 enum State {
@@ -103,7 +105,7 @@ impl SuperElement<FsPath> for FsPath {
 
     fn with_downcast_val<R>(
         this: Self::Mut<'_>,
-        f: impl FnOnce(<FsPath as ViewElement>::Mut<'_>) -> R,
+        f: impl FnOnce(Mut<'_, FsPath>) -> R,
     ) -> (Self::Mut<'_>, R) {
         let ret = f(this);
         (this, ret)
@@ -155,28 +157,29 @@ impl<State, Action> View<State, Action, ViewCtx> for File {
         (path.into(), ())
     }
 
-    fn rebuild(
+    fn rebuild<'el>(
         &self,
         prev: &Self,
         _view_state: &mut Self::ViewState,
         ctx: &mut ViewCtx,
-        element: <Self::Element as xilem_core::ViewElement>::Mut<'_>,
-    ) {
+        element: Mut<'el, Self::Element>,
+    ) -> Mut<'el, Self::Element> {
         if prev.name != self.name {
             let new_path = ctx.current_folder_path.join(&*self.name);
             let _ = std::fs::rename(&element, &new_path);
             *element = new_path;
         }
         if self.contents != prev.contents {
-            let _ = std::fs::write(element, self.contents.as_bytes());
+            let _ = std::fs::write(&element, self.contents.as_bytes());
         }
+        element
     }
 
     fn teardown(
         &self,
         _view_state: &mut Self::ViewState,
         _ctx: &mut ViewCtx,
-        element: <Self::Element as xilem_core::ViewElement>::Mut<'_>,
+        element: Mut<'_, Self::Element>,
     ) {
         let _ = std::fs::remove_file(element);
     }
diff --git a/xilem_core/examples/user_interface.rs b/xilem_core/examples/user_interface.rs
index 5926888ea..b7f151d59 100644
--- a/xilem_core/examples/user_interface.rs
+++ b/xilem_core/examples/user_interface.rs
@@ -6,7 +6,7 @@
 use core::any::Any;
 
 use xilem_core::{
-    DynMessage, MessageResult, SuperElement, View, ViewElement, ViewId, ViewPathTracker,
+    DynMessage, MessageResult, Mut, SuperElement, View, ViewElement, ViewId, ViewPathTracker,
 };
 
 pub fn app_logic(_: &mut u32) -> impl WidgetView<u32> {
@@ -57,21 +57,22 @@ impl<State, Action> View<State, Action, ViewCtx> for Button {
         )
     }
 
-    fn rebuild(
+    fn rebuild<'el>(
         &self,
         _prev: &Self,
         _view_state: &mut Self::ViewState,
         _ctx: &mut ViewCtx,
-        _element: <Self::Element as ViewElement>::Mut<'_>,
-    ) {
+        element: Mut<'el, Self::Element>,
+    ) -> Mut<'el, Self::Element> {
         // Nothing to do
+        element
     }
 
     fn teardown(
         &self,
         _view_state: &mut Self::ViewState,
         _ctx: &mut ViewCtx,
-        _element: <Self::Element as ViewElement>::Mut<'_>,
+        _element: Mut<'_, Self::Element>,
     ) {
         // Nothing to do
     }
diff --git a/xilem_core/src/any_view.rs b/xilem_core/src/any_view.rs
index 0a0e606b8..b3f201178 100644
--- a/xilem_core/src/any_view.rs
+++ b/xilem_core/src/any_view.rs
@@ -7,7 +7,7 @@ use core::any::Any;
 
 use alloc::boxed::Box;
 
-use crate::{AnyElement, DynMessage, MessageResult, View, ViewId, ViewPathTracker};
+use crate::{AnyElement, DynMessage, MessageResult, Mut, View, ViewId, ViewPathTracker};
 
 /// A view which can have any view type where the [`View::Element`] is compatible with
 /// `Element`.
@@ -28,13 +28,13 @@ pub trait AnyView<State, Action, Context, Element: crate::ViewElement> {
 
     fn dyn_build(&self, ctx: &mut Context) -> (Element, AnyViewState);
 
-    fn dyn_rebuild(
+    fn dyn_rebuild<'el>(
         &self,
         dyn_state: &mut AnyViewState,
         ctx: &mut Context,
         prev: &dyn AnyView<State, Action, Context, Element>,
-        element: Element::Mut<'_>,
-    );
+        element: Element::Mut<'el>,
+    ) -> Element::Mut<'el>;
 
     /// Returns `Element::Mut<'el>` so that the element can be
     /// returned and replaced in `dyn_rebuild`, if needed
@@ -78,13 +78,13 @@ where
         )
     }
 
-    fn dyn_rebuild(
+    fn dyn_rebuild<'el>(
         &self,
         dyn_state: &mut AnyViewState,
         ctx: &mut Context,
         prev: &dyn AnyView<State, Action, Context, DynamicElement>,
-        mut element: <DynamicElement as crate::ViewElement>::Mut<'_>,
-    ) {
+        mut element: DynamicElement::Mut<'el>,
+    ) -> DynamicElement::Mut<'el> {
         if let Some(prev) = prev.as_any().downcast_ref() {
             // If we were previously of this type, then do a normal rebuild
             DynamicElement::with_downcast(element, |element| {
@@ -96,7 +96,7 @@ where
                 ctx.with_id(ViewId::new(dyn_state.generation), move |ctx| {
                     self.rebuild(prev, state, ctx, element);
                 });
-            });
+            })
         } else {
             // Otherwise, teardown the old element, then replace the value
             element = prev.dyn_teardown(dyn_state, ctx, element);
@@ -108,15 +108,15 @@ where
             let (new_element, view_state) =
                 ctx.with_id(ViewId::new(dyn_state.generation), |ctx| self.build(ctx));
             dyn_state.inner_state = Box::new(view_state);
-            DynamicElement::replace_inner(element, new_element);
+            DynamicElement::replace_inner(element, new_element)
         }
     }
     fn dyn_teardown<'el>(
         &self,
         dyn_state: &mut AnyViewState,
         ctx: &mut Context,
-        element: <DynamicElement as crate::ViewElement>::Mut<'el>,
-    ) -> <DynamicElement as crate::ViewElement>::Mut<'el> {
+        element: DynamicElement::Mut<'el>,
+    ) -> DynamicElement::Mut<'el> {
         let state = dyn_state
             .inner_state
             .downcast_mut()
@@ -175,21 +175,21 @@ where
         self.dyn_build(ctx)
     }
 
-    fn rebuild(
+    fn rebuild<'el>(
         &self,
         prev: &Self,
         view_state: &mut Self::ViewState,
         ctx: &mut Context,
-        element: <Self::Element as crate::ViewElement>::Mut<'_>,
-    ) {
-        self.dyn_rebuild(view_state, ctx, prev, element);
+        element: Mut<'el, Self::Element>,
+    ) -> Mut<'el, Self::Element> {
+        self.dyn_rebuild(view_state, ctx, prev, element)
     }
 
     fn teardown(
         &self,
         view_state: &mut Self::ViewState,
         ctx: &mut Context,
-        element: <Self::Element as crate::ViewElement>::Mut<'_>,
+        element: Mut<'_, Self::Element>,
     ) {
         self.dyn_teardown(view_state, ctx, element);
     }
@@ -221,21 +221,21 @@ where
         self.dyn_build(ctx)
     }
 
-    fn rebuild(
+    fn rebuild<'el>(
         &self,
         prev: &Self,
         view_state: &mut Self::ViewState,
         ctx: &mut Context,
-        element: <Self::Element as crate::ViewElement>::Mut<'_>,
-    ) {
-        self.dyn_rebuild(view_state, ctx, prev, element);
+        element: Mut<'el, Self::Element>,
+    ) -> Mut<'el, Self::Element> {
+        self.dyn_rebuild(view_state, ctx, prev, element)
     }
 
     fn teardown(
         &self,
         view_state: &mut Self::ViewState,
         ctx: &mut Context,
-        element: <Self::Element as crate::ViewElement>::Mut<'_>,
+        element: Mut<'_, Self::Element>,
     ) {
         self.dyn_teardown(view_state, ctx, element);
     }
@@ -266,21 +266,21 @@ where
         self.dyn_build(ctx)
     }
 
-    fn rebuild(
+    fn rebuild<'el>(
         &self,
         prev: &Self,
         view_state: &mut Self::ViewState,
         ctx: &mut Context,
-        element: <Self::Element as crate::ViewElement>::Mut<'_>,
-    ) {
-        self.dyn_rebuild(view_state, ctx, prev, element);
+        element: Mut<'el, Self::Element>,
+    ) -> Mut<'el, Self::Element> {
+        self.dyn_rebuild(view_state, ctx, prev, element)
     }
 
     fn teardown(
         &self,
         view_state: &mut Self::ViewState,
         ctx: &mut Context,
-        element: <Self::Element as crate::ViewElement>::Mut<'_>,
+        element: Mut<'_, Self::Element>,
     ) {
         self.dyn_teardown(view_state, ctx, element);
     }
@@ -311,21 +311,21 @@ where
         self.dyn_build(ctx)
     }
 
-    fn rebuild(
+    fn rebuild<'el>(
         &self,
         prev: &Self,
         view_state: &mut Self::ViewState,
         ctx: &mut Context,
-        element: <Self::Element as crate::ViewElement>::Mut<'_>,
-    ) {
-        self.dyn_rebuild(view_state, ctx, prev, element);
+        element: Mut<'el, Self::Element>,
+    ) -> Mut<'el, Self::Element> {
+        self.dyn_rebuild(view_state, ctx, prev, element)
     }
 
     fn teardown(
         &self,
         view_state: &mut Self::ViewState,
         ctx: &mut Context,
-        element: <Self::Element as crate::ViewElement>::Mut<'_>,
+        element: Mut<'_, Self::Element>,
     ) {
         self.dyn_teardown(view_state, ctx, element);
     }
diff --git a/xilem_core/src/lib.rs b/xilem_core/src/lib.rs
index 35ebc84fc..cd638d072 100644
--- a/xilem_core/src/lib.rs
+++ b/xilem_core/src/lib.rs
@@ -44,3 +44,7 @@ pub use any_view::AnyView;
 
 mod sequence;
 pub use sequence::{AppendVec, ElementSplice, ViewSequence};
+
+/// This alias is syntax sugar to avoid the elaborate expansion of
+/// `<Self::Element as ViewElement>::Mut<'el>` in the View trait when implementing it (e.g. via rust-analyzer)
+pub type Mut<'el, E> = <E as ViewElement>::Mut<'el>;
diff --git a/xilem_core/src/view.rs b/xilem_core/src/view.rs
index b63d50d91..20c3746f4 100644
--- a/xilem_core/src/view.rs
+++ b/xilem_core/src/view.rs
@@ -7,7 +7,7 @@ use core::ops::Deref;
 
 use alloc::{boxed::Box, sync::Arc};
 
-use crate::{message::MessageResult, DynMessage, ViewElement};
+use crate::{message::MessageResult, DynMessage, Mut, ViewElement};
 
 /// A lightweight, short-lived representation of the state of a retained
 /// structure, usually a user interface node.
@@ -50,13 +50,17 @@ pub trait View<State, Action, Context: ViewPathTracker>: 'static {
     fn build(&self, ctx: &mut Context) -> (Self::Element, Self::ViewState);
 
     /// Update `element` based on the difference between `self` and `prev`.
-    fn rebuild(
+    ///
+    /// This returns `element`, to allow parent views to modify the element after this `rebuild` has
+    /// completed. This returning is needed as some reference types do not allow reborrowing,
+    /// without unwieldy boilerplate.
+    fn rebuild<'el>(
         &self,
         prev: &Self,
         view_state: &mut Self::ViewState,
         ctx: &mut Context,
-        element: <Self::Element as ViewElement>::Mut<'_>,
-    );
+        element: Mut<'el, Self::Element>,
+    ) -> Mut<'el, Self::Element>;
 
     /// Handle `element` being removed from the tree.
     ///
@@ -69,7 +73,7 @@ pub trait View<State, Action, Context: ViewPathTracker>: 'static {
         &self,
         view_state: &mut Self::ViewState,
         ctx: &mut Context,
-        element: <Self::Element as ViewElement>::Mut<'_>,
+        element: Mut<'_, Self::Element>,
     );
 
     /// Route `message` to `id_path`, if that is still a valid path.
@@ -133,23 +137,26 @@ impl<State, Action, Context: ViewPathTracker, V: View<State, Action, Context> +
     fn build(&self, ctx: &mut Context) -> (Self::Element, Self::ViewState) {
         self.deref().build(ctx)
     }
-    fn rebuild(
+
+    fn rebuild<'el>(
         &self,
         prev: &Self,
         view_state: &mut Self::ViewState,
         ctx: &mut Context,
-        element: <Self::Element as ViewElement>::Mut<'_>,
-    ) {
-        self.deref().rebuild(prev, view_state, ctx, element);
+        element: Mut<'el, Self::Element>,
+    ) -> Mut<'el, Self::Element> {
+        self.deref().rebuild(prev, view_state, ctx, element)
     }
+
     fn teardown(
         &self,
         view_state: &mut Self::ViewState,
         ctx: &mut Context,
-        element: <Self::Element as ViewElement>::Mut<'_>,
+        element: Mut<'_, Self::Element>,
     ) {
         self.deref().teardown(view_state, ctx, element);
     }
+
     fn message(
         &self,
         view_state: &mut Self::ViewState,
@@ -172,25 +179,30 @@ impl<State, Action, Context: ViewPathTracker, V: View<State, Action, Context> +
     fn build(&self, ctx: &mut Context) -> (Self::Element, Self::ViewState) {
         self.deref().build(ctx)
     }
-    fn rebuild(
+
+    fn rebuild<'el>(
         &self,
         prev: &Self,
         view_state: &mut Self::ViewState,
         ctx: &mut Context,
-        element: <Self::Element as ViewElement>::Mut<'_>,
-    ) {
+        element: Mut<'el, Self::Element>,
+    ) -> Mut<'el, Self::Element> {
         if !Arc::ptr_eq(self, prev) {
-            self.deref().rebuild(prev, view_state, ctx, element);
+            self.deref().rebuild(prev, view_state, ctx, element)
+        } else {
+            element
         }
     }
+
     fn teardown(
         &self,
         view_state: &mut Self::ViewState,
         ctx: &mut Context,
-        element: <Self::Element as ViewElement>::Mut<'_>,
+        element: Mut<'_, Self::Element>,
     ) {
         self.deref().teardown(view_state, ctx, element);
     }
+
     fn message(
         &self,
         view_state: &mut Self::ViewState,
diff --git a/xilem_core/src/views/memoize.rs b/xilem_core/src/views/memoize.rs
index 77fac4bcb..0f2a59a04 100644
--- a/xilem_core/src/views/memoize.rs
+++ b/xilem_core/src/views/memoize.rs
@@ -1,7 +1,7 @@
 // Copyright 2024 the Xilem Authors
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{DynMessage, MessageResult, View, ViewElement, ViewId, ViewPathTracker};
+use crate::{DynMessage, MessageResult, Mut, View, ViewId, ViewPathTracker};
 
 pub struct Memoize<D, F> {
     data: D,
@@ -64,17 +64,20 @@ where
         (element, memoize_state)
     }
 
-    fn rebuild(
+    fn rebuild<'el>(
         &self,
         prev: &Self,
         view_state: &mut Self::ViewState,
         cx: &mut Context,
-        element: <Self::Element as ViewElement>::Mut<'_>,
-    ) {
+        element: Mut<'el, Self::Element>,
+    ) -> Mut<'el, Self::Element> {
         if core::mem::take(&mut view_state.dirty) || prev.data != self.data {
             let view = (self.child_cb)(&self.data);
-            view.rebuild(&view_state.view, &mut view_state.view_state, cx, element);
+            let el = view.rebuild(&view_state.view, &mut view_state.view_state, cx, element);
             view_state.view = view;
+            el
+        } else {
+            element
         }
     }
 
@@ -99,7 +102,7 @@ where
         &self,
         view_state: &mut Self::ViewState,
         ctx: &mut Context,
-        element: <Self::Element as crate::ViewElement>::Mut<'_>,
+        element: Mut<'_, Self::Element>,
     ) {
         view_state
             .view
diff --git a/xilem_core/tests/common/mod.rs b/xilem_core/tests/common/mod.rs
index 5c98c3131..fa7b3ac75 100644
--- a/xilem_core/tests/common/mod.rs
+++ b/xilem_core/tests/common/mod.rs
@@ -95,13 +95,13 @@ where
         )
     }
 
-    fn rebuild(
+    fn rebuild<'el>(
         &self,
         prev: &Self,
         view_state: &mut Self::ViewState,
         ctx: &mut TestCx,
-        element: <Self::Element as ViewElement>::Mut<'_>,
-    ) {
+        element: Mut<'el, Self::Element>,
+    ) -> Mut<'el, Self::Element> {
         let mut elements = SeqTracker {
             inner: element.children.as_mut().unwrap(),
             ix: 0,
@@ -109,13 +109,14 @@ where
         };
         self.seq
             .seq_rebuild(&prev.seq, &mut view_state.0, ctx, &mut elements);
+        element
     }
 
     fn teardown(
         &self,
         view_state: &mut Self::ViewState,
         ctx: &mut TestCx,
-        element: <Self::Element as ViewElement>::Mut<'_>,
+        element: Mut<'_, Self::Element>,
     ) {
         let mut elements = SeqTracker {
             inner: element.children.as_mut().unwrap(),
@@ -153,26 +154,22 @@ impl<const N: u32> View<(), Action, TestCx> for OperationView<N> {
         )
     }
 
-    fn rebuild(
+    fn rebuild<'el>(
         &self,
         prev: &Self,
         _: &mut Self::ViewState,
         ctx: &mut TestCx,
-        element: <Self::Element as ViewElement>::Mut<'_>,
-    ) {
+        element: Mut<'el, Self::Element>,
+    ) -> Mut<'el, Self::Element> {
         assert_eq!(&*element.view_path, ctx.view_path());
         element.operations.push(Operation::Rebuild {
             from: prev.0,
             to: self.0,
         });
+        element
     }
 
-    fn teardown(
-        &self,
-        _: &mut Self::ViewState,
-        ctx: &mut TestCx,
-        element: <Self::Element as ViewElement>::Mut<'_>,
-    ) {
+    fn teardown(&self, _: &mut Self::ViewState, ctx: &mut TestCx, element: Mut<'_, Self::Element>) {
         assert_eq!(&*element.view_path, ctx.view_path());
         element.operations.push(Operation::Teardown(self.0));
     }
@@ -199,7 +196,7 @@ impl SuperElement<TestElement> for TestElement {
 
     fn with_downcast_val<R>(
         this: Self::Mut<'_>,
-        f: impl FnOnce(<TestElement as ViewElement>::Mut<'_>) -> R,
+        f: impl FnOnce(Mut<'_, TestElement>) -> R,
     ) -> (Self::Mut<'_>, R) {
         let ret = f(this);
         (this, ret)
@@ -257,7 +254,7 @@ impl<'a> ElementSplice<TestElement> for SeqTracker<'a> {
     fn insert(&mut self, element: TestElement) {
         self.inner.active.push(element);
     }
-    fn mutate<R>(&mut self, f: impl FnOnce(<TestElement as ViewElement>::Mut<'_>) -> R) -> R {
+    fn mutate<R>(&mut self, f: impl FnOnce(Mut<'_, TestElement>) -> R) -> R {
         let ix = self.ix;
         self.ix += 1;
         f(&mut self.inner.active[ix])
@@ -265,7 +262,7 @@ impl<'a> ElementSplice<TestElement> for SeqTracker<'a> {
     fn skip(&mut self, n: usize) {
         self.ix += n;
     }
-    fn delete<R>(&mut self, f: impl FnOnce(<TestElement as ViewElement>::Mut<'_>) -> R) -> R {
+    fn delete<R>(&mut self, f: impl FnOnce(Mut<'_, TestElement>) -> R) -> R {
         let ret = f(&mut self.inner.active[self.ix]);
         let val = self.inner.active.remove(self.ix);
         self.inner.deleted.push((self.ix, val));