Struct async_task::FallibleTask

pub struct FallibleTask<T, M = ()> { /* private fields */ }

A spawned task with a fallible response.

This type behaves like Task, however it produces an Option<T> when polled and will return None if the executor dropped its Runnable without being run.

This can be useful to avoid the panic produced when polling the Task future if the executor dropped its Runnable.

Implementations

impl<T, M> FallibleTask<T, M>

pub fn detach(self)

Detaches the task to let it keep running in the background.

Examples

use smol::{Executor, Timer};
use std::time::Duration;

let ex = Executor::new();

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

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

Cancels the task and waits for it to stop running.

Returns the task’s output if it was completed just before it got canceled, or None if it didn’t complete.

While it’s possible to simply drop the Task to cancel it, this is a cleaner way of canceling because it also waits for the task to stop running.

Examples

use smol::{future, Executor, Timer};
use std::thread;
use std::time::Duration;

let ex = Executor::new();

// Spawn a deamon future.
let task = ex.spawn(async {
    loop {
        println!("Even though I'm in an infinite loop, you can still cancel me!");
        Timer::after(Duration::from_secs(1)).await;
    }
})
.fallible();

// Run an executor thread.
thread::spawn(move || future::block_on(ex.run(future::pending::<()>())));

future::block_on(async {
    Timer::after(Duration::from_secs(3)).await;
    task.cancel().await;
});

pub fn is_finished(&self) -> bool

Returns true if the current task is finished.

Note that in a multithreaded environment, this task can change finish immediately after calling this function.

Trait Implementations

impl<T, M: Debug> Debug for FallibleTask<T, M>

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

Formats the value using the given formatter.

impl<T, M> Future for FallibleTask<T, M>

type Output = Option<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.