Struct WriteLock

pub struct WriteLock<'a, T: ?Sized + 'a, S: AnyStorage = UnsyncStorage, D = ()> { /* private fields */ }

A mutable reference to a writable value. This reference acts similarly to std::cell::RefMut, but it has extra debug information and integrates with the reactive system to automatically update dependents.

WriteLock implements DerefMut which means you can call methods on the inner value just like you would on a mutable reference to the inner value. If you need to get the inner reference directly, you can call WriteLock::deref_mut.

Example

fn app() -> Element {
    let mut value = use_signal(|| String::from("hello"));
     
    rsx! {
        button {
            onclick: move |_| {
                let mut mutable_reference = value.write();

                // You call methods like `push_str` on the reference just like you would with the inner String
                mutable_reference.push_str("world");
            },
            "Click to add world to the string"
        }
        div { "{value}" }
    }
}

Matching on WriteLock

You need to get the inner mutable reference with WriteLock::deref_mut before you match the inner value. If you try to match without calling WriteLock::deref_mut, you will get an error like this:

#[derive(Debug)]
enum Colors {
    Red(u32),
    Green
}
fn app() -> Element {
    let mut value = use_signal(|| Colors::Red(0));

    rsx! {
        button {
            onclick: move |_| {
                let mut mutable_reference = value.write();

                match mutable_reference {
                    // Since we are matching on the `Write` type instead of &mut Colors, we can't match on the enum directly
                    Colors::Red(brightness) => *brightness += 1,
                    Colors::Green => {}
                }
            },
            "Click to add brightness to the red color"
        }
        div { "{value:?}" }
    }
}

error[E0308]: mismatched types
  --> src/main.rs:18:21
   |
16 |                 match mutable_reference {
   |                       ----------------- this expression has type `dioxus::prelude::Write<'_, Colors>`
17 |                     // Since we are matching on the `Write` t...
18 |                     Colors::Red(brightness) => *brightness += 1,
   |                     ^^^^^^^^^^^^^^^^^^^^^^^ expected `Write<'_, Colors>`, found `Colors`
   |
   = note: expected struct `dioxus::prelude::Write<'_, Colors, >`
               found enum `Colors`

Instead, you need to call deref mut on the reference to get the inner value before you match on it:

use std::ops::DerefMut;
#[derive(Debug)]
enum Colors {
    Red(u32),
    Green
}
fn app() -> Element {
    let mut value = use_signal(|| Colors::Red(0));

    rsx! {
        button {
            onclick: move |_| {
                let mut mutable_reference = value.write();

                // DerefMut converts the `Write` into a `&mut Colors`
                match mutable_reference.deref_mut() {
                    // Now we can match on the inner value
                    Colors::Red(brightness) => *brightness += 1,
                    Colors::Green => {}
                }
            },
            "Click to add brightness to the red color"
        }
        div { "{value:?}" }
    }
}

Generics

• T is the current type of the write
• S is the storage type of the signal. This type determines if the signal is local to the current thread, or it can be shared across threads.
• D is the additional data associated with the write reference. This is used by signals to track when the write is dropped

Implementations

impl<'a, T: ?Sized, S: AnyStorage> WriteLock<'a, T, S>

pub fn new(write: S::Mut<'a, T>) -> Self

Create a new write reference

impl<'a, T: ?Sized, S: AnyStorage, D> WriteLock<'a, T, S, D>

pub fn new_with_metadata(write: S::Mut<'a, T>, data: D) -> Self

Create a new write reference with additional data.

pub fn into_inner(self) -> S::Mut<'a, T>

Get the inner value of the write reference.

pub fn data(&self) -> &D

Get the additional data associated with the write reference.

pub fn into_parts(self) -> (S::Mut<'a, T>, D)

Split into the inner value and the additional data.

pub fn map_metadata<O>(self, f: impl FnOnce(D) -> O) -> WriteLock<'a, T, S, O>

Map the metadata of the write reference to a new type.

pub fn map<O: ?Sized>( myself: Self, f: impl FnOnce(&mut T) -> &mut O, ) -> WriteLock<'a, O, S, D>

Map the mutable reference to the signal’s value to a new type.

pub fn filter_map<O: ?Sized>( myself: Self, f: impl FnOnce(&mut T) -> Option<&mut O>, ) -> Option<WriteLock<'a, O, S, D>>

Try to map the mutable reference to the signal’s value to a new type

pub fn downcast_lifetime<'b>(mut_: Self) -> WriteLock<'b, T, S, D>

where 'a: 'b,

Downcast the lifetime of the mutable reference to the signal’s value.

This function enforces the variance of the lifetime parameter 'a in Mut. Rust will typically infer this cast with a concrete type, but it cannot with a generic type.

Trait Implementations

impl<T, S, D> Deref for WriteLock<'_, T, S, D>

where S: AnyStorage, T: ?Sized,

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, S, D> DerefMut for WriteLock<'_, T, S, D>

where S: AnyStorage, T: ?Sized,

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

Mutably dereferences the value.