Struct Task 

pub struct Task {
    pub id: u64,
    pub scope: Rc<str>,
    pub position: usize,
    pub state: RefCell<TaskState>,
    /* private fields */
}

A spawned unit of work and the value it will produce.

The value is reachable only through TaskState::Settled, so no caller can observe it without going through await or scope exit.

Fields

id: u64

Trace identity, unique across the run. Zero for a task that was already settled when it was created, which never appears in a trace because it never ran as a task.

scope: Rc<str>

The name of the scope that owns this task, for diagnostics.

position: usize

Position in spawn order within that scope, counting from one.

state: RefCell<TaskState>

Implementations

impl Task

pub fn running( id: u64, scope: Rc<str>, position: usize, cancellation: Cancellation, thread: JoinHandle<TaskOutcome>, ) -> Rc<Task>

A task whose body is already running on thread.

pub fn settled(value: Value) -> Rc<Task>

A task whose value is already known.

An async fn is called like any other function and runs its body at the call site, so the handle it returns is settled on creation. ADR 0008 gives a thread to spawn, which is where the language says concurrency begins; nothing may depend on when an async fn body ran, only on the value await produces.

pub fn is_running(&self) -> bool

Whether the body is still running on its own thread.

pub fn is_cancelled(&self) -> bool

Whether this task’s own cancellation was requested.

pub fn cancel(&self)

Asks this task to stop at its next safepoint.

A task that has already finished is unaffected: cancellation stops work that has not happened, it does not undo work that has. Nothing here waits — Task::join is what waits — because a scope cancels all of its children before waiting for any of them.

pub fn join(&self)

Waits for the body’s thread and records what it produced, unless the task has already been joined.

A task’s body runs at most once and is joined at most once, so awaiting the same handle twice returns the same value and repeats no effect.

pub fn describe(&self) -> String

How this task is named in diagnostics.

Trait Implementations

impl Debug for Task

A task shows as what it is, never as the value it will produce: that value is observable through await or scope exit and through nothing else.

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

Formats the value using the given formatter.