Enum RetryError 

#[non_exhaustive]
pub enum RetryError<E> {
    Exhausted {
        attempts: u32,
        last_error: E,
    },
}

The error returned when a retried operation does not succeed.

It carries how many attempts were made and the last error the operation produced. There is intentionally no E: core::error::Error bound and no allocation: the failing value is moved in by value.

#[non_exhaustive]: new variants may be added in a future release, so match with a wildcard arm.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Exhausted

No further attempts will be made. This covers both running out of the allowed attempts and the retry predicate declining to retry: in either case attempts is the number of attempts actually made and last_error is the error from the final attempt.

Fields

attempts: u32

The number of attempts made (always >= 1).

last_error: E

The error returned by the final attempt.

Implementations

impl<E> RetryError<E>

pub fn attempts(&self) -> u32

The number of attempts that were made.

Examples found in repository

examples/basic_retry.rs (line 63)

fn main() {
    let policy = RetryPolicy::new(
        5,
        Backoff::exponential(Duration::from_millis(50), 2).with_max_delay(Duration::from_secs(1)),
    )
    .expect("max_attempts is non-zero");

    // An operation that fails twice with a temporary error, then succeeds.
    let mut attempt = 0;
    let result: Result<&str, RetryError<ApiError>> = retry_with_sleep(
        &policy,
        || {
            attempt += 1;
            println!("attempt {attempt}");
            if attempt < 3 {
                Err(ApiError::Temporary)
            } else {
                Ok("payload")
            }
        },
        |error| matches!(error, ApiError::Temporary), // retry only temporary errors
        |delay| {
            // You provide the waiting. In real code, call your platform or
            // runtime sleep here; this example only reports the delay so it
            // stays dependency-free and instant.
            println!("  would wait {delay:?} before the next attempt");
        },
    );
    match result {
        Ok(body) => println!("succeeded with: {body}"),
        Err(error) => println!("gave up: {error:?}"),
    }

    // A fatal error stops immediately, even though attempts remain.
    let mut attempt = 0;
    let result: Result<&str, RetryError<ApiError>> = retry_with_sleep(
        &policy,
        || {
            attempt += 1;
            Err(ApiError::Fatal)
        },
        |error| matches!(error, ApiError::Temporary),
        |_delay| {},
    );
    println!(
        "fatal path: stopped after {} attempt(s)",
        result.unwrap_err().attempts()
    );
}

pub fn last_error(&self) -> &E

A reference to the error returned by the final attempt.

pub fn into_last_error(self) -> E

Consumes the error and returns the final attempt’s error.

Trait Implementations

impl<E: Clone> Clone for RetryError<E>

fn clone(&self) -> RetryError<E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Copy> Copy for RetryError<E>

impl<E: Debug> Debug for RetryError<E>

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

Formats the value using the given formatter.

impl<E: Display> Display for RetryError<E>

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

Formats the value using the given formatter.

impl<E: Eq> Eq for RetryError<E>

impl<E: Error + 'static> Error for RetryError<E>

Available on crate feature std only.

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl<E: Hash> Hash for RetryError<E>

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<E: PartialEq> PartialEq for RetryError<E>

fn eq(&self, other: &RetryError<E>) -> bool

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

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<E> StructuralPartialEq for RetryError<E>