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.

When called inside batch, the dispatch is deferred (dirty slots are still marked precisely), and the outermost set() call outside the suppressed scope will trigger the actual dispatch cycle.

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,