Struct leptos::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(0);

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

// ❌ you can call the getter within the setter
// count.set(count.get() + 1);

// ✅ however, it's more efficient to use .update() and mutate the value in place
count.update(|count: &mut i32| *count += 1);
assert_eq!(count.get(), 2);

Implementations

impl<T> RwSignal<T>

pub fn new(value: T) -> RwSignal<T>

Creates a reactive signal with the getter and setter unified in one value. You may prefer this style, or it may be easier to pass around in a context or as a function argument.

This is identical to create_rw_signal.

let count = RwSignal::new(0);

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

// ❌ you can call the getter within the setter
// count.set(count.get() + 1);

// ✅ however, it's more efficient to use .update() and mutate the value in place
count.update(|count: &mut i32| *count += 1);
assert_eq!(count.get(), 2);

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(0);
let read_count = count.read_only();
assert_eq!(count.get(), 0);
assert_eq!(read_count.get(), 0);
count.set(1);
assert_eq!(count.get(), 1);
assert_eq!(read_count.get(), 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(0);
let set_count = count.write_only();
assert_eq!(count.get(), 0);
set_count.set(1);
assert_eq!(count.get(), 1);

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

Splits an RwSignal into its getter and setter.

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

Trait Implementations

impl<T> Clone for RwSignal<T>

fn clone(&self) -> RwSignal<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for RwSignal<T>

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

Formats the value using the given formatter.

impl<T> Default for RwSignal<T>

where T: Default,

fn default() -> RwSignal<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for RwSignal<T>

where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D ) -> Result<RwSignal<T>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> From<RwSignal<Option<T>>> for MaybeProp<T>

fn from(value: RwSignal<Option<T>>) -> MaybeProp<T>

Converts to this type from the input type.

impl<T> From<RwSignal<T>> for MaybeProp<T>

where T: Clone,

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<T> Hash for RwSignal<T>

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

where H: Hasher,

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> IntoAttribute for RwSignal<T>

where T: IntoAttribute + Clone,

fn into_attribute(self) -> Attribute

Converts the object into an Attribute.

fn into_attribute_boxed(self: Box<RwSignal<T>>) -> Attribute

Helper function for dealing with Box<dyn IntoAttribute>.

impl IntoClass for RwSignal<bool>

fn into_class(self) -> Class

Converts the object into a Class.

fn into_class_boxed(self: Box<RwSignal<bool>>) -> Class

Helper function for dealing with Box<dyn IntoClass>.

impl<T> IntoProperty for RwSignal<T>

where T: Into<JsValue> + Clone,

fn into_property(self) -> Property

Converts the object into a Property.

fn into_property_boxed(self: Box<RwSignal<T>>) -> Property

Helper function for dealing with Box<dyn IntoProperty>.

impl<T> IntoStyle for RwSignal<T>

where T: IntoStyle + Clone,

fn into_style(self) -> Style

Converts the object into a Style.

fn into_style_boxed(self: Box<RwSignal<T>>) -> Style

Helper function for dealing with Box<dyn IntoStyle>.

impl<T> IntoView for RwSignal<T>

where T: IntoView + Clone,

fn into_view(self) -> View

Converts the value into View.

impl<T> PartialEq for RwSignal<T>

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> Serialize for RwSignal<T>

where T: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> SignalDispose for RwSignal<T>

fn dispose(self)

Disposes of the signal. This:

impl<T> SignalGet for RwSignal<T>

where T: Clone,

Examples

let count = create_rw_signal(0);

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

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

type Value = T

The value held by the signal.

fn get(&self) -> T

where 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> SignalGetUntracked for RwSignal<T>

where T: Clone,

type Value = T

The value held by the signal.

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 for RwSignal<T>

Examples

let count = create_rw_signal(0);

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

type Value = T

The value held by the signal.

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> SignalStream<T> for RwSignal<T>

where T: Clone,

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

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

impl<T> SignalUpdate for RwSignal<T>

Examples

let count = create_rw_signal(0);

// notifies subscribers
count.update(|n| *n = 1); // it's easier just to call set_count.set(1), though!
assert_eq!(count.get(), 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.get(), 1);

type Value = T

The value held by the signal.

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.

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 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 for RwSignal<T>

Examples

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

// ❌ unnecessarily clones the string
let first_char = move || name.get().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');

type Value = T

The value held by the signal.

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 for RwSignal<T>

type Value = T

The value held by the signal.

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>