Struct PreflightHandle 

pub struct PreflightHandle<T> { /* private fields */ }

A future-of-T that has been spawned onto the runtime ahead of time. The chain calls .await only when it actually needs the artifact — typically after a cheaper solver has failed.

Implements Future so callers use it identically to a non-speculative future. Drop = cancel.

Implementations

impl<T> PreflightHandle<T>

where T: Send + 'static,

pub fn spawn<F>(fut: F) -> Self

where F: Future<Output = T> + Send + 'static,

Spawn fut onto the current tokio runtime and return a handle the chain can .await later.

Panics if called outside a tokio runtime — same constraint as tokio::spawn. The chain always runs inside one.

pub fn cancel(self)

Cancel the in-flight task without awaiting its result. Idempotent — second call is a no-op. Useful when the chain learns it doesn’t need the artifact (cheap solver won) before the natural drop point.

pub fn is_finished(&self) -> bool

True iff the spawned task has finished — useful for “should I bother awaiting, or is the artifact already here?” telemetry checks. Not load-bearing for correctness.

Trait Implementations

impl<T> Drop for PreflightHandle<T>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<T> Future for PreflightHandle<T>

where T: Send + 'static,

type Output = Result<T, PreflightError>

Result<T, PreflightError> so callers can distinguish “the spawn task panicked” from “T was an error”. For captchaforge’s use case, T is itself usually a Result, so the user sees nested Results — that’s the price of preserving the panic vs business-error distinction.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.