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: Clone + PartialEq + 'static - 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: Clone + PartialEq + 'static - 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: Clone + PartialEq + 'static - The new value to assign to the signal.

impl<T> Signal<T>

where T: Clone + PartialEq + 'static,

pub fn get_inner(&self) -> usize

pub fn get__marker(&self) -> PhantomData<fn() -> T>

impl<T> Signal<T>

where T: Clone + PartialEq + 'static,

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

Trait Implementations

impl<T> AsReactiveText for Signal<T>

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

Converts a signal into a reactive text node with listener wiring.

fn as_reactive_text(&self) -> VirtualNode

Creates a reactive text node that auto-updates when the signal changes.

Internally creates a bridge Signal<String> that subscribes to the source signal and updates the text content on every change.

Returns

• VirtualNode - A text virtual node with reactive signal binding.

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

Clones the Signal by reusing shared, cheap-to-clone state where possible.

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

Constructs a default Signal value.

impl<T> Eq for Signal<T>

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

impl From<Signal<String>> for AttributeValue

Converts a string signal into a reactive attribute value.

fn from(signal: Signal<String>) -> Self

Converts this string signal into an AttributeValue::Signal.

Returns

• AttributeValue - A signal-backed attribute value.

Arguments

• Signal<String> - Input value to convert from.

impl<T> From<Signal<T>> for VirtualNode

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

Converts a signal into a reactive text virtual node.

fn from(signal: Signal<T>) -> Self

Converts this signal into a reactive text virtual node.

Returns

• VirtualNode - A reactive text virtual node.

Arguments

• Signal<T> - Input value to convert from.

impl From<Signal<bool>> for AttributeValue

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 from(signal: Signal<bool>) -> Self

Converts this bool signal into an AttributeValue via string mapping.

Returns

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

Arguments

• Signal<bool> - Input value to convert from.

impl<T> Hash for Signal<T>

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

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Ord for Signal<T>

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

fn cmp(&self, other: &Signal<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl<T> PartialEq for Signal<T>

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

fn eq(&self, other: &Signal<T>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<T> PartialOrd for Signal<T>

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

fn partial_cmp(&self, other: &Signal<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> StructuralPartialEq for Signal<T>

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