Struct ExponentialBackoff 

pub struct ExponentialBackoff {
    pub initial_delay: Duration,
    pub max_delay: Duration,
    pub max_attempts: u32,
    pub multiplier: f64,
}

Exponential backoff retry policy.

Each retry waits exponentially longer than the previous one, up to a maximum delay. This is the recommended policy for most network operations.

Example

use error_rail::async_ext::ExponentialBackoff;
use core::time::Duration;

let policy = ExponentialBackoff {
    initial_delay: Duration::from_millis(100),
    max_delay: Duration::from_secs(10),
    max_attempts: 5,
    multiplier: 2.0,
};

// Delays: 100ms, 200ms, 400ms, 800ms, 1600ms (capped at 10s)

Fields

initial_delay: Duration

Initial delay before first retry.

max_delay: Duration

Maximum delay between retries.

max_attempts: u32

Maximum number of retry attempts.

multiplier: f64

Multiplier applied to delay after each attempt.

Implementations

impl ExponentialBackoff

pub fn new() -> Self

Creates a new exponential backoff policy with default settings.

pub fn with_initial_delay(self, delay: Duration) -> Self

Sets the initial delay.

pub fn with_max_delay(self, delay: Duration) -> Self

Sets the maximum delay.

pub fn with_max_attempts(self, attempts: u32) -> Self

Sets the maximum number of attempts.

pub fn with_multiplier(self, multiplier: f64) -> Self

Sets the multiplier.

Trait Implementations

impl Clone for ExponentialBackoff

fn clone(&self) -> ExponentialBackoff

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExponentialBackoff

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

Formats the value using the given formatter.

impl Default for ExponentialBackoff

fn default() -> Self

Returns the “default value” for a type.

impl RetryPolicy for ExponentialBackoff

fn next_delay(&mut self, attempt: u32) -> Option<Duration>

Returns the delay before the next retry attempt, or None to stop retrying.

fn reset(&mut self)

Resets the policy to its initial state.