Struct SignalSetter 

pub struct SignalSetter<T, S = SyncStorage>
where
    T: 'static,
{ /* private fields */ }

A wrapper for any kind of settable reactive signal: a WriteSignal, RwSignal, or closure that receives a value and sets a signal depending on it.

This allows you to create APIs that take any kind of SignalSetter<T> as an argument, rather than adding a generic F: Fn(T). Values can be set with the same function call or set(), API as other signals.

Core Trait Implementations

• .set() (or calling the setter as a function) 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.

Examples

let (count, set_count) = signal(2);
let set_double_input = SignalSetter::map(move |n| set_count.set(n * 2));

// this function takes any kind of signal setter
fn set_to_4(setter: &SignalSetter<i32>) {
    // ✅ calling the signal sets the value
    //    can be `setter(4)` on nightly
    setter.set(4);
}

set_to_4(&set_count.into());
assert_eq!(count.get(), 4);
set_to_4(&set_double_input);
assert_eq!(count.get(), 8);

Implementations

impl<T, S> SignalSetter<T, S>

where S: Storage<Box<dyn Fn(T) + Sync + Send>>,

pub fn map( mapped_setter: impl Fn(T) + Send + Sync + 'static, ) -> SignalSetter<T, S>

Wraps a signal-setting closure, i.e., any computation that sets one or more reactive signals.

Trait Implementations

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

fn clone(&self) -> SignalSetter<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 SignalSetter<T, S>

where T: Debug + 'static, S: Debug,

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

Formats the value using the given formatter.

impl<T, S> Default for SignalSetter<T, S>

where T: Default + 'static,

fn default() -> SignalSetter<T, S>

Returns the “default value” for a type.

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

where T: Send + Sync + 'static, S: Storage<ArcRwSignal<T>> + Storage<ArcWriteSignal<T>>,

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

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> PartialEq for SignalSetter<T, S>

where T: PartialEq + 'static, S: PartialEq,

fn eq(&self, other: &SignalSetter<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> Set for SignalSetter<T, S>

where T: 'static, S: Storage<ArcWriteSignal<T>> + Storage<Box<dyn Fn(T) + Sync + Send>>,

type Value = T

The type of the value contained in the signal.

fn set(&self, new_value: <SignalSetter<T, S> as Set>::Value)

Updates the value by replacing it, and notifies subscribers that it has changed.

fn try_set( &self, new_value: <SignalSetter<T, S> as Set>::Value, ) -> Option<<SignalSetter<T, S> as Set>::Value>

Updates the value by replacing it, and notifies subscribers that it has changed.

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

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

where T: Eq + 'static, S: Eq,

impl<T, S> StructuralPartialEq for SignalSetter<T, S>

where T: 'static,