Struct DurableFuture 

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

A wrapper around scheduled futures that supports cancellation on drop.

When a DurableFuture is dropped without completing (e.g., as a select loser, or when going out of scope without being awaited), the underlying scheduled work is cancelled:

• Activities: Lock stealing via provider (removes from worker queue)
• Sub-orchestrations: CancelInstance work item enqueued for child
• Timers/External waits: No-op (virtual constructs with no external state)

Examples

// Activity scheduled - if timer wins, activity gets cancelled
let activity = ctx.schedule_activity("SlowWork", "input");
let timeout = ctx.schedule_timer(Duration::from_secs(5));

match ctx.select2(activity, timeout).await {
    duroxide::Either2::First(result) => result,
    duroxide::Either2::Second(()) => Err("Timed out - activity cancelled".to_string()),
}

Drop Semantics

Unlike regular Rust futures which are inert on drop, DurableFuture has meaningful drop semantics similar to File (closes on drop) or MutexGuard (releases lock on drop). This is intentional - we want unobserved scheduled work to be cancelled rather than leaked.

Note: Using std::mem::forget() on a DurableFuture will bypass cancellation, causing the scheduled work to run but its result to be lost.

Implementations

impl<T: Send + 'static> DurableFuture<T>

pub fn map<U: Send + 'static>( self, f: impl FnOnce(T) -> U + Send + 'static, ) -> DurableFuture<U>

Transform the output of this DurableFuture while preserving its identity for cancellation, join, and select composability.

The mapping function runs synchronously after the underlying future completes. Cancellation semantics are fully preserved: dropping the returned DurableFuture cancels the original scheduled work.

Example

// Map an activity result to extract a field
let length = ctx.schedule_activity("Greet", "World")
    .map(|r| r.map(|s| s.len().to_string()));
let len_result = length.await?;

pub fn with_tag(self, tag: impl Into<String>) -> Self

Set a routing tag on this scheduled activity.

Tags direct activities to specialized workers. A worker configured with crate::providers::TagFilter::tags(["gpu"]) will only process activities tagged "gpu".

This method uses mutate-after-emit: the action has already been emitted to the context’s action list, and with_tag reaches back to modify it in place. This is safe because actions are not drained until the replay engine polls the orchestration future (which hasn’t happened yet — we’re still inside the user’s async block).

Panics

Panics if called on a non-activity DurableFuture (e.g., timer or sub-orchestration).

Example

let result = ctx.schedule_activity("CompileRelease", "repo-url")
    .with_tag("build-machine")
    .await?;

Trait Implementations

impl<T> Drop for DurableFuture<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Future for DurableFuture<T>

type Output = T

The type of value produced on completion.

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

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

impl<T: Send> Send for DurableFuture<T>