Enum Async

pub enum Async<T: Clone> {
    Uninitialized,
    Loading {
        value: Option<T>,
    },
    Success {
        value: T,
    },
    Fail {
        error: AsyncError,
        value: Option<T>,
    },
}

Represents the state of an asynchronous operation with its possible outcomes.

Async<T> is a generic enum that encapsulates the different states an asynchronous operation can be in, including uninitialized, loading, success, and failure states. It provides a uniform way to represent and handle asynchronous state in a reactive application.

The type parameter T represents the successful result type of the operation.

Variants

Uninitialized

The initial state before any operation has been attempted.

Loading

The operation is in progress. May optionally contain the previous value.

Fields

value: Option<T>

Success

The operation completed successfully with a result value.

Fields

value: T

Fail

The operation failed. Contains an error and optionally the previous value.

Fields

error: AsyncError

value: Option<T>

Implementations

impl<T: Clone> Async<T>

pub fn is_complete(&self) -> bool

Returns true if the operation has completed (either successfully or with an error).

pub fn should_load(&self) -> bool

Returns true if the operation should be (re)loaded.

This is typically true when the state is either uninitialized or in a failed state.

pub fn is_incomplete(&self) -> bool

Returns true if the operation has not yet completed.

This is true when the state is either uninitialized or currently loading.

pub fn is_uninitialized(&self) -> bool

Returns true if the operation has not been started.

pub fn is_loading(&self) -> bool

Returns true if the operation is currently in progress.

pub fn is_success(&self) -> bool

Returns true if the operation completed successfully.

pub fn is_fail(&self) -> bool

Returns true if the operation failed.

pub fn is_fail_with_error(&self) -> bool

Returns true if the operation failed with a general error.

pub fn is_fail_with_none(&self) -> bool

Returns true if the operation failed because it returned None.

pub fn is_fail_with_canceled(&self) -> bool

Returns true if the operation failed because it was cancelled.

pub fn is_fail_with_timeout(&self) -> bool

Returns true if the operation failed because it timed out.

pub fn value(self) -> Option<T>

Consumes the Async and returns the contained value if available.

This method extracts the value from any variant that might contain it:

• Success variant returns Some(value)
• Loading variant with a retained value returns Some(value)
• Fail variant with a retained value returns Some(value)
• Otherwise returns None

pub fn value_ref(&self) -> Option<&T>

Returns a reference to the contained value if available.

Similar to value() but returns a reference instead of consuming the Async.

pub fn value_ref_clone(self: &Async<T>) -> Option<T>

Returns a clone of the contained value if available.

This method is similar to value_ref() but returns a clone of the value rather than a reference.

pub fn set_retain_value(self, value: Option<T>) -> Self

Sets or updates the retained value in Loading or Fail states.

This method is useful when you want to update the retained value without changing the state itself.

pub fn loading(value: Option<T>) -> Self

Creates a new Async in the Loading state.

Optionally includes a retained value from a previous operation.

pub fn success(value: T) -> Self

Creates a new Async in the Success state with the provided value.

pub fn fail(error: AsyncError, value: Option<T>) -> Self

Creates a new Async in the Fail state with the provided error and optional retained value.

pub fn fail_with_cancelled(value: Option<T>) -> Self

Creates a new Async in the Fail state with a cancellation error.

pub fn fail_with_timeout(value: Option<T>) -> Self

Creates a new Async in the Fail state with a timeout error.

pub fn fail_with_message(message: impl Into<String>, value: Option<T>) -> Self

Creates a new Async in the Fail state with a general error message.

pub fn fail_with_none(value: Option<T>) -> Self

Creates a new Async in the Fail state with a None error.

Trait Implementations

impl<T: Clone + Clone> Clone for Async<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Clone> Debug for Async<T>

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

Formats the value using the given formatter.

impl<T: Clone> Default for Async<T>

fn default() -> Async<T>

Returns the “default value” for a type.

impl<T: Hash + Clone> Hash for Async<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq + Clone> PartialEq for Async<T>

fn eq(&self, other: &Async<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq + Clone> Eq for Async<T>

impl<T: Clone> StructuralPartialEq for Async<T>