Struct reactive_graph::computed::AsyncDerived

pub struct AsyncDerived<T, S = SyncStorage> { /* private fields */ }

A reactive value that is derived by running an asynchronous computation in response to changes in its sources.

When one of its dependencies changes, this will re-run its async computation, then notify other values that depend on it that it has changed.

This is an arena-allocated type, which is Copy and is disposed when its reactive Owner cleans up. For a reference-counted signal that livesas as long as a reference to it is alive, see ArcAsyncDerived.

Examples

let signal1 = RwSignal::new(0);
let signal2 = RwSignal::new(0);
let derived = AsyncDerived::new(move || async move {
  // reactive values can be tracked anywhere in the `async` block
  let value1 = signal1.get();
  tokio::time::sleep(std::time::Duration::from_millis(25)).await;
  let value2 = signal2.get();

  value1 + value2
});

// the value can be accessed synchronously as `Option<T>`
assert_eq!(derived.get(), None);
// we can also .await the value, i.e., convert it into a Future
assert_eq!(derived.await, 0);
assert_eq!(derived.get(), Some(0));

signal1.set(1);
// while the new value is still pending, the signal holds the old value
tokio::time::sleep(std::time::Duration::from_millis(5)).await;
assert_eq!(derived.get(), Some(0));

// setting multiple dependencies will hold until the latest change is ready
signal2.set(1);
assert_eq!(derived.await, 2);

Core Trait Implementations

• .get() clones the current value as an Option<T>. If you call it within an effect, it will cause that effect to subscribe to the memo, and to re-run whenever the value of the memo changes.
  • .get_untracked() clones the value of without reactively tracking it.
• .read() returns a guard that allows accessing the value by reference. If you call it within an effect, it will cause that effect to subscribe to the memo, and to re-run whenever the value changes.
  • .read_untracked() gives access to the current value without reactively tracking it.
• .with() allows you to reactively access the value without cloning by applying a callback function.
  • .with_untracked() allows you to access the value by applying a callback function without reactively tracking it.
• IntoFuture allows you to create a Future that resolves when this resource is done loading.

Implementations

impl<T> AsyncDerived<T>

where T: 'static,

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

where T: Send + Sync + 'static, Fut: Future<Output = T> + Send + 'static,

Creates a new async derived computation.

This runs eagerly: i.e., calls fun once when created and immediately spawns the Future as a new task.

pub fn new_with_initial<Fut>( initial_value: Option<T>, fun: impl Fn() -> Fut + Send + Sync + 'static, ) -> Self

where T: Send + Sync + 'static, Fut: Future<Output = T> + Send + 'static,

Creates a new async derived computation with an initial value.

If the initial value is Some(_), the task will not be run initially.

impl<T> AsyncDerived<T, LocalStorage>

where T: 'static,

pub fn new_unsync<Fut>(fun: impl Fn() -> Fut + 'static) -> Self

where T: 'static, Fut: Future<Output = T> + 'static,

Creates a new async derived computation that will be guaranteed to run on the current thread.

This runs eagerly: i.e., calls fun once when created and immediately spawns the Future as a new task.

pub fn new_unsync_with_initial<Fut>( initial_value: Option<T>, fun: impl Fn() -> Fut + 'static, ) -> Self

where T: 'static, Fut: Future<Output = T> + 'static,

Creates a new async derived computation with an initial value. Async work will be guaranteed to run only on the current thread.

If the initial value is Some(_), the task will not be run initially.

impl<T, S> AsyncDerived<T, S>

where T: 'static, S: Storage<ArcAsyncDerived<T>>,

pub fn ready(&self) -> AsyncDerivedReadyFuture

Returns a Future that is ready when this resource has next finished loading.

impl<T, S> AsyncDerived<T, S>

where T: 'static, S: Storage<ArcAsyncDerived<T>>,

pub fn by_ref(&self) -> AsyncDerivedRefFuture<T>

Returns a Future that resolves when the computation is finished, and accesses the inner value by reference rather than by cloning it.

Trait Implementations

impl<T, S> Clone for AsyncDerived<T, S>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, S> Debug for AsyncDerived<T, S>

where S: Debug,

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

Formats the value using the given formatter.

impl<T, S> DefinedAt for AsyncDerived<T, S>

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<T, S> Dispose for AsyncDerived<T, S>

fn dispose(self)

Disposes of the signal. This:

impl<T> From<ArcAsyncDerived<T>> for AsyncDerived<T>

where T: Send + Sync + 'static,

fn from(value: ArcAsyncDerived<T>) -> Self

Converts to this type from the input type.

impl<T> FromLocal<ArcAsyncDerived<T>> for AsyncDerived<T, LocalStorage>

where T: 'static,

fn from_local(value: ArcAsyncDerived<T>) -> Self

Converts between the types.

impl<T, S> IntoFuture for AsyncDerived<T, S>

where T: Clone + 'static, S: Storage<ArcAsyncDerived<T>>,

type Output = T

The output that the future will produce on completion.

type IntoFuture = AsyncDerivedFuture<T>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl<T, S> ReactiveNode for AsyncDerived<T, S>

where T: 'static, S: Storage<ArcAsyncDerived<T>>,

fn mark_dirty(&self)

Notifies the source’s dependencies that it has changed.

fn mark_check(&self)

Notifies the source’s dependencies that it may have changed.

fn mark_subscribers_check(&self)

Marks that all subscribers need to be checked.

fn update_if_necessary(&self) -> bool

Regenerates the value for this node, if needed, and returns whether it has actually changed or not.

impl<T, S> ReadUntracked for AsyncDerived<T, S>

where T: 'static, S: Storage<ArcAsyncDerived<T>>,

type Value = ReadGuard<Option<T>, AsyncPlain<Option<T>>>

The guard type that will be returned, which can be dereferenced to the value.

fn try_read_untracked(&self) -> Option<Self::Value>

Returns the guard, or None if the signal has already been disposed.

fn read_untracked(&self) -> Self::Value

Returns the guard.

impl<T, S> Source for AsyncDerived<T, S>

where T: 'static, S: Storage<ArcAsyncDerived<T>>,

fn add_subscriber(&self, subscriber: AnySubscriber)

Adds a subscriber to this source’s list of dependencies.

fn remove_subscriber(&self, subscriber: &AnySubscriber)

Removes a subscriber from this source’s list of dependencies.

fn clear_subscribers(&self)

Remove all subscribers from this source’s list of dependencies.

impl<T, S> Subscriber for AsyncDerived<T, S>

where T: 'static, S: Storage<ArcAsyncDerived<T>>,

fn add_source(&self, source: AnySource)

Adds a subscriber to this subscriber’s list of dependencies.

fn clear_sources(&self, subscriber: &AnySubscriber)

Clears the set of sources for this subscriber.

impl<T, S> ToAnySource for AsyncDerived<T, S>

where T: 'static, S: Storage<ArcAsyncDerived<T>>,

fn to_any_source(&self) -> AnySource

Converts this type to its type-erased equivalent.

impl<T, S> ToAnySubscriber for AsyncDerived<T, S>

where T: 'static, S: Storage<ArcAsyncDerived<T>>,

fn to_any_subscriber(&self) -> AnySubscriber

Converts this type to its type-erased equivalent.

impl<T, S> Copy for AsyncDerived<T, S>