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.

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<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.