Struct sycamore_reactive::RcSignal

pub struct RcSignal<T>(_);

A signal that is not bound to a Scope.

Sometimes, it is useful to have a signal that can escape the enclosing reactive scope. However, this cannot be achieved simply with Scope::create_signal because the resulting Signal is tied to the Scope by it’s lifetime. The Signal can only live as long as the Scope.

With RcSignal on the other hand, the lifetime is not tied to a Scope. Memory is managed using a reference-counted smart pointer (Rc). What this means is that RcSignal cannot implement the Copy trait and therefore needs to be manually cloned into all closures where it is used.

In general, Scope::create_signal should be preferred, both for performance and ergonomics.

Usage

To create a RcSignal, use the create_rc_signal function.

Example

let mut outer = None;

create_scope_immediate(|ctx| {
// Even though the RcSignal is created inside a reactive scope, it can escape out of it.
let rc_state = create_rc_signal(0);
let rc_state_cloned = rc_state.clone();
let double = ctx.create_memo(move || *rc_state_cloned.get() * 2);
assert_eq!(*double.get(), 0);

rc_state.set(1);
assert_eq!(*double.get(), 2);

// This isn't possible with simply ctx.create_signal()
outer = Some(rc_state);
});

Methods from Deref<Target = Signal<T>>

pub fn set(&self, value: T)

Set the current value of the state.

This will notify and update any effects and memos that depend on this value.

Example

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

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

pub fn set_silent(&self, value: T)

Set the current value of the state without triggering subscribers.

Make sure you know what you are doing because this can make state inconsistent.

pub fn split(&self) -> (impl Fn() -> Rc<T> + Copy + '_, impl Fn(T) + Copy + '_)

Split a signal into getter and setter handles.

Example

let (state, set_state) = ctx.create_signal(0).split();
assert_eq!(*state(), 0);

set_state(1);
assert_eq!(*state(), 1);

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

Take the current value out and replace it with the default value.

This will notify and update any effects and memos that depend on this value.

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

Take the current value out and replace it with the default value without triggering subscribers.

Make sure you know what you are doing because this can make state inconsistent.

Methods from Deref<Target = 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 = ctx.create_signal(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 = ctx.create_signal(1);
let double = ctx.create_memo(|| *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,
    ctx: ScopeRef<'a>,
    f: impl FnMut(&T) -> U + 'a
) -> &'a ReadSignal<U>

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

Example

let state = ctx.create_signal(1);
let double = state.map(&ctx, |&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 RcSignal<T>

fn track(&self)

Call the ReadSignal::track method.

impl<T> Clone for RcSignal<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> Debug for RcSignal<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for RcSignal<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Deref for RcSignal<T>

type Target = Signal<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Display> Display for RcSignal<T>

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

Formats the value using the given formatter.

impl<T: Hash> Hash for RcSignal<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<RcSignal<T>> for RcSignal<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 RcSignal<T>