update: modify usestate to be borrowed

examples/calculator.rs

@@ -18,7 +18,7 @@ fn main() {
 }
 
 fn app(cx: Scope) -> Element {
-    let display_value: UseState<String> = use_state(&cx, || String::from("0"));
+    let display_value = use_state(&cx, || String::from("0"));
 
     let input_digit = move |num: u8| {
         if display_value.get() == "0" {
@@ -66,11 +66,11 @@ fn app(cx: Scope) -> Element {
                                     class: "calculator-key key-clear",
                                     onclick: move |_| {
                                         display_value.set(String::new());
-                                        if display_value != "" {
+                                        if *display_value != "" {
                                             display_value.set("0".into());
                                         }
                                     },
-                                    [if display_value == "" { "C" } else { "AC" }]
+                                    [if *display_value == "" { "C" } else { "AC" }]
                                 }
                                 button {
                                     class: "calculator-key key-sign",

examples/crm.rs

@@ -38,7 +38,7 @@ fn app(cx: Scope) -> Element {
 
             h1 {"Dioxus CRM Example"}
 
-            match *scene {
+            match scene.get() {
                 Scene::ClientsList => rsx!(
                     div { class: "crm",
                         h2 { margin_bottom: "10px", "List of clients" }

examples/disabled.rs

@@ -11,7 +11,7 @@ fn app(cx: Scope) -> Element {
         div {
             button {
                 onclick: move |_| disabled.set(!disabled.get()),
-                "click to " [if *disabled {"enable"} else {"disable"} ] " the lower button"
+                "click to " [if **disabled {"enable"} else {"disable"} ] " the lower button"
             }
 
             button {

examples/dog_app.rs

@@ -42,7 +42,7 @@ fn app(cx: Scope) -> Element {
                         ))
                     }
                     div { flex: "50%",
-                        match &*selected_breed {
+                        match selected_breed.get() {
                             Some(breed) => rsx!( Breed { breed: breed.clone() } ),
                             None => rsx!("No Breed selected"),
                         }

examples/readme.rs

@@ -9,13 +9,13 @@ fn main() {
 }
 
 fn app(cx: Scope) -> Element {
-    let mut count = use_state(&cx, || 0);
+    let count = use_state(&cx, || 0);
 
     cx.render(rsx! {
         div {
             h1 { "High-Five counter: {count}" }
-            button { onclick: move |_| count += 1, "Up high!" }
-            button { onclick: move |_| count -= 1, "Down low!" }
+            button { onclick: move |_| *count.modify() += 1, "Up high!" }
+            button { onclick: move |_| *count.modify() -= 1, "Down low!" }
         }
     })
 }

examples/todomvc.rs

@@ -19,15 +19,15 @@ pub struct TodoItem {
 }
 
 pub fn app(cx: Scope<()>) -> Element {
-    let todos = use_state(&cx, || im_rc::HashMap::<u32, TodoItem>::default());
+    let todos = use_state(&cx, im_rc::HashMap::<u32, TodoItem>::default);
     let filter = use_state(&cx, || FilterState::All);
     let draft = use_state(&cx, || "".to_string());
-    let mut todo_id = use_state(&cx, || 0);
+    let (todo_id, set_todo_id) = use_state(&cx, || 0).split();
 
     // Filter the todos based on the filter state
     let mut filtered_todos = todos
         .iter()
-        .filter(|(_, item)| match *filter {
+        .filter(|(_, item)| match **filter {
             FilterState::All => true,
             FilterState::Active => !item.checked,
             FilterState::Completed => item.checked,
@@ -56,19 +56,17 @@ pub fn app(cx: Scope<()>) -> Element {
                         autofocus: "true",
                         oninput: move |evt| draft.set(evt.value.clone()),
                         onkeydown: move |evt| {
-                            if evt.key == "Enter" {
-                                if !draft.is_empty() {
-                                    todos.modify().insert(
-                                        *todo_id,
-                                        TodoItem {
-                                            id: *todo_id,
-                                            checked: false,
-                                            contents: draft.get().clone(),
-                                        },
-                                    );
-                                    todo_id += 1;
-                                    draft.set("".to_string());
-                                }
+                            if evt.key == "Enter" && !draft.is_empty() {
+                                todos.modify().insert(
+                                    *todo_id,
+                                    TodoItem {
+                                        id: *todo_id,
+                                        checked: false,
+                                        contents: draft.get().clone(),
+                                    },
+                                );
+                                set_todo_id(todo_id + 1);
+                                draft.set("".to_string());
                             }
                         }
                     }
@@ -90,7 +88,7 @@ pub fn app(cx: Scope<()>) -> Element {
                         (show_clear_completed).then(|| rsx!(
                             button {
                                 class: "clear-completed",
-                                onclick: move |_| todos.modify().retain(|_, todo| todo.checked == false),
+                                onclick: move |_| todos.modify().retain(|_, todo| !todo.checked),
                                 "Clear completed"
                             }
                         ))
@@ -108,7 +106,7 @@ pub fn app(cx: Scope<()>) -> Element {
 
 #[derive(Props)]
 pub struct TodoEntryProps<'a> {
-    todos: UseState<'a, im_rc::HashMap<u32, TodoItem>>,
+    todos: &'a UseState<im_rc::HashMap<u32, TodoItem>>,
     id: u32,
 }
 

packages/hooks/src/usestate.rs

@@ -0,0 +1,212 @@
+use dioxus_core::prelude::*;
+use std::{
+    cell::{Cell, Ref, RefCell, RefMut},
+    fmt::{Debug, Display},
+    rc::Rc,
+};
+
+/// Store state between component renders!
+///
+/// ## Dioxus equivalent of useState, designed for Rust
+///
+/// The Dioxus version of `useState` for state management inside components. It allows you to ergonomically store and
+/// modify state between component renders. When the state is updated, the component will re-render.
+///
+/// Dioxus' use_state basically wraps a RefCell with helper methods and integrates it with the VirtualDOM update system.
+///
+/// [`use_state`] exposes a few helper methods to modify the underlying state:
+/// - `.set(new)` allows you to override the "work in progress" value with a new value
+/// - `.get_mut()` allows you to modify the WIP value
+/// - `.get_wip()` allows you to access the WIP value
+/// - `.deref()` provides the previous value (often done implicitly, though a manual dereference with `*` might be required)
+///
+/// Additionally, a ton of std::ops traits are implemented for the `UseState` wrapper, meaning any mutative type operations
+/// will automatically be called on the WIP value.
+///
+/// ## Combinators
+///
+/// On top of the methods to set/get state, `use_state` also supports fancy combinators to extend its functionality:
+/// - `.classic()` and `.split()`  convert the hook into the classic React-style hook
+///     ```rust
+///     let (state, set_state) = use_state(&cx, || 10).split()
+///     ```
+/// Usage:
+///
+/// ```ignore
+/// const Example: Component = |cx| {
+///     let counter = use_state(&cx, || 0);
+///
+///     cx.render(rsx! {
+///         div {
+///             h1 { "Counter: {counter}" }
+///             button { onclick: move |_| counter.set(**counter + 1), "Increment" }
+///             button { onclick: move |_| counter.set(**counter - 1), "Decrement" }
+///         }
+///     ))
+/// }
+/// ```
+pub fn use_state<'a, T: 'static>(
+    cx: &'a ScopeState,
+    initial_state_fn: impl FnOnce() -> T,
+) -> &'a UseState<T> {
+    let hook = cx.use_hook(move |_| UseState {
+        current_val: Rc::new(initial_state_fn()),
+        update_callback: cx.schedule_update(),
+        wip: Rc::new(RefCell::new(None)),
+        update_scheuled: Cell::new(false),
+    });
+
+    hook.update_scheuled.set(false);
+    let mut new_val = hook.wip.borrow_mut();
+
+    if new_val.is_some() {
+        // if there's only one reference (weak or otherwise), we can just swap the values
+        if let Some(val) = Rc::get_mut(&mut hook.current_val) {
+            *val = new_val.take().unwrap();
+        } else {
+            hook.current_val = Rc::new(new_val.take().unwrap());
+        }
+    }
+
+    hook
+}
+
+pub struct UseState<T: 'static> {
+    pub(crate) current_val: Rc<T>,
+    pub(crate) wip: Rc<RefCell<Option<T>>>,
+    pub(crate) update_callback: Rc<dyn Fn()>,
+    pub(crate) update_scheuled: Cell<bool>,
+}
+
+impl<T: Debug> Debug for UseState<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self.current_val)
+    }
+}
+
+impl<T: 'static> UseState<T> {
+    /// Tell the Dioxus Scheduler that we need to be processed
+    pub fn needs_update(&self) {
+        if !self.update_scheuled.get() {
+            self.update_scheuled.set(true);
+            (self.update_callback)();
+        }
+    }
+
+    pub fn set(&self, new_val: T) {
+        *self.wip.borrow_mut() = Some(new_val);
+        self.needs_update();
+    }
+
+    pub fn get(&self) -> &T {
+        &self.current_val
+    }
+
+    pub fn get_rc(&self) -> &Rc<T> {
+        &self.current_val
+    }
+
+    /// Get the current status of the work-in-progress data
+    pub fn get_wip(&self) -> Ref<Option<T>> {
+        self.wip.borrow()
+    }
+
+    /// Get the current status of the work-in-progress data
+    pub fn get_wip_mut(&self) -> RefMut<Option<T>> {
+        self.wip.borrow_mut()
+    }
+
+    pub fn split(&self) -> (&T, Rc<dyn Fn(T)>) {
+        (&self.current_val, self.setter())
+    }
+
+    pub fn setter(&self) -> Rc<dyn Fn(T)> {
+        let slot = self.wip.clone();
+        let callback = self.update_callback.clone();
+        Rc::new(move |new| {
+            callback();
+            *slot.borrow_mut() = Some(new)
+        })
+    }
+
+    pub fn wtih(&self, f: impl FnOnce(&mut T)) {
+        let mut val = self.wip.borrow_mut();
+
+        if let Some(inner) = val.as_mut() {
+            f(inner);
+        }
+    }
+
+    pub fn for_async(&self) -> UseState<T> {
+        let UseState {
+            current_val,
+            wip,
+            update_callback,
+            update_scheuled,
+        } = self;
+
+        UseState {
+            current_val: current_val.clone(),
+            wip: wip.clone(),
+            update_callback: update_callback.clone(),
+            update_scheuled: update_scheuled.clone(),
+        }
+    }
+}
+
+impl<T: 'static + ToOwned<Owned = T>> UseState<T> {
+    /// Gain mutable access to the new value via [`RefMut`].
+    ///
+    /// If `modify` is called, then the component will re-render.
+    ///
+    /// This method is only available when the value is a `ToOwned` type.
+    ///
+    /// Mutable access is derived by calling "ToOwned" (IE cloning) on the current value.
+    ///
+    /// To get a reference to the current value, use `.get()`
+    pub fn modify(&self) -> RefMut<T> {
+        // make sure we get processed
+        self.needs_update();
+
+        // Bring out the new value, cloning if it we need to
+        // "get_mut" is locked behind "ToOwned" to make it explicit that cloning occurs to use this
+        RefMut::map(self.wip.borrow_mut(), |slot| {
+            if slot.is_none() {
+                *slot = Some(self.current_val.as_ref().to_owned());
+            }
+            slot.as_mut().unwrap()
+        })
+    }
+
+    pub fn inner(self) -> T {
+        self.current_val.as_ref().to_owned()
+    }
+}
+
+impl<'a, T> std::ops::Deref for UseState<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        self.get()
+    }
+}
+
+// enable displaty for the handle
+impl<'a, T: 'static + Display> std::fmt::Display for UseState<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.current_val)
+    }
+}
+
+impl<'a, V, T: PartialEq<V>> PartialEq<V> for UseState<T> {
+    fn eq(&self, other: &V) -> bool {
+        self.get() == other
+    }
+}
+impl<'a, O, T: std::ops::Not<Output = O> + Copy> std::ops::Not for UseState<T> {
+    type Output = O;
+
+    fn not(self) -> Self::Output {
+        !*self.get()
+    }
+}

packages/hooks/src/usestate/handle.rs

@@ -1,215 +0,0 @@
-use super::owned::UseStateOwned;
-use std::{
-    cell::{Ref, RefMut},
-    fmt::{Debug, Display},
-    rc::Rc,
-};
-
-pub struct UseState<'a, T: 'static>(pub(crate) &'a UseStateOwned<T>);
-
-impl<T> Copy for UseState<'_, T> {}
-
-impl<'a, T: 'static> Clone for UseState<'a, T> {
-    fn clone(&self) -> Self {
-        UseState(self.0)
-    }
-}
-
-impl<T: Debug> Debug for UseState<'_, T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{:?}", self.0.current_val)
-    }
-}
-
-impl<'a, T: 'static> UseState<'a, T> {
-    /// Tell the Dioxus Scheduler that we need to be processed
-    pub fn needs_update(&self) {
-        if !self.0.update_scheuled.get() {
-            self.0.update_scheuled.set(true);
-            (self.0.update_callback)();
-        }
-    }
-
-    pub fn set(&self, new_val: T) {
-        *self.0.wip.borrow_mut() = Some(new_val);
-        self.needs_update();
-    }
-
-    pub fn get(&self) -> &'a T {
-        &self.0.current_val
-    }
-
-    pub fn get_rc(&self) -> &'a Rc<T> {
-        &self.0.current_val
-    }
-
-    /// Get the current status of the work-in-progress data
-    pub fn get_wip(&self) -> Ref<Option<T>> {
-        self.0.wip.borrow()
-    }
-
-    /// Get the current status of the work-in-progress data
-    pub fn get_wip_mut(&self) -> RefMut<Option<T>> {
-        self.0.wip.borrow_mut()
-    }
-
-    pub fn classic(self) -> (&'a T, Rc<dyn Fn(T)>) {
-        (&self.0.current_val, self.setter())
-    }
-
-    pub fn setter(&self) -> Rc<dyn Fn(T)> {
-        let slot = self.0.wip.clone();
-        let callback = self.0.update_callback.clone();
-        Rc::new(move |new| {
-            callback();
-            *slot.borrow_mut() = Some(new)
-        })
-    }
-
-    pub fn wtih(&self, f: impl FnOnce(&mut T)) {
-        let mut val = self.0.wip.borrow_mut();
-
-        if let Some(inner) = val.as_mut() {
-            f(inner);
-        }
-    }
-
-    pub fn for_async(&self) -> UseStateOwned<T> {
-        let UseStateOwned {
-            current_val,
-            wip,
-            update_callback,
-            update_scheuled,
-        } = self.0;
-
-        UseStateOwned {
-            current_val: current_val.clone(),
-            wip: wip.clone(),
-            update_callback: update_callback.clone(),
-            update_scheuled: update_scheuled.clone(),
-        }
-    }
-}
-
-impl<'a, T: 'static + ToOwned<Owned = T>> UseState<'a, T> {
-    /// Gain mutable access to the new value via [`RefMut`].
-    ///
-    /// If `modify` is called, then the component will re-render.
-    ///
-    /// This method is only available when the value is a `ToOwned` type.
-    ///
-    /// Mutable access is derived by calling "ToOwned" (IE cloning) on the current value.
-    ///
-    /// To get a reference to the current value, use `.get()`
-    pub fn modify(self) -> RefMut<'a, T> {
-        // make sure we get processed
-        self.needs_update();
-
-        // Bring out the new value, cloning if it we need to
-        // "get_mut" is locked behind "ToOwned" to make it explicit that cloning occurs to use this
-        RefMut::map(self.0.wip.borrow_mut(), |slot| {
-            if slot.is_none() {
-                *slot = Some(self.0.current_val.as_ref().to_owned());
-            }
-            slot.as_mut().unwrap()
-        })
-    }
-
-    pub fn inner(self) -> T {
-        self.0.current_val.as_ref().to_owned()
-    }
-}
-
-impl<'a, T> std::ops::Deref for UseState<'a, T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        self.get()
-    }
-}
-
-// enable displaty for the handle
-impl<'a, T: 'static + Display> std::fmt::Display for UseState<'a, T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0.current_val)
-    }
-}
-impl<'a, V, T: PartialEq<V>> PartialEq<V> for UseState<'a, T> {
-    fn eq(&self, other: &V) -> bool {
-        self.get() == other
-    }
-}
-impl<'a, O, T: std::ops::Not<Output = O> + Copy> std::ops::Not for UseState<'a, T> {
-    type Output = O;
-
-    fn not(self) -> Self::Output {
-        !*self.get()
-    }
-}
-
-/*
-
-Convenience methods for UseState.
-
-Note!
-
-This is not comprehensive.
-This is *just* meant to make common operations easier.
-*/
-
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
-
-impl<'a, T: Copy + Add<T, Output = T>> Add<T> for UseState<'a, T> {
-    type Output = T;
-
-    fn add(self, rhs: T) -> Self::Output {
-        self.0.current_val.add(rhs)
-    }
-}
-impl<'a, T: Copy + Add<T, Output = T>> AddAssign<T> for UseState<'a, T> {
-    fn add_assign(&mut self, rhs: T) {
-        self.set(self.0.current_val.add(rhs));
-    }
-}
-
-/// Sub
-impl<'a, T: Copy + Sub<T, Output = T>> Sub<T> for UseState<'a, T> {
-    type Output = T;
-
-    fn sub(self, rhs: T) -> Self::Output {
-        self.0.current_val.sub(rhs)
-    }
-}
-impl<'a, T: Copy + Sub<T, Output = T>> SubAssign<T> for UseState<'a, T> {
-    fn sub_assign(&mut self, rhs: T) {
-        self.set(self.0.current_val.sub(rhs));
-    }
-}
-
-/// MUL
-impl<'a, T: Copy + Mul<T, Output = T>> Mul<T> for UseState<'a, T> {
-    type Output = T;
-
-    fn mul(self, rhs: T) -> Self::Output {
-        self.0.current_val.mul(rhs)
-    }
-}
-impl<'a, T: Copy + Mul<T, Output = T>> MulAssign<T> for UseState<'a, T> {
-    fn mul_assign(&mut self, rhs: T) {
-        self.set(self.0.current_val.mul(rhs));
-    }
-}
-
-/// DIV
-impl<'a, T: Copy + Div<T, Output = T>> Div<T> for UseState<'a, T> {
-    type Output = T;
-
-    fn div(self, rhs: T) -> Self::Output {
-        self.0.current_val.div(rhs)
-    }
-}
-impl<'a, T: Copy + Div<T, Output = T>> DivAssign<T> for UseState<'a, T> {
-    fn div_assign(&mut self, rhs: T) {
-        self.set(self.0.current_val.div(rhs));
-    }
-}

