Struct BisectSearch 

pub struct BisectSearch<E> { /* private fields */ }

Drives a bisect over n items: which range to probe next, and what each verdict means for the ranges still outstanding.

let mut search = BisectSearch::new(items.len(), BisectBudget::Auto);
while let Some(range) = search.next_range() {
    // The caller owns the operation — one shared transaction, or a fresh
    // one committed per range.
    let verdict = probe(&items[range.clone()]).await;
    search.report(range, verdict)?;
}
let outcomes = search.into_outcomes();

Implementations

impl<E> BisectSearch<E>

pub fn new(n: usize, budget: BisectBudget) -> Self

Starts a search over n items with the whole range as the first probe.

pub fn with_max_transient_retries(self, max: usize) -> Self

Overrides DEFAULT_MAX_TRANSIENT_RETRIES for this search.

pub fn next_range(&mut self) -> Option<Range<usize>>

The next range to probe: the largest outstanding one, earliest start breaking ties.

None when everything is resolved or the budget is spent — items still inside unprobed ranges resolve as ItemOutcome::Unresolved.

pub fn report( &mut self, range: Range<usize>, verdict: ProbeVerdict<E>, ) -> Result<(), TransientLimitExceeded>

Records what a probe found.

Errors once the transient allowance is exhausted, at which point the search is over — see TransientLimitExceeded.

pub fn probes_used(&self) -> usize

Probes spent so far, net of refunds.

pub fn transient_retries(&self) -> usize

Transient re-probes taken so far.

pub fn last_error(&self) -> Option<&E>

The most recent error from a probe spanning more than one item.

pub fn into_outcomes(self) -> BisectOutcomes<E>

Finishes the search, resolving anything still outstanding as ItemOutcome::Unresolved so every input gets exactly one outcome.

Trait Implementations

impl<E: Debug> Debug for BisectSearch<E>

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

Formats the value using the given formatter.