Struct UseAsyncHandle 

pub struct UseAsyncHandle<T, L = ()>
where
    T: Clone + PartialEq + 'static,
    L: Clone + PartialEq + HasLoadingHint + 'static,
{ /* private fields */ }

use_async’s reactive handle, stored in the hook context slot and returned to the user on each render.

The handle exposes three fields:

• state: the current AsyncState<T, L> (matches what the user should match on in html!).
• refetch: triggers the future to run again, regardless of whether the previous attempt completed or is still in flight.
• cancel: drops the in-flight future (if any) and prevents its Ok/Err branches from mutating the state. Subsequent renders will still call the future again on the next mount.

Cloning a handle is cheap — UseAsyncHandle is Copy if its generic parameters are. Use it from event handlers the same way you’d use a Signal<T>.

Implementations

impl<T, L> UseAsyncHandle<T, L>

where T: Clone + PartialEq + 'static, L: Clone + PartialEq + HasLoadingHint + 'static,

pub fn state(&self) -> AsyncState<T, L>

Returns the current reactive state.

pub fn refetch<F, Fut, E>(&self, factory: F)

where F: FnOnce() -> Fut + 'static, Fut: Future<Output = Result<T, E>> + 'static, E: Into<String> + 'static,

Re-runs the future, ignoring any in-flight result from a previous attempt.

Internally this sets a fresh cancel flag, transitions the state to Loading(L::empty()), and spawns the future. The existing in-flight future will see its cancel flag flipped and exit early.

The error type E is intentionally a free type parameter (rather than String or a dedicated AsyncError trait) so Result<T, JsValue>, Result<T, MyDomainError>, and Result<T, String> all work without an adapter layer.

Trait Implementations

impl<T, L> Clone for UseAsyncHandle<T, L>

where T: Clone + PartialEq + 'static + Clone, L: Clone + PartialEq + HasLoadingHint + 'static + Clone,

fn clone(&self) -> UseAsyncHandle<T, L>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, L> Copy for UseAsyncHandle<T, L>

where T: Clone + PartialEq + 'static + Copy, L: Clone + PartialEq + HasLoadingHint + 'static + Copy,

impl<T, L> Debug for UseAsyncHandle<T, L>

where T: Clone + PartialEq + 'static, L: Clone + PartialEq + HasLoadingHint + 'static,

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

Formats the value using the given formatter.

impl<T, L> Default for UseAsyncHandle<T, L>

where T: Clone + PartialEq + 'static, L: Clone + PartialEq + HasLoadingHint + 'static,

fn default() -> Self

Returns the “default value” for a type.