Struct WriteSignal

pub struct WriteSignal<T, S = SyncStorage> { /* private fields */ }

An arena-allocated setter for a reactive signal.

A signal is a piece of data that may change over time, and notifies other code when it has changed.

This is an arena-allocated signal, which is Copy and is disposed when its reactive Owner cleans up. For a reference-counted signal that lives as long as a reference to it is alive, see ArcWriteSignal.

Core Trait Implementations

• .set() sets the signal to a new value.
• .update() updates the value of the signal by applying a closure that takes a mutable reference.
• .write() returns a guard through which the signal can be mutated, and which notifies subscribers when it is dropped.

Each of these has a related _untracked() method, which updates the signal without notifying subscribers. Untracked updates are not desirable in most cases, as they cause “tearing” between the signal’s value and its observed value. If you want a non-reactive container, used ArenaItem instead.

Examples

let (count, set_count) = signal(0);

// ✅ calling the setter sets the value
//    `set_count(1)` on nightly
set_count.set(1);
assert_eq!(count.get(), 1);

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

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

// ✅ `.write()` returns a guard that implements `DerefMut` and will notify when dropped
*set_count.write() += 1;
assert_eq!(count.get(), 3);

Trait Implementations

impl<T, S> Clone for WriteSignal<T, S>

fn clone(&self) -> WriteSignal<T, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, S> Debug for WriteSignal<T, S>

where S: Debug,

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

Formats the value using the given formatter.

impl<T, S> DefinedAt for WriteSignal<T, S>

fn defined_at(&self) -> Option<&'static Location<'static>>

Returns the location at which the signal was defined. This is usually simply None in release mode.

impl<T, S> Dispose for WriteSignal<T, S>

fn dispose(self)

Disposes of the signal. This:

impl<T> From<ArcWriteSignal<T>> for WriteSignal<T>

where T: Send + Sync + 'static,

fn from(value: ArcWriteSignal<T>) -> WriteSignal<T>

Converts to this type from the input type.

impl<T, S> From<WriteSignal<T, S>> for SignalSetter<T, S>

fn from(value: WriteSignal<T, S>) -> SignalSetter<T, S>

Converts to this type from the input type.

impl<T, S> From<WriteSignal<T, S>> for WriteModel<T, S>

where S: Storage<T>,

fn from(write_signal: WriteSignal<T, S>) -> WriteModel<T, S>

Converts to this type from the input type.

impl<T> FromLocal<ArcWriteSignal<T>> for WriteSignal<T, LocalStorage>

where T: 'static,

fn from_local(value: ArcWriteSignal<T>) -> WriteSignal<T, LocalStorage>

Converts between the types.

impl<T, S> Hash for WriteSignal<T, S>

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, S> IntoInner for WriteSignal<T, S>

where S: Storage<ArcWriteSignal<T>>,

type Value = T

The type of the value contained in the signal.

fn into_inner(self) -> Option<<WriteSignal<T, S> as IntoInner>::Value>

Returns the inner value if this is the only reference to to the signal. Otherwise, returns None and drops this reference.

impl<T, S> IsDisposed for WriteSignal<T, S>

fn is_disposed(&self) -> bool

If true, the signal cannot be accessed without a panic.

impl<T, S> Notify for WriteSignal<T, S>

where T: 'static, S: Storage<ArcWriteSignal<T>>,

fn notify(&self)

Notifies subscribers of a change in this signal.

impl<T, S> PartialEq for WriteSignal<T, S>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T, S> Write for WriteSignal<T, S>

where T: 'static, S: Storage<ArcWriteSignal<T>>,

type Value = T

The type of the signal’s value.

fn try_write(&self) -> Option<impl UntrackableGuard>

Returns the guard, or None if the signal has already been disposed.

fn try_write_untracked(&self) -> Option<impl DerefMut>

or None if the signal has already been disposed.

fn write(&self) -> impl UntrackableGuard

Returns the guard.

fn write_untracked(&self) -> impl DerefMut

Returns a guard that will not notify subscribers when dropped.

impl<T, S> Copy for WriteSignal<T, S>

impl<T, S> Eq for WriteSignal<T, S>