Struct Fallback 

pub struct Fallback<R, F, I, O>
where
    R: Runnable<I, O> + 'static,
    F: Runnable<I, O> + 'static,
    I: Clone + Send + 'static,
    O: Send + 'static,
{ /* private fields */ }

Runnable<I, O> adapter that falls back through a list of alternatives when the primary returns a classifier-approved transient error.

Cancellation is honoured between attempts — pulling the rug mid-sequence returns Error::Cancelled rather than continuing.

Implementations

impl<R, F, I, O> Fallback<R, F, I, O>

where R: Runnable<I, O> + 'static, F: Runnable<I, O> + 'static, I: Clone + Send + 'static, O: Send + 'static,

pub fn new(primary: R, fallbacks: Vec<F>) -> Self

Build with the primary and an ordered list of fallbacks. Empty fallbacks degrades to the primary alone — the adapter still type-checks and behaves identically to the inner.

pub fn with_classifier(self, classifier: Arc<dyn RetryClassifier>) -> Self

Override the classifier — useful when the operator has a stricter or laxer “transient” definition for fallback purposes than for retry purposes.

Trait Implementations

impl<R, F, I, O> Debug for Fallback<R, F, I, O>

where R: Runnable<I, O> + 'static, F: Runnable<I, O> + 'static, I: Clone + Send + 'static, O: Send + 'static,

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

Formats the value using the given formatter.

impl<R, F, I, O> Runnable<I, O> for Fallback<R, F, I, O>

where R: Runnable<I, O> + 'static, F: Runnable<I, O> + 'static, I: Clone + Send + 'static, O: Send + 'static,

fn invoke<'life0, 'life1, 'async_trait>( &'life0 self, input: I, ctx: &'life1 ExecutionContext, ) -> Pin<Box<dyn Future<Output = Result<O>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Single-shot invocation.

fn batch<'life0, 'life1, 'async_trait>( &'life0 self, inputs: Vec<I>, ctx: &'life1 ExecutionContext, ) -> Pin<Box<dyn Future<Output = Result<Vec<O>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Batch invocation. The default runs invoke sequentially over the input vector. Implementors that can parallelize (e.g. independent provider calls) override this.

fn stream<'life0, 'life1, 'async_trait>( &'life0 self, input: I, mode: StreamMode, ctx: &'life1 ExecutionContext, ) -> Pin<Box<dyn Future<Output = Result<BoxStream<'_, Result<StreamChunk<O>>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Streaming invocation, shaped by mode (see StreamMode).

fn name(&self) -> Cow<'_, str>

Human-readable identifier used by tracing and debug output. Default is the Rust type name — implementors may override with a domain label (e.g. "anthropic-messages", "json-parser").