Struct Readable 

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

A type-erased readable state that only exposes the value type T.

This abstraction allows components to accept read-only state from any source without knowing whether it comes from local state (use_state) or global state (Freya Radio). Unlike Writable, this only provides read access to the underlying value.

Sources

Readable can be created from:

• State<T> via From or IntoReadable
• RadioSlice via IntoReadable
• Writable<T> via From<Writable<T>>

Example

#[derive(PartialEq)]
struct Counter {
    count: Readable<i32>,
}

impl Component for Counter {
    fn render(&self) -> impl IntoElement {
        // The component only reads the value, never modifies it
        format!("Count: {}", self.count.read())
    }
}

fn app() -> impl IntoElement {
    let local = use_state(|| 0);
    let radio = use_radio(AppChannel::Count);
    let slice = radio.slice_current(|s| &s.count);

    rect()
        // Pass local state as Readable
        .child(Counter { count: local.into_readable() })
        // Pass global radio slice as Readable
        .child(Counter { count: slice.into_readable() })
}

Implementations

impl<T> Readable<T>

where T: 'static,

pub fn from_state(state: State<T>) -> Readable<T>

Create from local State<T>.

pub fn from_value(value: T) -> Readable<T>

Create from an owned value.

pub fn new( read_fn: Box<dyn Fn() -> ReadableRef<T>>, peek_fn: Box<dyn Fn() -> ReadableRef<T>>, ) -> Readable<T>

Create a new Readable with custom read and peek functions.

pub fn read(&self) -> ReadableRef<T>

Read the value and subscribe to changes.

pub fn peek(&self) -> ReadableRef<T>

Read the value without subscribing.

Trait Implementations

impl<T> Clone for Readable<T>

where T: 'static,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> From<State<T>> for Readable<T>

fn from(value: State<T>) -> Readable<T>

Converts to this type from the input type.

impl<T> From<T> for Readable<T>

fn from(value: T) -> Readable<T>

Converts to this type from the input type.

impl<T> From<Writable<T>> for Readable<T>

fn from(value: Writable<T>) -> Readable<T>

Converts to this type from the input type.

impl<T> PartialEq for Readable<T>

where T: 'static,

fn eq(&self, _other: &Readable<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.