Trait Readable

pub trait Readable {
    type Target: 'static + ?Sized;
    type Storage: AnyStorage;

    // Required methods
    fn try_read_unchecked(
        &self,
    ) -> Result<<Self::Storage as AnyStorage>::Ref<'static, Self::Target>, BorrowError>;
    fn try_peek_unchecked(
        &self,
    ) -> Result<<Self::Storage as AnyStorage>::Ref<'static, Self::Target>, BorrowError>;

    // Provided methods
    fn map<O>(
        self,
        f: impl Fn(&Self::Target) -> &O + 'static,
    ) -> MappedSignal<O, Self::Storage>
       where Self: Sized + Clone + 'static { ... }
    fn read(&self) -> <Self::Storage as AnyStorage>::Ref<'_, Self::Target> { ... }
    fn try_read(
        &self,
    ) -> Result<<Self::Storage as AnyStorage>::Ref<'_, Self::Target>, BorrowError> { ... }
    fn read_unchecked(
        &self,
    ) -> <Self::Storage as AnyStorage>::Ref<'static, Self::Target> { ... }
    fn peek(&self) -> <Self::Storage as AnyStorage>::Ref<'_, Self::Target> { ... }
    fn try_peek(
        &self,
    ) -> Result<<Self::Storage as AnyStorage>::Ref<'_, Self::Target>, BorrowError> { ... }
    fn peek_unchecked(
        &self,
    ) -> <Self::Storage as AnyStorage>::Ref<'static, Self::Target> { ... }
    fn cloned(&self) -> Self::Target
       where Self::Target: Clone { ... }
    fn with<O>(&self, f: impl FnOnce(&Self::Target) -> O) -> O { ... }
    fn with_peek<O>(&self, f: impl FnOnce(&Self::Target) -> O) -> O { ... }
    fn index<I>(
        &self,
        index: I,
    ) -> <Self::Storage as AnyStorage>::Ref<'_, <Self::Target as Index<I>>::Output>
       where Self::Target: Index<I> { ... }
}

A trait for states that can be read from like crate::Signal, crate::GlobalSignal, or crate::ReadOnlySignal. You may choose to accept this trait as a parameter instead of the concrete type to allow for more flexibility in your API. For example, instead of creating two functions, one that accepts a crate::Signal and one that accepts a crate::GlobalSignal, you can create one function that accepts a Readable type.

Example

fn double(something_readable: &impl Readable<Target = i32>) -> i32 {
    something_readable.cloned() * 2
}

static COUNT: GlobalSignal<i32> = Signal::global(|| 0);

fn MyComponent(count: Signal<i32>) -> Element {
    // Since we defined the function in terms of the readable trait, we can use it with any readable type (Signal, GlobalSignal, ReadOnlySignal, etc)
    let doubled = use_memo(move || double(&count));
    let global_count_doubled = use_memo(|| double(&COUNT));
    rsx! {
        div {
            "Count local: {count}"
            "Doubled local: {doubled}"
            "Count global: {COUNT}"
            "Doubled global: {global_count_doubled}"
        }
    }
}

Required Associated Types

type Target: 'static + ?Sized

The target type of the reference.

type Storage: AnyStorage

The type of the storage this readable uses.

Required Methods

fn try_read_unchecked( &self, ) -> Result<<Self::Storage as AnyStorage>::Ref<'static, Self::Target>, BorrowError>

Try to get a reference to the value without checking the lifetime. This will subscribe the current scope to the signal.

NOTE: This method is completely safe because borrow checking is done at runtime.

fn try_peek_unchecked( &self, ) -> Result<<Self::Storage as AnyStorage>::Ref<'static, Self::Target>, BorrowError>

Try to peek the current value of the signal without subscribing to updates. If the value has been dropped, this will return an error.

NOTE: This method is completely safe because borrow checking is done at runtime.

Provided Methods

