Struct Jittered 

pub struct Jittered<W> { /* private fields */ }

Applies jitter to an inner wait strategy’s output.

Created by calling .jitter(max), .full_jitter(), or .equal_jitter() on any wait strategy.

Jitter uses a fast PRNG intended for retry backoff behavior, not for cryptographic use. Cloning a Jittered strategy produces a decorrelated copy — the clone will generate a different jitter sequence.

Examples

use relentless::{RetryState, Wait, wait};
use core::time::Duration;

// Additive jitter: base + random(0, max_jitter)
let strategy = wait::fixed(Duration::from_millis(50))
    .jitter(Duration::from_millis(10));
let state = RetryState::new(1, None);

let next = strategy.next_wait(&state);
assert!(next >= Duration::from_millis(50));
assert!(next <= Duration::from_millis(60));

use relentless::{RetryState, Wait, wait};
use core::time::Duration;

// Full jitter: random(0, base)
let strategy = wait::fixed(Duration::from_millis(100))
    .full_jitter();
let state = RetryState::new(1, None);

let next = strategy.next_wait(&state);
assert!(next <= Duration::from_millis(100));

use relentless::{RetryState, Wait, wait};
use core::time::Duration;

// Equal jitter: base/2 + random(0, base/2)
let strategy = wait::fixed(Duration::from_millis(100))
    .equal_jitter();
let state = RetryState::new(1, None);

let next = strategy.next_wait(&state);
assert!(next >= Duration::from_millis(50));
assert!(next <= Duration::from_millis(100));

Implementations

impl<W> Jittered<W>

pub fn with_seed(self, seed: u64) -> Self

Sets an explicit PRNG seed for reproducible jitter sequences.

Combine with with_nonce to fully pin the PRNG state for deterministic testing.

pub fn with_nonce(self, nonce: u64) -> Self

Overrides the instance-decorrelation nonce.

By default, each Jittered instance (including clones) receives a unique nonce so independent retry loops produce different jitter sequences. Set an explicit nonce when you need deterministic output, such as in tests.

Trait Implementations

impl<W: Wait, Rhs: Wait> Add<Rhs> for Jittered<W>

type Output = WaitCombine<Jittered<W>, Rhs>

The resulting type after applying the + operator.

fn add(self, rhs: Rhs) -> Self::Output

Performs the + operation.

impl<W: Clone> Clone for Jittered<W>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<W: Debug> Debug for Jittered<W>

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

Formats the value using the given formatter.

impl<W: Wait> Wait for Jittered<W>

fn next_wait(&self, state: &RetryState) -> Duration

Returns the duration to sleep before the next retry attempt.

fn cap(self, max: Duration) -> WaitCapped<Self>

where Self: Sized,

Clamps the returned duration to at most max.

fn chain<W2: Wait>(self, other: W2, after: u32) -> WaitChain<Self, W2>

where Self: Sized,

Uses this strategy for the first after attempts, then switches to other.

fn add<W2: Wait>(self, other: W2) -> WaitCombine<Self, W2>

where Self: Sized,

Adds another wait strategy to this one.

fn jitter(self, max_jitter: Duration) -> Jittered<Self>

where Self: Sized,

Adds uniformly distributed jitter in [0, max_jitter].

fn full_jitter(self) -> Jittered<Self>

where Self: Sized,

Replaces the computed delay with a random value in [0, base].

fn equal_jitter(self) -> Jittered<Self>

where Self: Sized,

Keeps half the computed delay and jitters the other half.