Best way to "wrap" a signal?

[sambonbonne]

Hello,

I'm trying to create a "custom signal" in order to have some custom methods. I wrap a RwSignal<bool> in a tuple struct, implement my own methods and forward some traits methods to self.0 (see code example below) but it seems it's not reactive.

First, do I need to implement SignalGetUntracked if I don't need it? Same for SignalSet, SignalSetUntracked, SignalUpdate, …
I just need to make my signal read-only and update it with my own methods.

I saw a discussion about a macro to create signal (see #1233) but while waiting for it, how can I wrap a signal and keep my struct reactive?

Thanks in advance for any help!

Below is the custom signal I implemented, it represents an "opening" signal for some modals and it gives some helpers to toggle the opening state. When I call toggle, close or open, nothing happens visually (I don't know how I can check anything on the internals of the reactive system). Using a raw RwSignal<bool> with _.set(/* bool */) works so I think I just made something wrong while wrapping.

use leptos::{
    create_rw_signal,
    ReadSignal,
    RwSignal,
    SignalGet,
    SignalSet,
    SignalUpdate,
    SignalWith,
};

pub struct OpenedSignal(RwSignal<bool>);

impl OpenedSignal {
    pub fn new(initial_status: bool) -> Self {
        Self(create_rw_signal(initial_status))
    }

    pub fn new_closed() -> Self {
        Self::new(false)
    }

    pub fn new_opened() -> Self {
        Self::new(true)
    }

    pub fn toggle(&self) {
        self.0.set(self.0());
    }

    pub fn open(&self) {
        self.0.set(true);
    }

    pub fn close(&self) {
        self.0.set(true);
    }
}

impl Clone for OpenedSignal {
    fn clone(&self) -> Self {
        *self
    }
}

impl Copy for OpenedSignal {}

impl Default for OpenedSignal {
    fn default() -> Self {
        Self::new_closed()
    }
}

impl SignalGet for OpenedSignal {
    type Value = bool;

    fn get(&self) -> bool {
        self.0.get()
    }

    fn try_get(&self) -> Option<bool> {
        self.0.try_get()
    }
}

impl SignalWith for OpenedSignal {
    type Value = bool;

    fn with<U>(&self, f: impl FnOnce(&bool) -> U) -> U {
        self.0.with(f)
    }

    fn try_with<O>(&self, f: impl FnOnce(&bool) -> O) -> Option<O> {
        self.0.try_with(f)
    }
}

impl FnOnce<()> for OpenedSignal {
    type Output = bool;

    #[inline(always)]
    extern "rust-call" fn call_once(self, args: ()) -> Self::Output {
        FnOnce::call_once(self.0, args)
    }
}

impl FnMut<()> for OpenedSignal {
    #[inline(always)]
    extern "rust-call" fn call_mut(&mut self, args: ()) -> Self::Output {
        FnOnce::call_once(self.0, args)
    }
}

impl Fn<()> for OpenedSignal {
    #[inline(always)]
    extern "rust-call" fn call(&self, args: ()) -> Self::Output {
        FnOnce::call_once(self.0, args)
    }
}

Edit: typo

[gbj]

Cool! This looks like a good practice to me. No, you don't need to implement any of the traits you don't need, and this should work out of the box.

However, the following logic is wrong:

    pub fn toggle(&self) {
        // this should be .set(!self.0())
        // more efficiently, self.o.update(|n| *n = !*n);
        self.0.set(self.0()); 
    }

    pub fn open(&self) {
        self.0.set(true);
    }

    pub fn close(&self) {
        // should be self.0.set(false);
        self.0.set(true);
    }

[sambonbonne]

OMG I'm so sorry, I should have better check my code!

It works now, thanks!

Is there a reason why .update() is more efficient than .set()?

[gbj]

In this case it's a very small difference, but .set(value) is basically sugar for .update(|n| *n = value), so this is .update(|n| *n = self.0.get()), which requires invoking all the machinery for both the "get" and the "set" halves of the reactive system, instead of just the "set" side. You could think of it as doing in two separate reactive operations what could be done in one.

[sambonbonne]

It's perfectly clear, thanks for your answers and your time (and for Leptos 😃)!