Struct Signal 

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

Mutable source node in the reactive graph.

Reading a signal from inside an observer (an effect, thunk, or memo computation) records a dependency; writing to it marks those observers stale — thunks and memos recompute on their next read, and effects are queued for the next microtask flush. Clones share the same underlying node, so a signal can be captured by any number of closures. The node lives as long as any clone does.

Writes through set are suppressed when the new value equals the old one, which is what allows convergent feedback (e.g. an effect clamping a value it reads) to settle. replace and update always mark dependents stale.

Implementations

impl<T: 'static> Signal<T>

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

Runs f with a shared reference to the current value, recording a dependency for the currently running observer.

Panics

A shared borrow is held while f runs: writing this same signal (set, replace, or update) from inside f panics with a borrow error.

pub fn with_peek<R>(&self, f: impl FnOnce(&T) -> R) -> R

Runs f with a shared reference to the current value without recording a dependency.

Panics

A shared borrow is held while f runs, exactly as in with: writing this same signal (set, replace, or update) from inside f panics with a borrow error.

pub fn reactor(&self) -> Reactor

Returns the reactor this signal’s node belongs to.

pub fn id(&self) -> NodeId

Returns this signal’s node id, for use with the graph queries on Reactor — observer_count, dependencies_of, node_origin and friends. Ids are unique within one reactor, so aggregate on (Reactor::id, id).

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

Replaces the current value and marks dependents stale, even when the new value equals the old one (compare set).

Panics

The value is swapped through a mutable borrow, so writing this same signal from inside a closure that already holds one — with, with_peek or update on this signal — panics with a borrow error. The panic is std’s bare RefCell already borrowed, but #[track_caller] attributes it to this call site, so the offending write is named by line in every build.

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

Mutates the current value in place and marks dependents stale, regardless of whether f actually changed anything (compare set).

Panics

f runs while the value is mutably borrowed: any read or write of the same signal from inside f (get, with, peek, set, replace, or a nested update) panics with a borrow error.

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

pub fn get(&self) -> T

Clones and returns the current value.

pub fn peek(&self) -> T

Clones and returns the current value without recording a dependency.

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

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

Sets the signal to value, suppressing unchanged writes.

Returns the previous value if the signal changed, or None when the new value was equal to the old one.

The equality check runs untracked, so a PartialEq implementation that reads reactive state records no dependencies for the currently running observer.

Panics

A write borrows the value twice over: the equality check takes a shared borrow, and a write that survives it takes a mutable one. So writing this same signal from inside a closure that already holds a borrow — with, with_peek or update on this signal — panics with a borrow error, as does a PartialEq implementation that writes the very signal it was asked to compare. The panic is std’s bare RefCell already borrowed, but #[track_caller] attributes it to this call site, so the offending write is named by line in every build.

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.

impl<T> Debug for Signal<T>

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

Formats the value using the given formatter.

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

type Item = T

The type of value this observable holds.

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

Runs f with a shared reference to the current value, recording a dependency for the currently running observer.

fn with_peek<R>(&self, f: impl FnOnce(&T) -> R) -> R

Runs f with a shared reference to the current value without recording a dependency.

fn reactor(&self) -> Option<Reactor>

Returns the reactor this observable’s node belongs to, when it has one.

fn get(&self) -> Self::Item

where Self::Item: Clone,

Clones and returns the current value, recording a dependency.

fn peek(&self) -> Self::Item

where Self::Item: Clone,

Clones and returns the current value without recording a dependency.

fn map<U, F>(&self, f: F) -> Memo<U>

where Self: Clone + Sized + 'static, U: PartialEq + 'static, F: Fn(&Self::Item) -> U + 'static,

Derives a memo from this observable, cloning the receiver’s handle internally.

fn into_dyn(self) -> DynObservable<Self::Item>

where Self: Sized + 'static,

Erases this observable’s concrete type behind a cheaply-cloneable handle.

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

fn set(&self, value: T)

Assigns a new value.