Struct leptos_reactive::signal_prelude::prelude::SignalSetter

pub struct SignalSetter<T>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) = create_signal(cx, 2);
let set_double_input = SignalSetter::map(cx, move |n| set_count(n * 2));

// this function takes any kind of signal setter
fn set_to_4(setter: &SignalSetter<i32>) {
    // ✅ calling the signal sets the value
    //    it is a shorthand for arg.set()
    setter(4);
}

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

Implementations

impl<T> SignalSetter<T>where T: 'static,

pub fn map(cx: Scope, mapped_setter: impl Fn(T) + 'static) -> Self

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

let (count, set_count) = create_signal(cx, 2);
let set_double_count = SignalSetter::map(cx, move |n| set_count(n * 2));

// this function takes any kind of signal setter
fn set_to_4(setter: &SignalSetter<i32>) {
    // ✅ calling the signal sets the value
    //    it is a shorthand for arg.set()
    setter(4)
}

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

pub fn set(&self, value: T)

Calls the setter function with the given value.

let (count, set_count) = create_signal(cx, 2);
let set_double_count = SignalSetter::map(cx, move |n| set_count(n * 2));

// this function takes any kind of signal setter
fn set_to_4(setter: &SignalSetter<i32>) {
  // ✅ calling the signal sets the value
  //    it is a shorthand for arg.set()
  setter(4);
}

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

Trait Implementations

impl<T> Clone for SignalSetter<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 SignalSetter<T>where T: 'static + Debug,

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

Formats the value using the given formatter.

impl<T: Default + 'static> Default for SignalSetter<T>

fn default() -> Self

Returns the “default value” for a 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> From<WriteSignal<T>> for SignalSetter<T>

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

Converts to this type from the input type.

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

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

fn set(&self, new_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> Copy for SignalSetter<T>

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

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

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