Struct leptos::ReadSignal

pub struct ReadSignal<T>
where
    T: 'static,
{ /* private fields */ }

The getter for a reactive signal.

A signal is a piece of data that may change over time, and notifies other code when it has changed. This is the core primitive of Leptos’s reactive system.

ReadSignal is also Copy and 'static, so it can very easily moved into closures or copied structs.

Core Trait Implementations

• .get() (or calling the signal as a function) clones the current value of the signal. If you call it within an effect, it will cause that effect to subscribe to the signal, and to re-run whenever the value of the signal changes.
  • .get_untracked() clones the value of the signal without reactively tracking it.
• .with() allows you to reactively access the signal’s value without cloning by applying a callback function.
  • .with_untracked() allows you to access the signal’s value without reactively tracking it.
• .to_stream() converts the signal to an async stream of values.

Examples

let (count, set_count) = create_signal(0);

// ✅ calling the getter clones and returns the value
assert_eq!(count.get(), 0);

// ✅ calling the setter sets the value
set_count.set(1); // `set_count(1)` on nightly
assert_eq!(count.get(), 1);

// ❌ you could call the getter within the setter
// set_count.set(count.get() + 1);

// ✅ however it's more efficient to use .update() and mutate the value in place
set_count.update(|count: &mut i32| *count += 1);
assert_eq!(count.get(), 2);

// ✅ you can create "derived signals" with the same Fn() -> T interface
let double_count = move || count.get() * 2; // signals are `Copy` so you can `move` them anywhere
set_count.set(0);
assert_eq!(double_count(), 0);
set_count.set(1);
assert_eq!(double_count(), 2);

Trait Implementations

impl<T> Clone for ReadSignal<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for ReadSignal<T>

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

Formats the value using the given formatter.

impl<T> From<ReadSignal<Option<T>>> for MaybeProp<T>

fn from(value: ReadSignal<Option<T>>) -> MaybeProp<T>

Converts to this type from the input type.

impl<T> From<ReadSignal<T>> for MaybeProp<T>

where T: Clone,

fn from(value: ReadSignal<T>) -> MaybeProp<T>

Converts to this type from the input type.

impl<T> From<ReadSignal<T>> for MaybeSignal<T>

fn from(value: ReadSignal<T>) -> MaybeSignal<T>

Converts to this type from the input type.

impl<T> From<ReadSignal<T>> for Signal<T>

fn from(value: ReadSignal<T>) -> Signal<T>

Converts to this type from the input type.

impl<T> Hash for ReadSignal<T>

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

where T: IntoAttribute + Clone,

fn into_attribute(self) -> Attribute

Converts the object into an Attribute.

fn into_attribute_boxed(self: Box<ReadSignal<T>>) -> Attribute

Helper function for dealing with Box<dyn IntoAttribute>.

impl IntoClass for ReadSignal<bool>

fn into_class(self) -> Class

Converts the object into a Class.

fn into_class_boxed(self: Box<ReadSignal<bool>>) -> Class

Helper function for dealing with Box<dyn IntoClass>.

impl<T> IntoProperty for ReadSignal<T>

where T: Into<JsValue> + Clone,

fn into_property(self) -> Property

Converts the object into a Property.

fn into_property_boxed(self: Box<ReadSignal<T>>) -> Property

Helper function for dealing with Box<dyn IntoProperty>.

impl<T> IntoStyle for ReadSignal<T>

where T: IntoStyle + Clone,

fn into_style(self) -> Style

Converts the object into a Style.

fn into_style_boxed(self: Box<ReadSignal<T>>) -> Style

Helper function for dealing with Box<dyn IntoStyle>.

impl<T> IntoView for ReadSignal<T>

where T: IntoView + Clone,

fn into_view(self) -> View

Converts the value into View.

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

fn dispose(self)

Disposes of the signal. This:

impl<T> SignalGet for ReadSignal<T>

where T: Clone,

Examples

let (count, set_count) = create_signal(0);

assert_eq!(count.get(), 0);

// count() is shorthand for count.get() on `nightly`
// assert_eq!(count.get(), 0);

type Value = T

The value held by the signal.

fn get(&self) -> T

Clones and returns the current value of the signal, and subscribes the running effect to this signal.

fn try_get(&self) -> Option<T>

Clones and returns the signal value, returning Some if the signal is still alive, and None otherwise.

impl<T> SignalGetUntracked for ReadSignal<T>

where T: Clone,

type Value = T

The value held by the signal.

fn get_untracked(&self) -> T

Gets the signal’s value without creating a dependency on the current scope.

fn try_get_untracked(&self) -> Option<T>

Gets the signal’s value without creating a dependency on the current scope. Returns [Some(T)] if the signal is still valid, None otherwise.

impl<T> SignalStream<T> for ReadSignal<T>

where T: Clone,

fn to_stream(&self) -> Pin<Box<dyn Stream<Item = T>>>

Generates a Stream that emits the new value of the signal whenever it changes.

impl<T> SignalWith for ReadSignal<T>

Examples

let (name, set_name) = create_signal("Alice".to_string());

// ❌ unnecessarily clones the string
let first_char = move || name.get().chars().next().unwrap();
assert_eq!(first_char(), 'A');

// ✅ gets the first char without cloning the `String`
let first_char = move || name.with(|n| n.chars().next().unwrap());
assert_eq!(first_char(), 'A');
set_name.set("Bob".to_string());
assert_eq!(first_char(), 'B');

type Value = T

The value held by the signal.

fn with<O>(&self, f: impl FnOnce(&T) -> O) -> O

Applies a function to the current value of the signal, and subscribes the running effect to this signal.

fn try_with<O>(&self, f: impl FnOnce(&T) -> O) -> Option<O>

Applies a function to the current value of the signal, and subscribes the running effect to this signal. Returns Some if the signal is valid and the function ran, otherwise returns None.

fn track(&self)

Subscribes to this signal in the current reactive scope without doing anything with its value.

impl<T> SignalWithUntracked for ReadSignal<T>

type Value = T

The value held by the signal.

fn with_untracked<O>(&self, f: impl FnOnce(&T) -> O) -> O

Runs the provided closure with a reference to the current value without creating a dependency on the current scope.

fn try_with_untracked<O>(&self, f: impl FnOnce(&T) -> O) -> Option<O>

Runs the provided closure with a reference to the current value without creating a dependency on the current scope. Returns [Some(O)] if the signal is still valid, None otherwise.

impl<T> Copy for ReadSignal<T>

impl<T> Eq for ReadSignal<T>