Struct Resource 

pub struct Resource<T>
where
    T: 'static,
{ /* private fields */ }

Declarative async data loading (§4.5): a TRACKED source whose value feeds an async fetcher; the result lands in a Signal<Load<T>>. The source re-runs when its tracked reads change; an unchanged source value refetches nothing, Resource::refetch always does. Latest wins: a source change supersedes the in-flight fetch (aborting its task — dropping any FetchFuture inside cancels the platform request) and a stale completion writes nothing. Scope disposal aborts the in-flight fetch the same way.

let stations = Resource::new(
    move || region.get(),                              // tracked: refetch on change
    |region| async move { fetch_stations(region).await },
);
when(move || stations.ready(), move || station_list(stations));

Implementations

impl<T> Resource<T>

where T: 'static,

pub fn new<S, Fut, E>( source: impl Fn() -> S + 'static, fetcher: impl Fn(S) -> Fut + 'static, ) -> Resource<T>

where S: Clone + PartialEq + 'static, Fut: Future<Output = Result<T, E>> + 'static, E: Error + Send + Sync + 'static,

Start loading: source runs tracked (its signal reads become dependencies) and its value moves into fetcher’s future, which runs on the main-loop executor via the installed spawner — so no Send bound anywhere, and the future may read/write signals after its awaits. Infallible fetchers use E = std::convert::Infallible.

pub fn signal(self) -> Signal<Load<T>>

The underlying state signal (tracked reads, when(move || …) guards, each sources).

pub fn get(self) -> Load<T>

where T: Clone,

The current load state (tracked).

pub fn with<R>(self, f: impl FnOnce(&Load<T>) -> R) -> R

Read the current load state by reference (tracked).

pub fn loading(self) -> bool

Whether a fetch is in flight (tracked).

pub fn ready(self) -> bool

Whether a value is ready (tracked) — when(move || r.ready(), …).

pub fn refetch(self)

Force a refetch with the current source value (even if unchanged).

Trait Implementations

impl<T> Clone for Resource<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Copy for Resource<T>