Struct Signal 

pub struct Signal<T>
where
    T: Clone + PartialEq + 'static,
{ /* private fields */ }

A reactive signal handle.

Allows reading, writing, and subscribing to changes. Implements Clone and Copy for ergonomic use; all copies share the same underlying state. The inner state is heap-allocated via Box and accessed through a raw pointer stored as a usize. The allocation is tracked in a global registry for lifecycle management. The Copy semantics are safe because only the pointer address is copied — the actual heap allocation is owned by the registry.

Implementations

impl<T> Signal<T>

where T: Clone + PartialEq + 'static,

Implementation of reactive signal operations.

pub fn create(value: T) -> Self

Creates a new Signal with the given initial value.

Allocates SignalInner<T> on the heap via Box, stores the raw pointer address, and registers it in the global registry for lifecycle tracking.

Arguments

• T - The initial value of the signal.

Returns

• Self - A handle to the newly created reactive signal.

pub fn get(&self) -> T

Returns the current value of the signal.

Directly reads the value from the heap-allocated inner state via raw pointer dereference. No runtime borrow checking overhead.

If the signal has been marked inactive (alive == false), returns the last stored value without registering tracking dependencies. This ensures that stale async callbacks (e.g., orphaned setInterval) holding a Signal copy can still call .get() safely without triggering side effects or panics.

If a tracking context is active (i.e., a DynamicNode is being rendered), automatically registers the current dynamic node as a dependent of this signal for precise reactive updates.

Returns

• T - The current value of the signal.

pub fn subscribe<F>(&self, callback: F)

where F: FnMut() + 'static,

Subscribes a callback to be invoked when the signal changes.

Arguments

• FnMut() + 'static - The callback to invoke when the signal changes.

pub fn set(&self, value: T)

Sets the value of the signal and notifies listeners.

Uses precise dirty marking: only dynamic nodes that depend on this signal are marked dirty, avoiding full broadcast.

Arguments

• T - The new value to assign to the signal.

pub fn set_silent(&self, value: T)

Sets the value of the signal and notifies listeners without scheduling a global DOM update dispatch.

Arguments

• T - The new value to assign to the signal.

pub fn set_untracked(&self, value: T)

Sets the value of the signal without notifying listeners or scheduling a DOM update. This is useful for breaking circular watch dependencies where two signals watch each other and would otherwise recurse infinitely.

If the signal has been marked inactive (alive == false), this is a no-op, consistent with set() behavior for dead signals.

Arguments

• T - The new value to assign to the signal.

impl<T> Signal<T>

where T: Clone + PartialEq + 'static,

pub fn new(inner: usize, _marker: PhantomData<fn() -> T>) -> Self

Trait Implementations

impl<T> Clone for Signal<T>

where T: Clone + PartialEq + 'static,

Clones the signal, sharing the same inner state.

Since Signal is Copy, this simply returns *self.

Returns

• Self: A copy of the signal handle sharing the same inner state.

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Copy for Signal<T>

where T: Clone + PartialEq + 'static,

Copies the signal, sharing the same inner state.

Safe because only the inner address (a usize) is copied; the actual heap allocation is owned by the global signal registry.

impl<T> Debug for Signal<T>

where T: Clone + PartialEq + 'static,

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

Formats the value using the given formatter.

impl<T> Default for Signal<T>

where T: Clone + Default + PartialEq + 'static,

Provides a safe default for Signal<T> by creating a valid signal initialized with T::default().

This prevents the creation of invalid signals with inner = 0 (null pointer), which would cause a panic when .get() is called.

Returns

• Self: A valid signal initialized with T::default().

fn default() -> Self

Returns the “default value” for a type.

impl<T> Eq for Signal<T>

where T: Clone + PartialEq + 'static + Eq,

impl<T> IntoNode for Signal<T>

where T: Clone + PartialEq + Display + 'static,

Converts a signal into a reactive text virtual node via IntoNode.

fn into_node(self) -> VirtualNode

Converts this signal into a reactive text virtual node.

Returns

• VirtualNode - A reactive text virtual node.

impl IntoReactiveString for Signal<String>

Converts a string signal into a reactive string by resolving its current value.

fn into_reactive_string(self) -> String

Resolves the current value of this signal.

Returns

• String - The current value of the signal.

impl IntoReactiveString for Signal<bool>

Converts a bool signal into a reactive string by resolving its current value.

fn into_reactive_string(self) -> String

Resolves the current value of this bool signal as a string.

Returns

• String - The current boolean value as "true" or "false".

impl IntoReactiveValue for Signal<String>

Converts a string signal into a reactive attribute value.

fn into_reactive_value(self) -> AttributeValue

Converts this string signal into an AttributeValue::Signal.

Returns

• AttributeValue - A signal-backed attribute value.

impl IntoReactiveValue for Signal<bool>

Converts a mutable bool signal into a reactive attribute value.

The signal is mapped to a Signal<String> that yields "true" or "false", enabling boolean attributes like checked to reactively update the DOM.

fn into_reactive_value(self) -> AttributeValue

Converts this bool signal into an AttributeValue via string mapping.

Returns

• AttributeValue - A signal-backed attribute value yielding "true" or "false".

impl<T> PartialEq for Signal<T>

where T: Clone + PartialEq + 'static + PartialEq,

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.

impl<T> StructuralPartialEq for Signal<T>

where T: Clone + PartialEq + 'static,