Struct FailedWithContinuation 

pub struct FailedWithContinuation {
    pub source: Error,
    pub continuation: Arc<dyn Continuation + Send + Sync + 'static>,
}

Error type that signals a task failed but provided a continuation

This error type contains a continuation task that can be executed as a follow-up. The task defines its own continuation logic through the Continuation trait.

Fields

source: Error

The underlying error that caused the task to fail

continuation: Arc<dyn Continuation + Send + Sync + 'static>

The continuation task for follow-up execution

Implementations

impl FailedWithContinuation

pub fn new( source: Error, continuation: Arc<dyn Continuation + Send + Sync + 'static>, ) -> Self

Create a new FailedWithContinuation with a continuation task

The continuation task defines its own execution logic through the Continuation trait.

pub fn into_anyhow( source: Error, continuation: Arc<dyn Continuation + Send + Sync + 'static>, ) -> Error

Create a FailedWithContinuation and convert it to anyhow::Error

This is a convenience method for tasks to easily return continuation errors.

pub fn from_fn<F, Fut, T>(source: Error, f: F) -> Error

where F: Fn() -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<T, Error>> + Send + 'static, T: Send + 'static,

Create a FailedWithContinuation from a simple async function (no cancellation support)

This is a convenience method for creating continuation errors from simple async closures that don’t need to handle cancellation. The function will be executed when the continuation is triggered.

Example

let error = FailedWithContinuation::from_fn(
    anyhow!("Initial task failed"),
    || async {
        println!("Retrying operation...");
        Ok("retry_result".to_string())
    }
);

pub fn from_cancellable<F, Fut, T>(source: Error, f: F) -> Error

where F: Fn(CancellationToken) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<T, Error>> + Send + 'static, T: Send + 'static,

Create a FailedWithContinuation from a cancellable async function

This is a convenience method for creating continuation errors from async closures that can handle cancellation. The function receives a CancellationToken and should check it periodically for cooperative cancellation.

Example

let error = FailedWithContinuation::from_cancellable(
    anyhow!("Initial task failed"),
    |cancel_token| async move {
        if cancel_token.is_cancelled() {
            return Err(anyhow!("Cancelled"));
        }
        println!("Retrying operation with cancellation support...");
        Ok("retry_result".to_string())
    }
);

Trait Implementations

impl Debug for FailedWithContinuation

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

Formats the value using the given formatter.

impl Display for FailedWithContinuation

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

Formats the value using the given formatter.

impl Error for FailedWithContinuation

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.