Struct leptos_reactive::signal_prelude::RwSignal

pub struct RwSignal<T>where
    T: 'static,{ /* private fields */ }

A signal that combines the getter and setter into one value, rather than separating them into a ReadSignal and a WriteSignal. You may prefer this its style, or it may be easier to pass around in a context or as a function argument.

Core Trait Implementations

• .get() clones the current value of the signal. If you call it within an effect, it will cause that effect to subscribe to the signal, and to re-run whenever the value of the signal changes.
  • .get_untracked() clones the value of the signal without reactively tracking it.
• .with() allows you to reactively access the signal’s value without cloning by applying a callback function.
  • .with_untracked() allows you to access the signal’s value without reactively tracking it.
• .set() sets the signal’s value, and notifies all subscribers that the signal’s value has changed. to subscribe to the signal, and to re-run whenever the value of the signal changes.
  • .set_untracked() sets the signal’s value without notifying its subscribers.
• .update() mutates the signal’s value in place and notifies all subscribers that the signal’s value has changed.
  • .update_untracked() mutates the signal’s value in place without notifying its subscribers.
• .to_stream() converts the signal to an async stream of values.

let count = create_rw_signal(cx, 0);

// ✅ set the value
count.set(1);
assert_eq!(count(), 1);

// ❌ don't try to call the getter within the setter
// count.set(count.get() + 1);

// ✅ instead, use .update() to mutate the value in place
count.update(|count: &mut i32| *count += 1);
assert_eq!(count(), 2);

Implementations

impl<T> RwSignal<T>

pub fn read_only(&self) -> ReadSignal<T>

Returns a read-only handle to the signal.

Useful if you’re trying to give read access to another component but ensure that it can’t write to the signal and cause other parts of the DOM to update.

let count = create_rw_signal(cx, 0);
let read_count = count.read_only();
assert_eq!(count(), 0);
assert_eq!(read_count(), 0);
count.set(1);
assert_eq!(count(), 1);
assert_eq!(read_count(), 1);

pub fn write_only(&self) -> WriteSignal<T>

Returns a write-only handle to the signal.

Useful if you’re trying to give write access to another component, or split an RwSignal into a ReadSignal and a WriteSignal.

let count = create_rw_signal(cx, 0);
let set_count = count.write_only();
assert_eq!(count(), 0);
set_count(1);
assert_eq!(count(), 1);

pub fn split(&self) -> (ReadSignal<T>, WriteSignal<T>)

Splits an RwSignal into its getter and setter.

let count = create_rw_signal(cx, 0);
let (get_count, set_count) = count.split();
assert_eq!(count(), 0);
assert_eq!(get_count(), 0);
set_count(1);
assert_eq!(count(), 1);
assert_eq!(get_count(), 1);

Trait Implementations

impl<T> Clone for RwSignal<T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for RwSignal<T>where T: 'static + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> From<RwSignal<T>> for MaybeSignal<T>

fn from(value: RwSignal<T>) -> Self

Converts to this type from the input type.

impl<T> From<RwSignal<T>> for Signal<T>

fn from(value: RwSignal<T>) -> Self

Converts to this type from the input type.

impl<T> From<RwSignal<T>> for SignalSetter<T>

fn from(value: RwSignal<T>) -> Self

Converts to this type from the input type.

impl<T> Hash for RwSignal<T>where T: 'static + Hash,

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> PartialEq<RwSignal<T>> for RwSignal<T>where T: 'static + PartialEq,

