Trait Writable

pub trait Writable: Readable {
    type Mut<'a, R: ?Sized + 'static>: DerefMut<Target = R>;

    // Required methods
    fn map_mut<I: ?Sized, U: ?Sized, F: FnOnce(&mut I) -> &mut U>(
        ref_: Self::Mut<'_, I>,
        f: F,
    ) -> Self::Mut<'_, U>;
    fn try_map_mut<I: ?Sized, U: ?Sized, F: FnOnce(&mut I) -> Option<&mut U>>(
        ref_: Self::Mut<'_, I>,
        f: F,
    ) -> Option<Self::Mut<'_, U>>;
    fn downcast_lifetime_mut<'a: 'b, 'b, T: ?Sized + 'static>(
        mut_: Self::Mut<'a, T>,
    ) -> Self::Mut<'b, T>;
    fn try_write_unchecked(
        &self,
    ) -> Result<WritableRef<'static, Self>, BorrowMutError>;

    // Provided methods
    fn write(&mut self) -> WritableRef<'_, Self> { ... }
    fn try_write(&mut self) -> Result<WritableRef<'_, Self>, BorrowMutError> { ... }
    fn write_unchecked(&self) -> WritableRef<'static, Self> { ... }
    fn with_mut<O>(&mut self, f: impl FnOnce(&mut Self::Target) -> O) -> O { ... }
    fn set(&mut self, value: Self::Target)
       where Self::Target: Sized { ... }
    fn toggle(&mut self)
       where Self::Target: Not<Output = Self::Target> + Clone { ... }
    fn index_mut<I>(
        &mut self,
        index: I,
    ) -> WritableRef<'_, Self, <Self::Target as Index<I>>::Output>
       where Self::Target: IndexMut<I> { ... }
    fn take(&mut self) -> Self::Target
       where Self::Target: Default { ... }
    fn replace(&mut self, value: Self::Target) -> Self::Target
       where Self::Target: Sized { ... }
}

A trait for states that can be written to like crate::Signal. You may choose to accept this trait as a parameter instead of the concrete type to allow for more flexibility in your API.

Example

enum MyEnum {
    String(String),
    Number(i32),
}

fn MyComponent(mut count: Signal<MyEnum>) -> Element {
    rsx! {
        button {
            onclick: move |_| {
                // You can use any methods from the Writable trait on Signals
                match &mut *count.write() {
                    MyEnum::String(s) => s.push('a'),
                    MyEnum::Number(n) => *n += 1,
                }
            },
            "Add value"
        }
    }
}

Required Associated Types

type Mut<'a, R: ?Sized + 'static>: DerefMut<Target = R>

The type of the reference.

Required Methods

fn map_mut<I: ?Sized, U: ?Sized, F: FnOnce(&mut I) -> &mut U>( ref_: Self::Mut<'_, I>, f: F, ) -> Self::Mut<'_, U>

Map the reference to a new type.

fn try_map_mut<I: ?Sized, U: ?Sized, F: FnOnce(&mut I) -> Option<&mut U>>( ref_: Self::Mut<'_, I>, f: F, ) -> Option<Self::Mut<'_, U>>

Try to map the reference to a new type.

fn downcast_lifetime_mut<'a: 'b, 'b, T: ?Sized + 'static>( mut_: Self::Mut<'a, T>, ) -> Self::Mut<'b, T>

Downcast a mutable reference in a RefMut to a more specific lifetime

This function enforces the variance of the lifetime parameter 'a in Ref.

fn try_write_unchecked( &self, ) -> Result<WritableRef<'static, Self>, BorrowMutError>

Try to get a mutable reference to the value without checking the lifetime. This will update any subscribers.

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

Provided Methods

fn write(&mut self) -> WritableRef<'_, Self>

Get a mutable reference to the value. If the value has been dropped, this will panic.

fn try_write(&mut self) -> Result<WritableRef<'_, Self>, BorrowMutError>

Try to get a mutable reference to the value.

fn write_unchecked(&self) -> WritableRef<'static, Self>

Get a mutable reference to the value without checking the lifetime. This will update any subscribers.

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

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

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

fn set(&mut self, value: Self::Target)

where Self::Target: Sized,

Set the value of the signal. This will trigger an update on all subscribers.

fn toggle(&mut self)

where Self::Target: Not<Output = Self::Target> + Clone,

Invert the boolean value of the signal. This will trigger an update on all subscribers.

fn index_mut<I>( &mut self, index: I, ) -> WritableRef<'_, Self, <Self::Target as Index<I>>::Output>

where Self::Target: IndexMut<I>,

Index into the inner value and return a reference to the result.

fn take(&mut self) -> Self::Target

where Self::Target: Default,

Takes the value out of the Signal, leaving a Default in its place.

fn replace(&mut self, value: Self::Target) -> Self::Target

where Self::Target: Sized,

Replace the value in the Signal, returning the old value.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<T, R: 'static> Writable for Global<T, R>

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

type Mut<'a, Read: ?Sized + 'static> = <T as Writable>::Mut<'a, Read>

impl<T: 'static, S: Storage<SignalData<T>>> Writable for Signal<T, S>

type Mut<'a, R: ?Sized + 'static> = Write<'a, R, S>

impl<T: 'static, S: Storage<T>> Writable for CopyValue<T, S>

type Mut<'a, R: ?Sized + 'static> = <S as AnyStorage>::Mut<'a, R>