Trait Writable 

pub trait Writable: Readable {
    type WriteMetadata;

    // Required method
    fn try_write_unchecked(
        &self,
    ) -> Result<WriteLock<'static, Self::Target, Self::Storage, Self::WriteMetadata>, BorrowMutError>
       where Self::Target: 'static;
}

Available on crate feature prelude only.

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 WriteMetadata

Additional data associated with the write reference.

Required Methods

fn try_write_unchecked( &self, ) -> Result<WriteLock<'static, Self::Target, Self::Storage, Self::WriteMetadata>, BorrowMutError>

where Self::Target: 'static,

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.

Implementations on Foreign Types

impl<Index, Write> Writable for IndexWrite<Index, Write>

where Write: Writable, <Write as Readable>::Target: IndexMut<Index> + 'static, Index: Clone,

type WriteMetadata = <Write as Writable>::WriteMetadata

fn try_write_unchecked( &self, ) -> Result<WriteLock<'static, <IndexWrite<Index, Write> as Readable>::Target, <IndexWrite<Index, Write> as Readable>::Storage, <IndexWrite<Index, Write> as Writable>::WriteMetadata>, BorrowMutError>

where <IndexWrite<Index, Write> as Readable>::Target: 'static,

impl<Index, Write, K, V> Writable for GetWrite<Index, Write>

where Write: Writable<Target = BTreeMap<K, V>>, Index: Ord + 'static, K: Borrow<Index> + Ord + 'static,

type WriteMetadata = <Write as Writable>::WriteMetadata

fn try_write_unchecked( &self, ) -> Result<WriteLock<'static, <GetWrite<Index, Write> as Readable>::Target, <GetWrite<Index, Write> as Readable>::Storage, <GetWrite<Index, Write> as Writable>::WriteMetadata>, BorrowMutError>

where <GetWrite<Index, Write> as Readable>::Target: 'static,

impl<Index, Write, K, V, St> Writable for GetWrite<Index, Write>

where Write: Writable<Target = HashMap<K, V, St>>, Index: Hash + Eq + 'static, K: Borrow<Index> + Eq + Hash + 'static, St: BuildHasher + 'static,

type WriteMetadata = <Write as Writable>::WriteMetadata

fn try_write_unchecked( &self, ) -> Result<WriteLock<'static, <GetWrite<Index, Write> as Readable>::Target, <GetWrite<Index, Write> as Readable>::Storage, <GetWrite<Index, Write> as Writable>::WriteMetadata>, BorrowMutError>

where <GetWrite<Index, Write> as Readable>::Target: 'static,

impl<Lens> Writable for SelectorScope<Lens>

where Lens: Writable,

type WriteMetadata = <Lens as Writable>::WriteMetadata

fn try_write_unchecked( &self, ) -> Result<WriteLock<'static, <Lens as Readable>::Target, <Lens as Readable>::Storage, <Lens as Writable>::WriteMetadata>, BorrowMutError>

Implementors

impl<T> Writable for Memo<T>

where T: 'static + PartialEq,

type WriteMetadata = <Signal<T> as Writable>::WriteMetadata

impl<T> Writable for Resource<T>

type WriteMetadata = <Signal<Option<T>> as Writable>::WriteMetadata

impl<T, Lens> Writable for Store<T, Lens>

where Lens: Writable<Target = T>, T: 'static + ?Sized,

type WriteMetadata = <Lens as Writable>::WriteMetadata

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

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

type WriteMetadata = <T as Writable>::WriteMetadata

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

where S: Storage<T>,

type WriteMetadata = ()

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

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

type WriteMetadata = SignalSubscriberDrop<T, S>

impl<T, S> Writable for WriteSignal<T, S>

where S: BoxedSignalStorage<T>, T: ?Sized,

type WriteMetadata = Box<dyn Any>

impl<V, O, F, FMut> Writable for MappedMutSignal<O, V, F, FMut>

where V: Writable, <V as Readable>::Target: 'static, F: Fn(&<V as Readable>::Target) -> &O, FMut: Fn(&mut <V as Readable>::Target) -> &mut O, O: ?Sized,

type WriteMetadata = <V as Writable>::WriteMetadata