Struct dioxus_signals::Signal

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

Creates a new Signal. Signals are a Copy state management solution with automatic dependency tracking.

use dioxus::prelude::*;
use dioxus_signals::*;

#[component]
fn App(cx: Scope) -> Element {
    let mut count = use_signal(cx, || 0);

    // Because signals have automatic dependency tracking, if you never read them in a component, that component will not be re-rended when the signal is updated.
    // The app component will never be rerendered in this example.
    render! { Child { state: count } }
}

#[component]
fn Child(cx: Scope, state: Signal<u32>) -> Element {
    let state = *state;

    use_future!(cx,  |()| async move {
        // Because the signal is a Copy type, we can use it in an async block without cloning it.
        *state.write() += 1;
    });

    render! {
        button {
            onclick: move |_| *state.write() += 1,
            "{state}"
        }
    }
}

Implementations

impl<T: 'static> Signal<Vec<T>>

pub fn get(&self, index: usize) -> Option<Ref<'_, T>>

Read a value from the inner vector.

impl<T: 'static> Signal<Option<T>>

pub fn unwrap(&self) -> Twhere T: Clone,

Unwraps the inner value and clones it.

pub fn as_ref(&self) -> Option<Ref<'_, T>>

Attemps to read the inner value of the Option.

impl<T: 'static> Signal<Vec<T>>

pub fn push(&self, value: T)

Pushes a new value to the end of the vector.

pub fn pop(&self) -> Option<T>

Pops the last value from the vector.

pub fn insert(&self, index: usize, value: T)

Inserts a new value at the given index.

pub fn remove(&self, index: usize) -> T

Removes the value at the given index.

pub fn clear(&self)

Clears the vector, removing all values.

pub fn extend(&self, iter: impl IntoIterator<Item = T>)

Extends the vector with the given iterator.

pub fn truncate(&self, len: usize)

Truncates the vector to the given length.

pub fn swap_remove(&self, index: usize) -> T

Swaps two values in the vector.

pub fn retain(&self, f: impl FnMut(&T) -> bool)

Retains only the values that match the given predicate.

pub fn split_off(&self, at: usize) -> Vec<T>

Splits the vector into two at the given index.

impl<T: 'static> Signal<Option<T>>

pub fn take(&self) -> Option<T>

Takes the value out of the Option.

pub fn replace(&self, value: T) -> Option<T>

Replace the value in the Option.

pub fn get_or_insert(&self, default: T) -> Ref<'_, T>

Gets the value out of the Option, or inserts the given value if the Option is empty.

pub fn get_or_insert_with(&self, default: impl FnOnce() -> T) -> Ref<'_, T>

Gets the value out of the Option, or inserts the value returned by the given function if the Option is empty.

impl<T: 'static> Signal<Vec<T>>

pub fn get_mut(&self, index: usize) -> Option<Write<'_, T, Vec<T>>>

Returns a reference to an element or None if out of bounds.

impl<T: 'static> Signal<Option<T>>

pub fn as_mut(&self) -> Option<Write<'_, T, Option<T>>>

Returns a reference to an element or None if out of bounds.

impl<T: 'static> Signal<T>

pub fn new(value: T) -> Self

Creates a new Signal. Signals are a Copy state management solution with automatic dependency tracking.

pub fn new_in_scope(value: T, owner: ScopeId) -> Self

Create a new signal with a custom owner scope. The signal will be dropped when the owner scope is dropped instead of the current scope.

pub fn origin_scope(&self) -> ScopeId

Get the scope the signal was created in.

pub fn read(&self) -> Ref<'_, T>

Get the current value of the signal. This will subscribe the current scope to the signal. If the signal has been dropped, this will panic.

pub fn write(&self) -> Write<'_, T>

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

pub fn set(&self, value: T)

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

pub fn with<O>(&self, f: impl FnOnce(&T) -> O) -> O

Run a closure with a reference to the signal’s value. If the signal has been dropped, this will panic.

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

Run a closure with a mutable reference to the signal’s value. If the signal has been dropped, this will panic.

impl<T: Clone + 'static> Signal<T>

pub fn value(&self) -> T

Get the current value of the signal. This will subscribe the current scope to the signal. If the signal has been dropped, this will panic.

impl Signal<bool>

pub fn toggle(&self)

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

Trait Implementations

impl<T: Add<Output = T> + Copy + 'static> Add<T> for Signal<T>

type Output = T

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<T: Add<Output = T> + Copy + 'static> AddAssign<T> for Signal<T>

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T> Clone for Signal<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + 'static> Debug for Signal<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default + 'static> Default for Signal<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Deref for Signal<T>

type Target = dyn Fn() -> Ref<'static, T>

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: Display + 'static> Display for Signal<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Div<Output = T> + Copy + 'static> Div<T> for Signal<T>

type Output = T

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<T: Div<Output = T> + Copy + 'static> DivAssign<T> for Signal<T>

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T: Clone + 'static> IntoIterator for Signal<Vec<T>>

type IntoIter = SignalIterator<T>

Which kind of iterator are we turning this into?

type Item = T

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Mul<Output = T> + Copy + 'static> Mul<T> for Signal<T>

type Output = T

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T: Mul<Output = T> + Copy + 'static> MulAssign<T> for Signal<T>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

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

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: Sub<Output = T> + Copy + 'static> Sub<T> for Signal<T>

type Output = T

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<T: Sub<Output = T> + Copy + 'static> SubAssign<T> for Signal<T>

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<T> Copy for Signal<T>