Enum Error 

#[non_exhaustive]
pub enum Error {
    Message(String),
    Request(Error),
    UnexpectedResponse(String),
    EzError(Box<EzError>),
    PollingExhausted {
        task_id: String,
        attempts: usize,
        interval: Duration,
    },
    WaitInterrupted {
        task_id: String,
        request_id: Option<String>,
        source: Box<Error>,
    },
    SolutionDecode {
        source: Error,
        raw: Box<Value>,
    },
}

Errors produced by request construction, HTTP transport, API responses, and polling.

This enum is #[non_exhaustive]: new variants may be added in future minor releases, so downstream matches must include a wildcard arm.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Message(String)

A failure whose only useful detail is its description.

An invalid client configuration arrives here today. Anything a caller would react to programmatically gets a variant of its own instead, so this one is meant to be printed rather than matched on.

Request(Error)

Available on crate features async or blocking only.

The HTTP request failed.

Wraps the underlying reqwest::Error, whose is_timeout, is_connect, and status methods classify the failure.

UnexpectedResponse(String)

The response could not be used, either because it did not decode or because it violated the API contract.

A ready result carrying no solution field lands here too: the task was billed and the answer is gone, which is a broken contract rather than a category of its own. Solution::is_missing still tells that case apart from a solution that was present and null.

EzError(Box<EzError>)

The API reported an error.

This covers both a structured business error and any non-success HTTP status, so EzError::http_status is always available here.

PollingExhausted

Polling ended before the task reached a terminal state.

Fields

task_id: String

Task identifier.

attempts: usize

Number of completed result queries.

interval: Duration

Delay configured between queries.

WaitInterrupted

The task was created and billed, but waiting for its result failed.

solve creates the task internally, so the identifier never reaches the caller on its own. A failure that dropped it would leave a paid-for result unreachable — hence this variant, whose whole purpose is to carry the identifier out.

Recover by waiting on the same task again rather than creating a second one: the service holds a result for five minutes after creation, and a new task is billed again. Errors that already carry the identifier themselves are left alone, so a business error still arrives as Self::EzError and an exhausted budget as Self::PollingExhausted.

Fields

task_id: String

Identifier of the task that was created and billed.

request_id: Option<String>

Request identifier returned by task creation.

source: Box<Error>

The failure that interrupted the wait.

SolutionDecode

A raw solution could not be converted into the requested type.

The raw value travels with the error: a decode failure means the worker returned a shape this release does not model, and that shape is exactly what is needed to diagnose it. The convenience methods consume the task result, so this is the only place it survives.

Fields

source: Error

JSON decoding error.

raw: Box<Value>

Raw solution value that failed to decode, preserved in full.

Implementations

impl Error

pub fn task_id(&self) -> Option<&str>

Returns the identifier of a task that was created and billed, when this failure left one behind.

Creating a task is what costs money, so a failure after that point leaves a result worth recovering: wait on this identifier again with wait_for_result instead of creating a second task. The service holds a result for five minutes after creation.

None means nothing was billed — the failure happened before or during task creation, so there is nothing to recover.

Which variant the identifier is stored on is an implementation detail; this is the one place to ask.

if let Some(task_id) = error.task_id() {
    // The task is still on the service. Waiting again is free.
    eprintln!("recover with wait_for_result({task_id})");
}

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

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

Provides type-based access to context intended for error reports.

impl From<Error> for Error

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<EzError> for Error

fn from(error: EzError) -> Self

Converts to this type from the input type.