Struct Task 

pub struct Task<T>(/* private fields */);

Task is a primitive that allows work to happen in the background.

It implements Future so you can .await on it.

If you drop a task it will be cancelled immediately. Calling Task::detach allows the task to continue running, but with no way to return a value.

Implementations

impl<T> Task<T>

pub fn ready(val: T) -> Task<T>

Creates a new task that will resolve with the value

pub fn from_async_task(task: Task<T, RunnableMeta>) -> Task<T>

Creates a Task from an async_task::Task

pub fn is_ready(&self) -> bool

pub fn detach(self)

Detaching a task runs it to completion in the background

pub fn fallible(self) -> FallibleTask<T>

Converts this task into a fallible task that returns Option<T>.

impl Task<Box<dyn Any + Sync + Send>>

pub fn downcast<T>(self) -> Task<T>

where T: Send + Sync + 'static,

Reinterprets the boxed output as a concrete T via downcast on completion. Used by LocalExecutor::spawn_dedicated and BackgroundExecutor::spawn_dedicated to recover the user closure’s Fut::Output from the dyn-safe Scheduler::spawn_dedicated.

Panics on poll if the inner output is not in fact a T – a logic error in whatever produced the inner task, since the downcast type is chosen by the caller of downcast.

Trait Implementations

impl<T> Debug for Task<T>

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

Formats the value using the given formatter.

impl<T> Future for Task<T>

where T: 'static,

type Output = T

The type of value produced on completion.

fn poll( self: Pin<&mut Task<T>>, cx: &mut Context<'_>, ) -> Poll<<Task<T> 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.

impl<T, E> TaskExt<T, E> for Task<Result<T, E>>

where T: 'static, E: 'static + Display + Debug,

fn detach_and_log_err(self, cx: &App)

Run the task to completion in the background and log any errors that occur.

fn detach_and_log_err_with_backtrace(self, cx: &App)

Like Self::detach_and_log_err, but uses {:?} formatting on failure so anyhow::Error values emit their full backtrace. Prefer detach_and_log_err unless a backtrace is wanted.