Struct sycamore_reactive::ReadSignal

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

A read-only 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: Scope<'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> Debug for ReadSignal<T>

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

impl<T: Hash> Hash for ReadSignal<T>

fn hash<H: Hasher>(&self, state: &mut H)

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> PartialEq<ReadSignal<T>> for ReadSignal<T>

fn eq(&self, other: &Self) -> 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 !=.

impl<T: Eq> Eq for ReadSignal<T>