fn eq(&self, other: &RwSignal<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> SignalDispose for RwSignal<T>

fn dispose(self)

Disposes of the signal. This:

impl<T: Clone> SignalGet<T> for RwSignal<T>

Examples

let count = create_rw_signal(cx, 0);

assert_eq!(count.get(), 0);

// count() is shorthand for count.get()
assert_eq!(count(), 0);

fn get(&self) -> Twhere T: Clone,

Clones and returns the current value of the signal, and subscribes the running effect to this signal.

fn try_get(&self) -> Option<T>

Clones and returns the signal value, returning Some if the signal is still alive, and None otherwise.

impl<T: Clone> SignalGetUntracked<T> for RwSignal<T>

fn get_untracked(&self) -> T

Gets the signal’s value without creating a dependency on the current scope.

fn try_get_untracked(&self) -> Option<T>

Gets the signal’s value without creating a dependency on the current scope. Returns [Some(T)] if the signal is still valid, None otherwise.

impl<T> SignalSet<T> for RwSignal<T>

Examples

let count = create_rw_signal(cx, 0);

assert_eq!(count(), 0);
count.set(1);
assert_eq!(count(), 1);

fn set(&self, value: T)

Sets the signal’s value and notifies subscribers.

fn try_set(&self, new_value: T) -> Option<T>

Sets the signal’s value and notifies subscribers. Returns None if the signal is still valid, [Some(T)] otherwise.

impl<T> SignalSetUntracked<T> for RwSignal<T>

fn set_untracked(&self, new_value: T)

Sets the signal’s value without notifying dependents.

fn try_set_untracked(&self, new_value: T) -> Option<T>

Attempts to set the signal if it’s still valid. Returns None if the signal was set, [Some(T)] otherwise.

impl<T: Clone> SignalStream<T> for RwSignal<T>

fn to_stream(&self, cx: Scope) -> Pin<Box<dyn Stream<Item = T>>>

Generates a Stream that emits the new value of the signal whenever it changes.

impl<T> SignalUpdate<T> for RwSignal<T>

Examples

let count = create_rw_signal(cx, 0);

// notifies subscribers
count.update(|n| *n = 1); // it's easier just to call set_count(1), though!
assert_eq!(count(), 1);

// you can include arbitrary logic in this update function
// also notifies subscribers, even though the value hasn't changed
count.update(|n| {
    if *n > 3 {
        *n += 1
    }
});
assert_eq!(count(), 1);

fn update(&self, f: impl FnOnce(&mut T))

Applies a function to the current value to mutate it in place and notifies subscribers that the signal has changed.

fn try_update<O>(&self, f: impl FnOnce(&mut T) -> O) -> Option<O>

Applies a function to the current value to mutate it in place and notifies subscribers that the signal has changed. Returns [Some(O)] if the signal is still valid, None otherwise.

fn update_returning<O>(&self, f: impl FnOnce(&mut T) -> O) -> Option<O>

👎Deprecated: Please use try_update instead. This method will be removed in a future version of this crate

Applies a function to the current value to mutate it in place and notifies subscribers that the signal has changed. Returns [Some(O)] if the signal is still valid, None otherwise.

impl<T> SignalUpdateUntracked<T> for RwSignal<T>

fn update_untracked(&self, f: impl FnOnce(&mut T))

Runs the provided closure with a mutable reference to the current value without notifying dependents.

fn update_returning_untracked<U>( &self, f: impl FnOnce(&mut T) -> U ) -> Option<U>

👎Deprecated: Please use try_update_untracked instead. This method will be removed in a future version of leptos

Runs the provided closure with a mutable reference to the current value without notifying dependents and returns the value the closure returned.

fn try_update_untracked<O>(&self, f: impl FnOnce(&mut T) -> O) -> Option<O>

Runs the provided closure with a mutable reference to the current value without notifying dependents and returns the value the closure returned.

impl<T> SignalWith<T> for RwSignal<T>

Examples

let name = create_rw_signal(cx, "Alice".to_string());

// ❌ unnecessarily clones the string
let first_char = move || name().chars().next().unwrap();
assert_eq!(first_char(), 'A');

// ✅ gets the first char without cloning the `String`
let first_char = move || name.with(|n| n.chars().next().unwrap());
assert_eq!(first_char(), 'A');
name.set("Bob".to_string());
assert_eq!(first_char(), 'B');

fn with<O>(&self, f: impl FnOnce(&T) -> O) -> O

Applies a function to the current value of the signal, and subscribes the running effect to this signal.

fn try_with<O>(&self, f: impl FnOnce(&T) -> O) -> Option<O>

Applies a function to the current value of the signal, and subscribes the running effect to this signal. Returns Some if the signal is valid and the function ran, otherwise returns None.

fn track(&self)

Subscribes to this signal in the current reactive scope without doing anything with its value.

impl<T> SignalWithUntracked<T> for RwSignal<T>

fn with_untracked<O>(&self, f: impl FnOnce(&T) -> O) -> O

Runs the provided closure with a reference to the current value without creating a dependency on the current scope.

fn try_with_untracked<O>(&self, f: impl FnOnce(&T) -> O) -> Option<O>

Runs the provided closure with a reference to the current value without creating a dependency on the current scope. Returns [Some(O)] if the signal is still valid, None otherwise.

impl<T> Copy for RwSignal<T>

impl<T> Eq for RwSignal<T>where T: 'static + Eq,

impl<T> StructuralEq for RwSignal<T>where T: 'static,

impl<T> StructuralPartialEq for RwSignal<T>where T: 'static,