packages/hooks/src/usestate/mod.rs

@@ -1,78 +0,0 @@
-mod handle;
-mod owned;
-pub use handle::*;
-pub use owned::*;
-
-use dioxus_core::prelude::*;
-use std::{
-    cell::{Cell, RefCell},
-    rc::Rc,
-};
-
-/// Store state between component renders!
-///
-/// ## Dioxus equivalent of useState, designed for Rust
-///
-/// The Dioxus version of `useState` for state management inside components. It allows you to ergonomically store and
-/// modify state between component renders. When the state is updated, the component will re-render.
-///
-/// Dioxus' use_state basically wraps a RefCell with helper methods and integrates it with the VirtualDOM update system.
-///
-/// [`use_state`] exposes a few helper methods to modify the underlying state:
-/// - `.set(new)` allows you to override the "work in progress" value with a new value
-/// - `.get_mut()` allows you to modify the WIP value
-/// - `.get_wip()` allows you to access the WIP value
-/// - `.deref()` provides the previous value (often done implicitly, though a manual dereference with `*` might be required)
-///
-/// Additionally, a ton of std::ops traits are implemented for the `UseState` wrapper, meaning any mutative type operations
-/// will automatically be called on the WIP value.
-///
-/// ## Combinators
-///
-/// On top of the methods to set/get state, `use_state` also supports fancy combinators to extend its functionality:
-/// - `.classic()` and `.split()`  convert the hook into the classic React-style hook
-///     ```rust
-///     let (state, set_state) = use_state(&cx, || 10).split()
-///     ```
-///
-///
-/// Usage:
-///
-/// ```ignore
-/// const Example: Component = |cx| {
-///     let counter = use_state(&cx, || 0);
-///
-///     cx.render(rsx! {
-///         div {
-///             h1 { "Counter: {counter}" }
-///             button { onclick: move |_| counter += 1, "Increment" }
-///             button { onclick: move |_| counter -= 1, "Decrement" }
-///         }
-///     ))
-/// }
-/// ```
-pub fn use_state<'a, T: 'static>(
-    cx: &'a ScopeState,
-    initial_state_fn: impl FnOnce() -> T,
-) -> UseState<'a, T> {
-    let hook = cx.use_hook(move |_| UseStateOwned {
-        current_val: Rc::new(initial_state_fn()),
-        update_callback: cx.schedule_update(),
-        wip: Rc::new(RefCell::new(None)),
-        update_scheuled: Cell::new(false),
-    });
-
-    hook.update_scheuled.set(false);
-    let mut new_val = hook.wip.borrow_mut();
-
-    if new_val.is_some() {
-        // if there's only one reference (weak or otherwise), we can just swap the values
-        if let Some(val) = Rc::get_mut(&mut hook.current_val) {
-            *val = new_val.take().unwrap();
-        } else {
-            hook.current_val = Rc::new(new_val.take().unwrap());
-        }
-    }
-
-    UseState(hook)
-}

