Struct Signal 

pub struct Signal<T>(/* private fields */);

Shared, single-threaded reactive state. Cloning shares the same value.

Implementations

impl<T> Signal<T>

pub fn with<R>(&self, read: impl FnOnce(&T) -> R) -> R

Read without cloning the value, tracking this dependency. Do not write this signal while the read closure holds its borrow.

pub fn with_untracked<R>(&self, read: impl FnOnce(&T) -> R) -> R

Read without subscribing the current effect.

pub fn update<R>(&self, update: impl FnOnce(&mut T) -> R) -> R

Mutate state, then notify subscribers after releasing the mutable borrow. Always notifies; use set to skip unchanged values. The mutation closure must not read or write this same signal.

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

Replace the value and notify subscribers, returning the previous value. Unlike set, this needs no PartialEq and always notifies. Dropping the result retires the old value after notification.

impl<T: Clone> Signal<T>

pub fn get(&self) -> T

Clone the current value and automatically track the read.

Examples found in repository

examples/memo_workload.rs (line 14)

fn run(name: &str, cached: bool, consumers: usize, updates: u64, work: u64, group: u64) {
    let input = signal(0_u64);
    let computations = Rc::new(Cell::new(0_u64));
    let renders = Rc::new(Cell::new(0_u64));
    let compute = {
        let (input, computations) = (input.clone(), computations.clone());
        move || {
            computations.set(computations.get() + 1);
            let mut n = input.get() / group;
            for _ in 0..work {
                n = black_box(n.wrapping_mul(6364136223846793005).wrapping_add(1));
            }
            n
        }
    };
    let read: Rc<dyn Fn() -> u64> = if cached {
        let value = memo(compute);
        Rc::new(move || value.get())
    } else {
        let value = derived(compute);
        Rc::new(move || value.get())
    };
    let subscriptions: Vec<_> = (0..consumers)
        .map(|_| {
            let (read, renders) = (read.clone(), renders.clone());
            effect(move || {
                black_box(read());
                renders.set(renders.get() + 1);
            })
        })
        .collect();
    computations.set(0);
    renders.set(0);
    let start = Instant::now();
    for value in 1..=updates {
        input.set(black_box(value));
    }
    let elapsed = start.elapsed().as_micros();
    let mode = if cached { "Memo" } else { "Derived" };
    println!(
        "{name},{mode},{consumers},{updates},{},{},{elapsed}",
        computations.get(),
        renders.get()
    );
    assert_eq!(
        computations.get(),
        updates * if cached { 1 } else { consumers as u64 }
    );
    assert_eq!(
        renders.get(),
        if cached { updates / group } else { updates } * consumers as u64
    );
    drop(subscriptions);
}

pub fn get_untracked(&self) -> T

Clone the current value without dependency tracking.

impl<T: PartialEq> Signal<T>

pub fn set(&self, value: T)

Replace the value, notifying only when it actually changes. Retire the old value after notification, outside the internal borrow. Inside a batch, notification queues observers until the batch completes.

Examples found in repository

examples/memo_workload.rs (line 41)

fn run(name: &str, cached: bool, consumers: usize, updates: u64, work: u64, group: u64) {
    let input = signal(0_u64);
    let computations = Rc::new(Cell::new(0_u64));
    let renders = Rc::new(Cell::new(0_u64));
    let compute = {
        let (input, computations) = (input.clone(), computations.clone());
        move || {
            computations.set(computations.get() + 1);
            let mut n = input.get() / group;
            for _ in 0..work {
                n = black_box(n.wrapping_mul(6364136223846793005).wrapping_add(1));
            }
            n
        }
    };
    let read: Rc<dyn Fn() -> u64> = if cached {
        let value = memo(compute);
        Rc::new(move || value.get())
    } else {
        let value = derived(compute);
        Rc::new(move || value.get())
    };
    let subscriptions: Vec<_> = (0..consumers)
        .map(|_| {
            let (read, renders) = (read.clone(), renders.clone());
            effect(move || {
                black_box(read());
                renders.set(renders.get() + 1);
            })
        })
        .collect();
    computations.set(0);
    renders.set(0);
    let start = Instant::now();
    for value in 1..=updates {
        input.set(black_box(value));
    }
    let elapsed = start.elapsed().as_micros();
    let mode = if cached { "Memo" } else { "Derived" };
    println!(
        "{name},{mode},{consumers},{updates},{},{},{elapsed}",
        computations.get(),
        renders.get()
    );
    assert_eq!(
        computations.get(),
        updates * if cached { 1 } else { consumers as u64 }
    );
    assert_eq!(
        renders.get(),
        if cached { updates / group } else { updates } * consumers as u64
    );
    drop(subscriptions);
}

Trait Implementations

impl Checkbox for Signal<bool>

fn checked(&self, _: &str) -> bool

Whether the box whose value is choice is checked.

fn check(&self, _: &str, checked: bool)

The user checked or cleared the box whose value is choice.

impl<T: FromStr + PartialEq + 'static> Checkbox for Signal<Vec<T>>

fn checked(&self, choice: &str) -> bool

Whether the box whose value is choice is checked.

fn check(&self, choice: &str, checked: bool)

The user checked or cleared the box whose value is choice.

impl<T> 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: FromStr + Display + PartialEq + 'static> TextValue for Signal<T>

fn text(&self) -> String

The text the control shows.

fn shows(&self, text: &str) -> bool

Whether the control’s text already shows this value. Such an edit is never written back, which keeps the cursor and partial input intact.

fn edit(&self, text: String)

Apply the control’s text after a user edit.

fn touch(&self)

The control lost focus.