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.

Returns

• AsyncState<T, L> - The current AsyncState, owned.

pub fn set_state(&self, next: AsyncState<T, L>)

Overrides the slot’s state directly.

Bypasses the future machinery. Exists so the integration tests in core/tests/use_async/ can exercise the match arms produced by users without needing a live browser to run the future.

Arguments

• AsyncState<T, L> - A AsyncState<T, L> parameter.

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.

Arguments

• F: FnOnce() -> Fut + 'static - A generic type parameter.

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

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

pub fn get_inner(&self) -> &usize

pub fn get_mut_inner(&mut self) -> &mut usize

pub fn set_inner(&mut self, val: usize) -> &mut Self

pub fn get__marker(&self) -> &PhantomData<fn() -> (T, L)>

pub fn get_mut__marker(&mut self) -> &mut PhantomData<fn() -> (T, L)>

pub fn set__marker(&mut self, val: PhantomData<fn() -> (T, L)>) -> &mut Self

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 UseAsyncHandle via the supplied formatter.

Arguments

• &mut core::fmt::Formatter<'_> - The formatter receiving the formatted output.

Returns

• core::fmt::Result - Result of the formatting operation.

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

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

fn default() -> Self

Constructs a default UseAsyncHandle value.