Struct JoinSet 

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

A set of spawned tasks, joined in the order they finish.

Dropping the set cancels every task still in it, as dropping their Task handles would; detach_all lets them run on.

let mut set = nuclei::task::JoinSet::new();
for i in 0..4u64 {
    set.spawn(async move { i * 10 });
}
let mut sum = 0;
while let Some(out) = set.join_next().await {
    sum += out.unwrap();
}
assert_eq!(sum, 60);

Implementations

impl<T> JoinSet<T>

pub fn new() -> Self

An empty set.

pub fn len(&self) -> usize

The tasks in the set, finished and not joined ones included.

pub fn is_empty(&self) -> bool

Whether the set holds no task.

pub fn insert(&mut self, task: Task<T>) -> AbortHandle

Takes task into the set and answers a handle that cancels it.

pub fn spawn<F>(&mut self, future: F) -> AbortHandle

where F: Future<Output = T> + Send + 'static, T: Send + 'static,

Spawns future as spawn does, into the set.

pub fn spawn_local<F>(&mut self, future: F) -> AbortHandle

where F: Future<Output = T> + 'static, T: 'static,

Spawns future as spawn_local does, into the set.

pub fn spawn_blocking<F>(&mut self, f: F) -> AbortHandle

where F: FnOnce() -> T + Send + 'static, T: Send + 'static,

Runs f on the blocking pool, into the set.

pub fn spawn_on<F>(&mut self, future: F, handle: &RuntimeHandle) -> AbortHandle

where F: Future<Output = T> + Send + 'static, T: Send + 'static,

Spawns future on the runtime handle refers to, into the set.

pub async fn join_next(&mut self) -> Option<Result<T, JoinError>>

The output of the next task to finish, None when the set is empty. A task that was cancelled or panicked gives its JoinError.

pub async fn join_next_with_id(&mut self) -> Option<Result<(Id, T), JoinError>>

join_next, with the id of the task.

pub fn try_join_next(&mut self) -> Option<Result<T, JoinError>>

The output of a task that has finished, without waiting: None when none has (the set may still hold tasks).

pub fn poll_join_next( &mut self, cx: &mut Context<'_>, ) -> Poll<Option<Result<(Id, T), JoinError>>>

Polls for the next finished task.

pub async fn join_all(self) -> Vec<T>

Every task’s output, in finishing order.

Panics

When a task panicked (its panic is resumed) or was cancelled.

pub fn abort_all(&mut self)

Cancels every task in the set; they stay in it, and join_next gives each one’s cancellation (or its output, if it finished first).

pub fn detach_all(&mut self)

Takes every task out of the set and lets each run to its end. The slots go with them, so a detached task’s later wake meets none.

pub async fn shutdown(&mut self)

Cancels every task and waits until each one is out of the set.

Trait Implementations

impl<T> Debug for JoinSet<T>

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

Formats the value using the given formatter.

impl<T> Default for JoinSet<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T, F> Extend<F> for JoinSet<T>

where F: Future<Output = T> + Send + 'static, T: Send + 'static,

fn extend<I: IntoIterator<Item = F>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T, F> FromIterator<F> for JoinSet<T>

where F: Future<Output = T> + Send + 'static, T: Send + 'static,

fn from_iter<I: IntoIterator<Item = F>>(iter: I) -> Self

Creates a value from an iterator.