fn map<O>( self, f: impl Fn(&Self::Target) -> &O + 'static, ) -> MappedSignal<O, Self::Storage>

where Self: Sized + Clone + 'static,

Map the readable type to a new type. This lets you provide a view into a readable type without needing to clone the inner value.

Anything that subscribes to the readable value will be rerun whenever the original value changes, even if the view does not change. If you want to memorize the view, you can use a crate::Memo instead.

Example

fn List(list: Signal<Vec<i32>>) -> Element {
    rsx! {
        for index in 0..list.len() {
            // We can use the `map` method to provide a view into the single item in the list that the child component will render
            Item { item: list.map(move |v| &v[index]) }
        }
    }
}

// The child component doesn't need to know that the mapped value is coming from a list
#[component]
fn Item(item: MappedSignal<i32>) -> Element {
    rsx! {
        div { "Item: {item}" }
    }
}

fn read(&self) -> <Self::Storage as AnyStorage>::Ref<'_, Self::Target>

Get the current value of the state. If this is a signal, this will subscribe the current scope to the signal. If the value has been dropped, this will panic. Calling this on a Signal is the same as using the signal() syntax to read and subscribe to its value

fn try_read( &self, ) -> Result<<Self::Storage as AnyStorage>::Ref<'_, Self::Target>, BorrowError>

Try to get the current value of the state. If this is a signal, this will subscribe the current scope to the signal.

fn read_unchecked( &self, ) -> <Self::Storage as AnyStorage>::Ref<'static, Self::Target>

Get a reference to the value without checking the lifetime. This will subscribe the current scope to the signal.

NOTE: This method is completely safe because borrow checking is done at runtime.

fn peek(&self) -> <Self::Storage as AnyStorage>::Ref<'_, Self::Target>

Get the current value of the state without subscribing to updates. If the value has been dropped, this will panic.

Example

fn MyComponent(mut count: Signal<i32>) -> Element {
    let mut event_source = use_signal(|| None);
    let doubled = use_memo(move || {
        // We want to log the value of the event_source, but we don't need to rerun the doubled value if the event_source changes (because the value of doubled doesn't depend on the event_source)
        // We can read the value with peek without subscribing to updates
        let click_count = count.peek();
        tracing::info!("Click count: {click_count:?}");
        count() * 2
    });
    rsx! {
        div { "Count: {count}" }
        div { "Doubled: {doubled}" }
        button {
            onclick: move |_| {
                event_source.set(Some("Click me button"));
            },
            "Click me"
        }
        button {
            onclick: move |_| {
                event_source.set(Some("Double me button"));
                count += 1;
            },
            "Double me"
        }
    }
}

fn try_peek( &self, ) -> Result<<Self::Storage as AnyStorage>::Ref<'_, Self::Target>, BorrowError>

Try to peek the current value of the signal without subscribing to updates. If the value has been dropped, this will return an error.

fn peek_unchecked( &self, ) -> <Self::Storage as AnyStorage>::Ref<'static, Self::Target>

Get the current value of the signal without checking the lifetime. Unlike read, this will not subscribe the current scope to the signal which can cause parts of your UI to not update.

If the signal has been dropped, this will panic.

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

where Self::Target: Clone,

Clone the inner value and return it. If the value has been dropped, this will panic.

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

Run a function with a reference to the value. If the value has been dropped, this will panic.

fn with_peek<O>(&self, f: impl FnOnce(&Self::Target) -> O) -> O

Run a function with a reference to the value. If the value has been dropped, this will panic.

fn index<I>( &self, index: I, ) -> <Self::Storage as AnyStorage>::Ref<'_, <Self::Target as Index<I>>::Output>

where Self::Target: Index<I>,

Index into the inner value and return a reference to the result. If the value has been dropped or the index is invalid, this will panic.

Object Safety

This trait is not object safe.

Implementors

impl Readable for UseFuture

type Target = UseFutureState

type Storage = UnsyncStorage

impl<O, S> Readable for MappedSignal<O, S>

where S: AnyStorage, O: ?Sized,

type Target = O

type Storage = S

impl<T> Readable for Memo<T>

where T: PartialEq,

type Target = T

type Storage = UnsyncStorage

impl<T> Readable for Resource<T>

type Target = Option<T>

type Storage = UnsyncStorage

impl<T, R> Readable for Global<T, R>

where T: Clone + 'static + Readable<Target = R> + InitializeFromFunction<R>, R: 'static,

type Target = R

type Storage = <T as Readable>::Storage

impl<T, S> Readable for CopyValue<T, S>

where T: 'static, S: Storage<T>,

type Target = T

type Storage = S

impl<T, S> Readable for ReadOnlySignal<T, S>

where S: Storage<SignalData<T>>,

type Target = T

type Storage = S

impl<T, S> Readable for Signal<T, S>

where S: Storage<SignalData<T>>,

type Target = T

type Storage = S