Struct ImmediateEffect 

pub struct ImmediateEffect { /* private fields */ }

Effects run a certain chunk of code whenever the signals they depend on change.

The effect runs on creation and again as soon as any tracked signal changes.

NOTE: you probably want use Effect instead. This is for the few cases where it’s important to execute effects immediately and in order.

ImmediateEffects stop running when dropped.

NOTE: since effects are executed immediately, they might recurse. Under recursion or parallelism only the last run to start is tracked.

Example

let a = RwSignal::new(0);
let b = RwSignal::new(0);

// ✅ use effects to interact between reactive state and the outside world
let _drop_guard = ImmediateEffect::new(move || {
  // on the next “tick” prints "Value: 0" and subscribes to `a`
  println!("Value: {}", a.get());
});

// The effect runs immediately and subscribes to `a`, in the process it prints "Value: 0"
a.set(1);
// ✅ because it's subscribed to `a`, the effect reruns and prints "Value: 1"

Notes

1. Scheduling: Effects run immediately, as soon as any tracked signal changes.
2. By default, effects do not run unless the effects feature is enabled. If you are using this with a web framework, this generally means that effects do not run on the server. and you can call browser-specific APIs within the effect function without causing issues. If you need an effect to run on the server, use ImmediateEffect::new_isomorphic.

Implementations

impl ImmediateEffect

pub fn new(fun: impl Fn() + Send + Sync + 'static) -> ImmediateEffect

Creates a new effect which runs immediately, then again as soon as any tracked signal changes. (Unless batch is used.)

NOTE: this requires a Fn function because it might recurse. Use Self::new_mut to pass a FnMut function, it’ll panic on recursion.

pub fn new_mut(fun: impl FnMut() + Send + Sync + 'static) -> ImmediateEffect

Creates a new effect which runs immediately, then again as soon as any tracked signal changes. (Unless batch is used.)

Panics

Panics on recursion or if triggered in parallel. Also see Self::new

pub fn new_scoped(fun: impl Fn() + Send + Sync + 'static)

Creates a new effect which runs immediately, then again as soon as any tracked signal changes. (Unless batch is used.)

NOTE: this requires a Fn function because it might recurse. Use Self::new_mut_scoped to pass a FnMut function, it’ll panic on recursion. NOTE: this effect is automatically cleaned up when the current owner is cleared or disposed.

pub fn new_mut_scoped(fun: impl FnMut() + Send + Sync + 'static)

Creates a new effect which runs immediately, then again as soon as any tracked signal changes. (Unless batch is used.)

NOTE: this effect is automatically cleaned up when the current owner is cleared or disposed.

Panics

Panics on recursion or if triggered in parallel. Also see Self::new_scoped

pub fn new_isomorphic(fun: impl Fn() + Send + Sync + 'static) -> ImmediateEffect

Creates a new effect which runs immediately, then again as soon as any tracked signal changes.

This will run whether the effects feature is enabled or not.

Trait Implementations

impl Clone for ImmediateEffect

fn clone(&self) -> ImmediateEffect

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ImmediateEffect

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

Formats the value using the given formatter.

impl DefinedAt for ImmediateEffect

fn defined_at(&self) -> Option<&'static Location<'static>>

Returns the location at which the signal was defined. This is usually simply None in release mode.

impl Dispose for ImmediateEffect

fn dispose(self)

Disposes of the signal. This:

impl ToAnySubscriber for ImmediateEffect

fn to_any_subscriber(&self) -> AnySubscriber

Converts this type to its type-erased equivalent.