Struct Signal

pub struct Signal<T>(/* private fields */)
where
    T: 'static;

A reactive value that can be read and written to.

This is the writable version of ReadSignal.

See create_signal for more information.

Implementations

impl<T> Signal<T>

pub fn set_silent(self, new: T)

Silently set a new value for the signal. This will not trigger any updates in dependent signals. As such, this is generally not recommended as it can easily lead to state inconsistencies.

Example

let state = create_signal(0);
let doubled = create_memo(move || state.get() * 2);
assert_eq!(doubled.get(), 0);
state.set_silent(1);
assert_eq!(doubled.get(), 0); // We now have inconsistent state!

pub fn set(self, new: T)

Set a new value for the signal and automatically update any dependents.

Example

let state = create_signal(0);
let doubled = create_memo(move || state.get() * 2);
assert_eq!(doubled.get(), 0);
state.set(1);
assert_eq!(doubled.get(), 2);

pub fn replace_silent(self, new: T) -> T

Silently set a new value for the signal and return the previous value.

This is the silent version of Signal::replace.

pub fn replace(self, new: T) -> T

Set a new value for the signal and return the previous value.

Example

let state = create_signal(123);
let prev = state.replace(456);
assert_eq!(state.get(), 456);
assert_eq!(prev, 123);

pub fn take_silent(self) -> T

where T: Default,

Silently gets the value of the signal and sets the new value to the default value.

This is the silent version of Signal::take.

pub fn take(self) -> T

where T: Default,

Gets the value of the signal and sets the new value to the default value.

Example

let state = create_signal(Some(123));
let prev = state.take();
assert_eq!(state.get(), None);
assert_eq!(prev, Some(123));

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

Update the value of the signal silently. This will not trigger any updates in dependent signals. As such, this is generally not recommended as it can easily lead to state inconsistencies.

This is the silent version of Signal::update.

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

Update the value of the signal and automatically update any dependents.

Using this has the advantage of not needing to clone the value when updating it, especially with types that do not implement Copy where cloning can be expensive, or for types that do not implement Clone at all.

Example

let state = create_signal("Hello".to_string());
state.update(|val| val.push_str(" Sycamore!"));
assert_eq!(state.get_clone(), "Hello Sycamore!");

pub fn set_fn_silent(self, f: impl FnOnce(&T) -> T)

Use a function to produce a new value and sets the value silently.

This is the silent version of Signal::set_fn.

pub fn set_fn(self, f: impl FnOnce(&T) -> T)

Use a function to produce a new value and sets the value.

Example

let state = create_signal(123);
state.set_fn(|val| *val + 1);
assert_eq!(state.get(), 124);

pub fn split(self) -> (ReadSignal<T>, impl Fn(T))

Split the signal into a reader/writter pair.

Example

let (read_signal, mut write_signal) = create_signal(0).split();
assert_eq!(read_signal.get(), 0);
write_signal(1);
assert_eq!(read_signal.get(), 1);

Trait Implementations

impl<T, Rhs> AddAssign<Rhs> for Signal<T>

where T: AddAssign<Rhs>,

fn add_assign(&mut self, rhs: Rhs)

Performs the += operation.

impl<T> Clone for Signal<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Signal<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Signal<T>

where T: Default,

fn default() -> Signal<T>

Returns the “default value” for a type.

impl<T> Deref for Signal<T>

type Target = ReadSignal<T>

The resulting type after dereferencing.

fn deref(&self) -> &<Signal<T> as Deref>::Target

Dereferences the value.

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

where T: Deserialize<'de>,

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Display for Signal<T>

where T: Display,

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

Formats the value using the given formatter.

impl<T, Rhs> DivAssign<Rhs> for Signal<T>

where T: DivAssign<Rhs>,

fn div_assign(&mut self, rhs: Rhs)

Performs the /= operation.

impl<T> FnOnce() for Signal<T>

where T: Copy,

type Output = T

The returned type after the call operator is used.

extern "rust-call" fn call_once( self, _args: (), ) -> <Signal<T> as FnOnce()>::Output

🔬This is a nightly-only experimental API. (fn_traits)

Performs the call operation.

impl<T> FnOnce(T) for Signal<T>

where T: Copy,

type Output = T

The returned type after the call operator is used.

extern "rust-call" fn call_once( self, _: (T,), ) -> <Signal<T> as FnOnce(T)>::Output

🔬This is a nightly-only experimental API. (fn_traits)

Performs the call operation.

impl<T, U> From<Signal<U>> for MaybeDyn<T>

where T: Into<MaybeDyn<T>>, U: Into<MaybeDyn<T>> + Clone,

fn from(val: Signal<U>) -> MaybeDyn<T>

Converts to this type from the input type.

impl<T> Hash for Signal<T>

where T: Hash,

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, Rhs> MulAssign<Rhs> for Signal<T>

where T: MulAssign<Rhs>,

fn mul_assign(&mut self, rhs: Rhs)

Performs the *= operation.

impl<T> Ord for Signal<T>

where T: Ord,

fn cmp(&self, other: &Signal<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T> PartialEq for Signal<T>

where T: PartialEq,

fn eq(&self, other: &Signal<T>) -> 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> PartialOrd for Signal<T>

where T: PartialOrd,

fn partial_cmp(&self, other: &Signal<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, Rhs> RemAssign<Rhs> for Signal<T>

where T: RemAssign<Rhs>,

fn rem_assign(&mut self, rhs: Rhs)

Performs the %= operation.

impl<T> Serialize for Signal<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, Rhs> SubAssign<Rhs> for Signal<T>

where T: SubAssign<Rhs>,

fn sub_assign(&mut self, rhs: Rhs)

Performs the -= operation.

impl<T> Trackable for Signal<T>

fn _track(&self)

Track the data reactively.

impl<T> Copy for Signal<T>

impl<T> Eq for Signal<T>

where T: Eq,