Struct fuchsia_async::Task

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

A handle to a future that is owned and polled by the executor.

Once a task is created, the executor will poll it until done, even if the task handle itself is not polled.

When a task is dropped its future will no longer be polled by the executor. See Task::cancel for cancellation semantics.

Polling (or attempting to extract the value from) a task after the executor is dropped may trigger a panic.

Implementations

impl Task<()>

pub fn detach(self)

Detach this task so that it can run independently in the background.

Note: this is usually not what you want. This API severs the control flow from the caller, making it impossible to return values (including errors). If your goal is to run multiple futures concurrently, consider using [TaskGroup] or other futures combinators such as:

• [futures::future::join]
• [futures::future::select]
• [futures::select]

or their error-aware variants

• [futures::future::try_join]
• [futures::future::try_select]

or their stream counterparts

• [futures::stream::StreamExt::for_each]
• [futures::stream::StreamExt::for_each_concurrent]
• [futures::stream::TryStreamExt::try_for_each]
• [futures::stream::TryStreamExt::try_for_each_concurrent]

can meet your needs.

impl<T: Send> Task<T>

pub fn spawn(future: impl Future<Output = T> + Send + 'static) -> Task<T>

Spawn a new task on the current executor.

The task may be executed on any thread(s) owned by the current executor. See Task::local for an equivalent that ensures locality.

The passed future will live until either (a) the future completes, (b) the returned Task is dropped while the executor is running, or (c) the executor is destroyed; whichever comes first.

Panics

spawn may panic if not called in the context of an executor (e.g. within a call to run or run_singlethreaded).

impl<T> Task<T>

pub fn local(future: impl Future<Output = T> + 'static) -> Task<T>

Spawn a new task on the thread local executor.

The passed future will live until either (a) the future completes, (b) the returned Task is dropped while the executor is running, or (c) the executor is destroyed; whichever comes first.

NOTE: This is not supported with a [SendExecutor] and will cause a runtime panic. Use Task::spawn instead.

Panics

local may panic if not called in the context of a local executor (e.g. within a call to run or run_singlethreaded).

impl<T: 'static> Task<T>

pub async fn cancel(self) -> Option<T>

Initiate cancellation of this task.

Returns the tasks output if it was available prior to cancelation.

NOTE: If None is returned, the underlying future may continue executing for a short period before getting dropped. If so, do not assume any resources held by the task’s future are released. If Some(..) is returned, such resources are guaranteed to be released.

Trait Implementations

impl<T: Debug> Debug for Task<T>

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

Formats the value using the given formatter.

impl<T: 'static> Future for Task<T>

type Output = T

The type of value produced on completion.

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

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