Struct Writable 

pub struct Writable<T: 'static> { /* private fields */ }

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

This abstraction allows components to accept state from any source without knowing whether it comes from local state (use_state) or global state (Freya Radio). It hides the implementation details, providing a uniform interface for reading and writing values.

Sources

Writable can be created from:

• State<T> via From or IntoWritable
• RadioSliceMut via IntoWritable

Example

#[derive(PartialEq)]
struct NameInput {
    name: Writable<String>,
}

impl Component for NameInput {
    fn render(&self) -> impl IntoElement {
        // The component doesn't care if this is local or global state
        Input::new(self.name.clone())
    }
}

fn app() -> impl IntoElement {
    let local = use_state(|| "Alice".to_string());
    let radio = use_radio(AppChannel::Name);
    let slice = radio.slice_mut_current(|s| &mut s.name);

    rect()
        // Pass local state
        .child(NameInput { name: local.into_writable() })
        // Pass global radio slice
        .child(NameInput { name: slice.into_writable() })
}

Implementations

impl<T: 'static> Writable<T>

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

Create from local State<T>.

pub fn new( peek_fn: Box<dyn Fn() -> ReadRef<'static, T>>, write_fn: Box<dyn Fn() -> WriteRef<'static, T>>, subscribe_fn: Box<dyn Fn()>, notify_fn: Box<dyn Fn()>, ) -> Self

Create a new Writable with custom peek, write, subscribe, and notify functions.

pub fn read(&self) -> ReadRef<'static, T>

Read the value and subscribe to changes.

pub fn peek(&self) -> ReadRef<'static, T>

Read the value without subscribing.

pub fn write(&mut self) -> WriteRef<'static, T>

Write the value and notify subscribers.

pub fn write_if(&mut self, with: impl FnOnce(WriteRef<'static, T>) -> bool)

Trait Implementations

impl<T: 'static> Clone for Writable<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> From<State<T>> for Writable<T>

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<T: 'static> PartialEq for Writable<T>

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