Struct sycamore::reactive::ReadSignal

pub struct ReadSignal<T> { /* private fields */ }

A read-only Signal.

Unlike Rust’s shared-reference (&T), the underlying data is not immutable. The data can be updated with the corresponding Signal (which has mutable access) and will show up in the ReadSignal as well.

A ReadSignal can be simply obtained by dereferencing a Signal. In fact, every Signal is a ReadSignal with additional write abilities!

Example

let signal: &Signal<i32> = create_signal(cx, 123);
let read_signal: &ReadSignal<i32> = &*signal;

Implementations

impl<T> ReadSignal<T>

pub fn get(&self) -> Rc<T>

Get the current value of the state. When called inside a reactive scope, calling this will add itself to the scope’s dependencies.

Example

let state = create_signal(cx, 0);
assert_eq!(*state.get(), 0);

state.set(1);
assert_eq!(*state.get(), 1);

pub fn get_untracked(&self) -> Rc<T>

Get the current value of the state, without tracking this as a dependency if inside a reactive context.

Example

let state = create_signal(cx, 1);
let double = create_memo(cx, || *state.get_untracked() * 2);
assert_eq!(*double.get(), 2);

state.set(2);
// double value should still be old value because state was untracked
assert_eq!(*double.get(), 2);

pub fn map<'a, U>(
    &'a self,
    cx: BoundedScope<'a, 'a>,
    f: impl FnMut(&T) -> U + 'a
) -> &'a ReadSignal<U>

Creates a mapped ReadSignal. This is equivalent to using create_memo.

Example

let state = create_signal(cx, 1);
let double = state.map(cx, |&x| x * 2);
assert_eq!(*double.get(), 2);

state.set(2);
assert_eq!(*double.get(), 4);

pub fn track(&self)

When called inside a reactive scope, calling this will add itself to the scope’s dependencies.

To both track and get the value of the signal, use ReadSignal::get instead.

Trait Implementations

impl<'a, T> AnyReadSignal<'a> for ReadSignal<T>

fn track(&self)

Call the ReadSignal::track method.

impl<T> Debug for ReadSignal<T>where
    T: Debug,

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

Formats the value using the given formatter.

impl<T> Display for ReadSignal<T>where
    T: Display,

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

Formats the value using the given formatter.

impl<T> Hash for ReadSignal<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,

Feeds a slice of this type into the given Hasher.

impl<T> PartialEq<ReadSignal<T>> for ReadSignal<T>where
    T: PartialEq<T>,

fn eq(&self, other: &ReadSignal<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> Eq for ReadSignal<T>where
    T: Eq,