Struct leptos::Effect

pub struct Effect<T> { /* private fields */ }

A handle to an effect, can be used to explicitly dispose of the effect.

Implementations

impl<T> Effect<T>

where T: 'static,

pub fn new(f: impl Fn(Option<T>) -> T + 'static) -> Effect<T>

Effects run a certain chunk of code whenever the signals they depend on change. create_effect immediately runs the given function once, tracks its dependence on any signal values read within it, and reruns the function whenever the value of a dependency changes.

Effects are intended to run side-effects of the system, not to synchronize state within the system. In other words: don’t write to signals within effects. (If you need to define a signal that depends on the value of other signals, use a derived signal or create_memo).

The effect function is called with an argument containing whatever value it returned the last time it ran. On the initial run, this is None.

By default, effects do not run on the server. This means you can call browser-specific APIs within the effect function without causing issues. If you need an effect to run on the server, use create_isomorphic_effect.

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

// ✅ use effects to interact between reactive state and the outside world
Effect::new(move |_| {
  // immediately prints "Value: 0" and subscribes to `a`
  log::debug!("Value: {}", a.get());
});

a.set(1);
// ✅ because it's subscribed to `a`, the effect reruns and prints "Value: 1"

// ❌ don't use effects to synchronize state within the reactive system
Effect::new(move |_| {
  // this technically works but can cause unnecessary re-renders
  // and easily lead to problems like infinite loops
  b.set(a.get() + 1);
});

pub fn new_isomorphic(f: impl Fn(Option<T>) -> T + 'static) -> Effect<T>

Creates an effect; unlike effects created by create_effect, isomorphic effects will run on the server as well as the client.

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

// ✅ use effects to interact between reactive state and the outside world
Effect::new_isomorphic(move |_| {
  // immediately prints "Value: 0" and subscribes to `a`
  log::debug!("Value: {}", a.get());
});

a.set(1);
// ✅ because it's subscribed to `a`, the effect reruns and prints "Value: 1"

// ❌ don't use effects to synchronize state within the reactive system
Effect::new_isomorphic(move |_| {
  // this technically works but can cause unnecessary re-renders
  // and easily lead to problems like infinite loops
  b.set(a.get() + 1);
});

pub fn with_value_mut<U>( &self, f: impl FnOnce(&mut Option<T>) -> U ) -> Option<U>

Applies the given closure to the most recent value of the effect.

Because effect functions can return values, each time an effect runs it consumes its previous value. This allows an effect to store additional state (like a DOM node, a timeout handle, or a type that implements Drop) and keep it alive across multiple runs.

This method allows access to the effect’s value outside the effect function. The next time a signal change causes the effect to run, it will receive the mutated value.

Trait Implementations

impl<T> Clone for Effect<T>

where T: Clone,

fn clone(&self) -> Effect<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Effect<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Effect<T>

where T: Default,

fn default() -> Effect<T>

Returns the “default value” for a type.

impl<T> From<Effect<T>> for Disposer

fn from(effect: Effect<T>) -> Disposer

Converts to this type from the input type.

impl<T> Hash for Effect<T>

where T: Hash,

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

where __H: Hasher,

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> PartialEq for Effect<T>

where T: PartialEq,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> SignalDispose for Effect<T>

fn dispose(self)

Disposes of the signal. This:

impl<T> Copy for Effect<T>

where T: Copy,

impl<T> Eq for Effect<T>

where T: Eq,

impl<T> StructuralPartialEq for Effect<T>