packages/hooks/src/usestate/owned.rs

@@ -1,99 +0,0 @@
-use std::{
-    cell::{Cell, Ref, RefCell, RefMut},
-    fmt::{Debug, Display},
-    rc::Rc,
-};
-pub struct UseStateOwned<T: 'static> {
-    // this will always be outdated
-    pub(crate) current_val: Rc<T>,
-    pub(crate) wip: Rc<RefCell<Option<T>>>,
-    pub(crate) update_callback: Rc<dyn Fn()>,
-    pub(crate) update_scheuled: Cell<bool>,
-}
-
-impl<T> UseStateOwned<T> {
-    pub fn get(&self) -> Ref<Option<T>> {
-        self.wip.borrow()
-    }
-
-    pub fn set(&self, new_val: T) {
-        *self.wip.borrow_mut() = Some(new_val);
-        (self.update_callback)();
-    }
-
-    pub fn modify(&self) -> RefMut<Option<T>> {
-        (self.update_callback)();
-        self.wip.borrow_mut()
-    }
-}
-
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
-
-impl<T: Debug> Debug for UseStateOwned<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{:?}", self.current_val)
-    }
-}
-
-// enable displaty for the handle
-impl<'a, T: 'static + Display> std::fmt::Display for UseStateOwned<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.current_val)
-    }
-}
-
-impl<'a, T: Copy + Add<T, Output = T>> Add<T> for UseStateOwned<T> {
-    type Output = T;
-
-    fn add(self, rhs: T) -> Self::Output {
-        self.current_val.add(rhs)
-    }
-}
-
-impl<'a, T: Copy + Add<T, Output = T>> AddAssign<T> for UseStateOwned<T> {
-    fn add_assign(&mut self, rhs: T) {
-        self.set(self.current_val.add(rhs));
-    }
-}
-
-/// Sub
-impl<'a, T: Copy + Sub<T, Output = T>> Sub<T> for UseStateOwned<T> {
-    type Output = T;
-
-    fn sub(self, rhs: T) -> Self::Output {
-        self.current_val.sub(rhs)
-    }
-}
-impl<'a, T: Copy + Sub<T, Output = T>> SubAssign<T> for UseStateOwned<T> {
-    fn sub_assign(&mut self, rhs: T) {
-        self.set(self.current_val.sub(rhs));
-    }
-}
-
-/// MUL
-impl<'a, T: Copy + Mul<T, Output = T>> Mul<T> for UseStateOwned<T> {
-    type Output = T;
-
-    fn mul(self, rhs: T) -> Self::Output {
-        self.current_val.mul(rhs)
-    }
-}
-impl<'a, T: Copy + Mul<T, Output = T>> MulAssign<T> for UseStateOwned<T> {
-    fn mul_assign(&mut self, rhs: T) {
-        self.set(self.current_val.mul(rhs));
-    }
-}
-
-/// DIV
-impl<'a, T: Copy + Div<T, Output = T>> Div<T> for UseStateOwned<T> {
-    type Output = T;
-
-    fn div(self, rhs: T) -> Self::Output {
-        self.current_val.div(rhs)
-    }
-}
-impl<'a, T: Copy + Div<T, Output = T>> DivAssign<T> for UseStateOwned<T> {
-    fn div_assign(&mut self, rhs: T) {
-        self.set(self.current_val.div(rhs));
-    }
-}