Struct rustcn_ui::Signal

pub struct Signal<T, S = UnsyncStorage>
where
    T: 'static,
    S: Storage<SignalData<T>>,
{ /* 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() -> Element {
    let mut count = use_signal(|| 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.
    rsx! { Child { state: count } }
}

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

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

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

Implementations

impl<T> Signal<T>

where T: 'static,

pub fn new(value: T) -> Signal<T>

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

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

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 const fn global(constructor: fn() -> T) -> GlobalSignal<T>

Creates a new global Signal that can be used in a global static.

impl<T> Signal<T>

where T: PartialEq + 'static,

pub const fn global_memo(constructor: fn() -> T) -> GlobalMemo<T>

Creates a new global Signal that can be used in a global static.

pub fn memo(f: impl FnMut() -> T + 'static) -> ReadOnlySignal<T>

Creates a new unsync Selector. The selector will be run immediately and whenever any signal it reads changes.

Selectors can be used to efficiently compute derived data from signals.

pub fn use_maybe_sync_memo<S>( f: impl FnMut() -> T + 'static ) -> ReadOnlySignal<T, S>

where S: Storage<SignalData<T>>,

Creates a new Selector that may be Sync + Send. The selector will be run immediately and whenever any signal it reads changes.

Selectors can be used to efficiently compute derived data from signals.

impl<T, S> Signal<T, S>

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

pub fn new_maybe_sync(value: T) -> Signal<T, S>

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

pub fn new_with_caller( value: T, caller: &'static Location<'static> ) -> Signal<T, S>

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

pub fn new_maybe_sync_in_scope(value: T, owner: ScopeId) -> Signal<T, S>

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 take(&self) -> T

Take the value out of the signal, invalidating the signal in the process.

pub fn origin_scope(&self) -> ScopeId

Get the scope the signal was created in.

pub fn id(&self) -> GenerationalBoxId

Get the generational id of the signal.

Trait Implementations

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

where T: Add<Output = T> + Copy + 'static, S: Storage<SignalData<T>>,

type Output = T

The resulting type after applying the + operator.

fn add(self, rhs: T) -> <Signal<T, S> as Add<T>>::Output

Performs the + operation.

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

where T: Add<Output = T> + Copy + 'static, S: Storage<SignalData<T>>,

fn add_assign(&mut self, rhs: T)

Performs the += operation.

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

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

fn clone(&self) -> Signal<T, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

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

Formats the value using the given formatter.

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

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

fn default() -> Signal<T, S>

Returns the “default value” for a type.

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

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

Allow calling a signal with signal() syntax

Currently only limited to copy types, though could probably specialize for string/arc/rc

type Target = dyn Fn() -> T

The resulting type after dereferencing.

fn deref(&self) -> &<Signal<T, S> as Deref>::Target

Dereferences the value.

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

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

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

Formats the value using the given formatter.

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

where T: Div<Output = T> + Copy + 'static, S: Storage<SignalData<T>>,

type Output = T

The resulting type after applying the / operator.

fn div(self, rhs: T) -> <Signal<T, S> as Div<T>>::Output

Performs the / operation.

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

where T: Div<Output = T> + Copy + 'static, S: Storage<SignalData<T>>,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T, S> From<Signal<T, S>> for ReadOnlySignal<T, S>

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

fn from(inner: Signal<T, S>) -> ReadOnlySignal<T, S>

Converts to this type from the input type.

impl<T> IntoAttributeValue for Signal<T>

where T: Clone + IntoAttributeValue,

fn into_value(self) -> AttributeValue

Convert into an attribute value

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

where T: Mul<Output = T> + Copy + 'static, S: Storage<SignalData<T>>,

type Output = T

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> <Signal<T, S> as Mul<T>>::Output

Performs the * operation.

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

where T: Mul<Output = T> + Copy + 'static, S: Storage<SignalData<T>>,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

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

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

fn eq(&self, other: &T) -> 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, S> PartialEq for Signal<T, S>

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

fn eq(&self, other: &Signal<T, S>) -> 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, S> Readable for Signal<T, S>

where S: Storage<SignalData<T>>,

fn peek( &self ) -> <<Signal<T, S> as Readable>::Storage as AnyStorage>::Ref<<Signal<T, S> as Readable>::Target>

Get the current value of the signal. Unlike read, this will not subscribe the current scope to the signal which can cause parts of your UI to not update.

If the signal has been dropped, this will panic.

type Target = T

The target type of the reference.

type Storage = S

The type of the storage this readable uses.

fn try_read( &self ) -> Result<<<Signal<T, S> as Readable>::Storage as AnyStorage>::Ref<<Signal<T, S> as Readable>::Target>, BorrowError>

Try to get the current value of the state. If this is a signal, this will subscribe the current scope to the signal. If the value has been dropped, this will panic.

fn map<O>( self, f: impl Fn(&Self::Target) -> &O + 'static ) -> MappedSignal<O, Self::Storage>

where Self: Clone + Sized + 'static,

Map the readable type to a new type.

fn read(&self) -> <Self::Storage as AnyStorage>::Ref<Self::Target>

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

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

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

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

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

fn index<I>( &self, index: I ) -> <Self::Storage as AnyStorage>::Ref<<Self::Target as Index<I>>::Output>

where Self::Target: Index<I>,

Index into the inner value and return a reference to the result. If the value has been dropped or the index is invalid, this will panic.

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

where T: Sub<Output = T> + Copy + 'static, S: Storage<SignalData<T>>,

type Output = T

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> <Signal<T, S> as Sub<T>>::Output

Performs the - operation.

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

where T: Sub<Output = T> + Copy + 'static, S: Storage<SignalData<T>>,

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

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

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

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

The type of the reference.

fn map_mut<I, U, F>( ref_: <Signal<T, S> as Writable>::Mut<I>, f: F ) -> <Signal<T, S> as Writable>::Mut<U>

where U: 'static + ?Sized, F: FnOnce(&mut I) -> &mut U, I: ?Sized,

Map the reference to a new type.

fn try_map_mut<I, U, F>( ref_: <Signal<T, S> as Writable>::Mut<I>, f: F ) -> Option<<Signal<T, S> as Writable>::Mut<U>>

where I: 'static + ?Sized, U: 'static + ?Sized, F: FnOnce(&mut I) -> Option<&mut U>,

Try to map the reference to a new type.

fn try_write( &self ) -> Result<<Signal<T, S> as Writable>::Mut<T>, BorrowMutError>

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

fn write(&mut self) -> Self::Mut<Self::Target>

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

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 index_mut<I>( &mut self, index: I ) -> Self::Mut<<Self::Target as Index<I>>::Output>

where Self::Target: IndexMut<I>,

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

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

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