Struct twizzler_async::Task

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

A spawned future. Tasks are futures themselves and yield the output of the spawned future.

When a task is dropped, it is automatically canceled and it won’t be polled again. You can also cancel a task explicitly with the cancel() method.

Tasks that panic are immediately canceled, and awaiting a canceled task causes a panic. If the future panics, the panic will be unwound into the run() invocation that polled it, but this doesn’t apply to the blocking executor, which will simply ignore panics and continue running.

Implementations

impl<T: 'static> Task<T>

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

Spawns a future onto the thread-local executor.

Panics if the current thread is not inside an invocation of run().

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

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

Spawns a future onto the global executor.

This future may be stolen and polled by any thread calling run(), and thus the future (and its output) must be Send.

impl<T, E> Task<Result<T, E>>where T: Send + 'static, E: Debug + Send + 'static,

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

Spawns a new task and awaits and unwraps the result.

pub fn expect(self, msg: &str) -> Task<T>

Spawns a new task and awaits and unwraps the result, panicing with the provided message if the unwrap fails.

impl Task<()>

pub fn detach(self)

Detach the task and let it run in the background.

Examples

use std::time::Duration;

use twizzler_async::{Task, Timer};

Task::spawn(async {
    loop {
        println!("I'm a daemon task looping forever.");
        Timer::after(Duration::from_secs(1)).await;
    }
})
.detach();

impl<T> Task<T>

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

Cancels the task and waits for it to stop running. If the task completed before canceling, return the task’s output, or None if it wasn’t complete. The advantage of calling cancel() explicitly over jus dropping the task is that it, one, waits for the task to stop running before returning, and two, it returns the result if the task did successfully complete.

Trait Implementations

impl<T> Drop for Task<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> From<Task<T>> for JoinHandle<T, u32>

fn from(t: Task<T>) -> Self

Converts to this type from the input type.

impl<T> 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.