Struct SpawnedTask 

pub struct SpawnedTask<R> { /* private fields */ }

Helper that provides a simple API to spawn a single task and join it. Provides guarantees of aborting on Drop to keep it cancel-safe. Note that if the task was spawned with spawn_blocking, it will only be aborted if it hasn’t started yet.

Technically, it’s just a wrapper of a JoinHandle overriding drop.

Implementations

impl<R> SpawnedTask<R>

where R: 'static,

pub fn spawn<T>(task: T) -> SpawnedTask<R>

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

pub fn spawn_blocking<T>(task: T) -> SpawnedTask<R>

where T: FnOnce() -> R + Send + 'static, R: Send,

pub async fn join(self) -> Result<R, JoinError>

Joins the task, returning the result of join (Result<R, JoinError>). Same as awaiting the spawned task, but left for backwards compatibility.

pub async fn join_unwind(self) -> Result<R, JoinError>

Joins the task and unwinds the panic if it happens.

pub async fn join_unwind_mut(&mut self) -> Result<R, JoinError>

Joins the task using a mutable reference and unwinds the panic if it happens.

This method is similar to join_unwind, but takes a mutable reference instead of consuming self. This allows the SpawnedTask to remain usable after the call.

If called multiple times on the same task:

• If the task is still running, it will continue waiting for completion
• If the task has already completed successfully, subsequent calls will continue to return the same JoinError indicating the task is finished
• If the task panicked, the first call will resume the panic, and the program will not reach subsequent calls

Trait Implementations

impl<R> Debug for SpawnedTask<R>

where R: Debug,

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

Formats the value using the given formatter.

impl<R> Drop for SpawnedTask<R>

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<R> Future for SpawnedTask<R>

type Output = Result<R, JoinError>

The type of value produced on completion.

fn poll( self: Pin<&mut SpawnedTask<R>>, cx: &mut Context<'_>, ) -> Poll<<SpawnedTask<R> as Future>::Output>

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