Could a write_on_drop method be useful for using signals across await points?

[jaysonmaw]

I unfortunately ran into the need to call an async fn(&mut self) function on a type that exists inside a Signal.
Code looked something like:

let sig = use_signal(||MyAsyncType::new())

rsx!{
    Button {
        onclick: move |_| async move {
            //Problem is here, we are holding a lock across an await point without realizing
            sig.write().increment(5).await;
        },
        "+5"
    }
}

Due to me not doing a good enough job of reading the docs, I quickly started having panics all over the app.
I did eventually figure out that this was the issue, and found docs explaining that the dioxus idiomatic way around this was to do something like:

rsx!{
    Button {
        onclick: move |_| async move {
            //Dioxus proposed solution
            let mut temp = sig.read().clone();
            temp.increment(5).await;
            sig.set(temp);
        },
        "+5"
    }
}

This ends up very cluttered and error prone if I forget to set the signal back to the temporary value, I ended up playing around with the idea of a write_on_drop() method to accomplish the same thing, and wondered if there was anything I'm missing on why this is a bad idea as it seems to work well.

With my write_on_drop() method the code ends up looking like:

rsx!{
    Button {
        onclick: move |_| async move {
            //example 1
            {
                //with write_on_drop, value is cloned, and then set back after the await point
                sig.write_on_drop().value().increment(5).await;
            }

            //example 2
            {
                //alternatively if you need to do many operations you would do something like 
                let mut temp = sig.write_on_drop();
                temp.value().increment(5).await;
                temp.value().set(0).await;

                info!("The current state of the temp cloned value before actually updating the signal: {:?}",&*temp.value());

                //Does not compile, as we are holding &mut sig inside temp, so you don't read "stale" value by accident
                //sig.read()

                //Only here does temp get dropped and actually update the value
                //alternatively you can call drop(temp) yourself
            }
        },
        "+5"
    }
}

From my very limited testing this does seem to work as expected. It could also be named something like async_safe_write() to help guide users to the happy path.

The actual code for this is under "WriteOnDrop impl code" below, I wrote this with very little thought, so this specific impl may have issues but is just to get the general idea across, and put it here incase anyone wants to try it out.

WriteOnDrop impl code

use dioxus::prelude::{Readable, ReadableExt, WritableExt};

pub struct WriteOnDrop<'a, W>
where 
    W: WritableExt,
    <W as Readable>::Target: 'static + Sized + Clone,
{
    signal: &'a mut W,
    temp_value: Option<<W as Readable>::Target>,
}

pub struct WriteOnDropRef<'a, 'lock, W>
where 
    W: WritableExt,
    <W as Readable>::Target: 'static + Sized + Clone,
{
    inner: &'lock mut WriteOnDrop<'a, W>,
}

impl<'a, W> WriteOnDrop<'a, W>
where 
    W: WritableExt,
    <W as Readable>::Target: 'static + Sized + Clone,
{
    pub fn value(&mut self) -> WriteOnDropRef<'a, '_, W> {
        WriteOnDropRef { inner: self }
    }
}

impl<'a, 'lock, W> std::ops::Deref for WriteOnDropRef<'a, 'lock, W>
where 
    W: WritableExt,
    <W as Readable>::Target: 'static + Sized + Clone,
{
    type Target = <W as Readable>::Target;

    fn deref(&self) -> &Self::Target {
        self.inner.temp_value.as_ref().unwrap()
    }
}

impl<'a, 'lock, W> std::ops::DerefMut for WriteOnDropRef<'a, 'lock, W>
where 
    W: WritableExt,
    <W as Readable>::Target: 'static + Sized + Clone,
{
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.inner.temp_value.as_mut().unwrap()
    }
}

impl<'a, W> Drop for WriteOnDrop<'a, W>
where 
    W: WritableExt,
    <W as Readable>::Target: 'static + Sized + Clone,
{
    fn drop(&mut self) {
        let v = self.temp_value.take().unwrap();
        self.signal.set(v);
    }
}

pub trait WriteOnDropExt: WritableExt
where
     Self: Sized,
    <Self as Readable>::Target: 'static + Sized + Clone
{
    fn write_on_drop<'a>(&'a mut self) -> WriteOnDrop<'a, Self>{
        let temp_value = self.read().clone();
        WriteOnDrop {
            signal: self,
            temp_value: Some(temp_value),
        }
    }
}

impl<W: WritableExt + Sized> WriteOnDropExt for W
where <W as Readable>::Target: 'static + Sized + Clone{}

I'm currently using this across my app with seemingly no issues, so just thought it could be a good idea to share.