Struct Effect 

pub struct Effect { /* private fields */ }

A side effect that runs when its dependencies change

Effects automatically track which signals they read and re-run when any of those signals change. This is the core of the reactive system.

Example

let count = signal(0);

// This effect automatically tracks `count` as a dependency
let _effect = Effect::new(move || {
    println!("Count: {}", count.get());
});

count.set(1); // Effect re-runs, prints "Count: 1"
count.set(2); // Effect re-runs, prints "Count: 2"

Thread Safety

Effect closures must be Send + Sync since Signals are now thread-safe. This is automatically satisfied when capturing Signals.

Implementations

impl Effect

pub fn new(f: impl Fn() + Send + Sync + 'static) -> Self

Create a new effect that runs immediately with automatic dependency tracking

pub fn lazy(f: impl Fn() + Send + Sync + 'static) -> Self

Create an effect without running immediately (lazy initialization)

pub fn run(&self)

Run the effect if active (manual run, also tracks dependencies)

pub fn stop(&self)

Stop the effect from running and clear its dependencies

pub fn resume(&self)

Resume the effect (will need to be run manually to re-establish dependencies)

pub fn is_active(&self) -> bool

Check if effect is active

pub fn id(&self) -> SubscriberId

Get the effect’s unique ID

Trait Implementations

impl Drop for Effect

fn drop(&mut self)

Executes the destructor for this type.