Struct Resource 

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

A reactive resource that automatically fetches data when its dependencies change.

Resource provides a way to reactively fetch data from async operations and automatically refetch when the input dependencies change. It manages loading states and ensures that only the most recent result is kept if multiple async operations complete rapidly.

Concurrency Behavior

If multiple async operations complete while the main thread is busy processing other work, only the most recent result is kept.

Examples

// Simple case: event loop executor, hash-based memoization, returns Option<T>
let resource = Resource::new(|| user_id.get(), |id| fetch_user(id));

// With initial value
let resource = Resource::with_initial(
    || user_id.get(),
    |id| fetch_user(id),
    User::default()
);

// Full customization
let resource = Resource::custom(|| user_id.get(), |id| fetch_user(id))
    .executor(my_executor)
    .key_fn(|id| *id)
    .initial(User::default())
    .build();

Implementations

impl<T: 'static> Resource<T>

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

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

Creates a new reactive resource with sensible defaults.

• Executor: Main event loop (future does not need to be Send)
• Memoization: Hash-based (only refetches when dependency hash changes)
• Initial value: None (returns Resource<Option<U>>)

Parameters

• source - A function that returns the current dependency value(s).
• fetcher - An async function that takes the dependency value and returns the fetched data.

Examples

let user_resource = Resource::new(
    || user_id.get(),
    |id| async move { fetch_user(id).await }
);

pub fn with_initial<Fut, Dep>( source: impl Fn() -> Dep + 'static, fetcher: impl Fn(Dep) -> Fut + 'static, initial: T, ) -> Self

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

Creates a new reactive resource with an initial value.

Uses the same defaults as new() but allows you to specify an initial value so the resource is never None.

• Executor: Main event loop (future does not need to be Send)
• Memoization: Hash-based (only refetches when dependency hash changes)

Parameters

• source - A function that returns the current dependency value(s).
• fetcher - An async function that takes the dependency value and returns the fetched data.
• initial - The initial value for the resource before any fetch completes.

Examples

let user_resource = Resource::with_initial(
    || user_id.get(),
    |id| async move { fetch_user(id).await },
    User::default()
);

pub fn custom<Fut, Dep>( source: impl Fn() -> Dep + 'static, fetcher: impl Fn(Dep) -> Fut + 'static, ) -> ResourceBuilder<Fut, Dep, T, DefaultHashKeyFn, EventLoopExecutor, WithMemo, NoInitial>

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

Creates a resource builder for full customization.

Use this when you need to customize:

• The executor (tokio, custom, etc.)
• The key function (custom comparison logic)
• Memoization behavior (disable with .no_memo())
• Initial value

Examples

// Tokio executor with custom key function
let resource = Resource::custom(|| user_id.get(), |id| fetch_user(id))
    .tokio_spawn()
    .key_fn(|id| *id)
    .build();

// Disable memoization
let resource = Resource::custom(|| (), || fetch_latest())
    .no_memo()
    .build();

pub fn refetch(&self)

Manually triggers a refetch of the resource, bypassing memoization.

This will start a new async fetch operation using the current dependency value, even if that value hasn’t changed since the last fetch.

Behavior

• Sets the finished state to false
• Spawns a new fetch operation
• Bypasses memoization for this fetch

pub fn is_loading(&self) -> bool

where T: 'static,

Returns true if an async fetch operation is currently in progress.

This can be used to show loading indicators in the UI.

Trait Implementations

impl<T> Clone for Resource<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Clone + 'static> SignalGet<T> for Resource<T>

fn id(&self) -> ReactiveId

get the Signal Id

fn get_untracked(&self) -> T

where T: 'static,

fn get(&self) -> T

where T: 'static,

fn try_get(&self) -> Option<T>

where T: 'static,

fn try_get_untracked(&self) -> Option<T>

where T: 'static,

impl<T> SignalRead<T> for Resource<T>

fn id(&self) -> ReactiveId

get the Signal Id

fn try_read(&self) -> Option<ReadRef<'_, T>>

where T: 'static,

If the signal isn’t disposed, reads the data stored in the Signal and subscribes to the current running effect.

fn try_read_untracked(&self) -> Option<ReadRef<'_, T>>

where T: 'static,

If the signal isn’t disposed, reads the data stored in the Signal without subscribing.

fn read(&self) -> ReadRef<'_, T>

where T: 'static,

Reads the data stored in the Signal, subscribing the current running effect.

fn read_untracked(&self) -> ReadRef<'_, T>

where T: 'static,

Reads the data stored in the Signal without subscribing.

impl<T: 'static> SignalTrack<T> for Resource<T>

fn id(&self) -> ReactiveId

fn track(&self)

Only subscribes to the current running effect to this Signal.

fn try_track(&self)

If the signal isn’t disposed,

impl<T> SignalWith<T> for Resource<T>

fn id(&self) -> ReactiveId

get the Signal Id

fn with<O>(&self, f: impl FnOnce(&T) -> O) -> O

where T: 'static,

fn with_untracked<O>(&self, f: impl FnOnce(&T) -> O) -> O

where T: 'static,

fn try_with<O>(&self, f: impl FnOnce(Option<&T>) -> O) -> O

where T: 'static,

fn try_with_untracked<O>(&self, f: impl FnOnce(Option<&T>) -> O) -> O

where T: 'static,

impl<T> Copy for Resource<T>