Struct Signal 

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

State that can be set.

Example

use maple_core::prelude::*;

let state = Signal::new(0);
assert_eq!(*state.get(), 0);

state.set(1);
assert_eq!(*state.get(), 1);

Implementations

impl<T: 'static> Signal<T>

pub fn new(value: T) -> Self

Creates a new signal with the given value.

Example

let state = Signal::new(0);

pub fn set(&self, new_value: T)

Set the current value of the state.

This will notify and update any effects and memos that depend on this value.

Example

let state = Signal::new(0);
assert_eq!(*state.get(), 0);

state.set(1);
assert_eq!(*state.get(), 1);

pub fn handle(&self) -> StateHandle<T>

Get the StateHandle associated with this signal.

This is a shortcut for (*signal).clone().

pub fn into_handle(self) -> StateHandle<T>

Consumes this signal and returns its underlying StateHandle.

pub fn trigger_subscribers(&self)

Calls all the subscribers without modifying the state. This can be useful when using patterns such as inner mutability where the state updated will not be automatically triggered. In the general case, however, it is preferable to use Signal::set instead.

Methods from Deref<Target = StateHandle<T>>

pub fn get(&self) -> Rc<T>

Get the current value of the state.

pub fn get_untracked(&self) -> Rc<T>

Get the current value of the state, without tracking this as a dependency if inside a reactive context.

Example

use maple_core::prelude::*;

let state = Signal::new(1);

let double = create_memo({
    let state = state.clone();
    move || *state.get_untracked() * 2
});

assert_eq!(*double.get(), 2);

state.set(2);
// double value should still be old value because state was untracked
assert_eq!(*double.get(), 2);

Trait Implementations

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

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Signal<T>

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

Formats the value using the given formatter.

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

type Target = StateHandle<T>

The resulting type after dereferencing.

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

Dereferences the value.

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

fn eq(&self, other: &Signal<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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