Trait futures_concurrency::prelude::Race

pub trait Race {
    type Output;

    fn race<'async_trait>(
        self
    ) -> Pin<Box<dyn Future<Output = Self::Output> + 'async_trait>>
    where
        Self: 'async_trait;
}

Wait for the first future to complete.

Awaits multiple futures simultaneously, returning the output of the first future which completes.

Required Associated Types

type Output

The resulting output type.

Required Methods

fn race<'async_trait>(
    self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'async_trait>> where
    Self: 'async_trait, 

Waits for multiple futures to complete.

Awaits multiple futures simultaneously, returning the output of the futures once both complete.

This function returns a new future which polls both futures concurrently.

Implementations on Foreign Types

impl<T, const N: usize> Race for [T; N] where
    T: Future, 

type Output = <T as Future>::Output

fn race<'async_trait>(
    self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'async_trait>> where
    Self: 'async_trait, 

impl<T, A, B> Race for (A, B) where
    A: Future<Output = T>,
    B: Future<Output = T>, 

type Output = T

fn race<'async_trait>(
    self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'async_trait>> where
    Self: 'async_trait, 

impl<T, A, B, C> Race for (A, B, C) where
    A: Future<Output = T>,
    B: Future<Output = T>,
    C: Future<Output = T>, 

type Output = T

fn race<'async_trait>(
    self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'async_trait>> where
    Self: 'async_trait, 

impl<T, A, B, C, D> Race for (A, B, C, D) where
    A: Future<Output = T>,
    B: Future<Output = T>,
    C: Future<Output = T>,
    D: Future<Output = T>, 

type Output = T

fn race<'async_trait>(
    self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'async_trait>> where
    Self: 'async_trait, 

impl<T, A, B, C, D, E> Race for (A, B, C, D, E) where
    A: Future<Output = T>,
    B: Future<Output = T>,
    C: Future<Output = T>,
    D: Future<Output = T>,
    E: Future<Output = T>, 

type Output = T

fn race<'async_trait>(
    self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'async_trait>> where
    Self: 'async_trait, 

impl<T, A, B, C, D, E, F> Race for (A, B, C, D, E, F) where
    A: Future<Output = T>,
    B: Future<Output = T>,
    C: Future<Output = T>,
    D: Future<Output = T>,
    E: Future<Output = T>,
    F: Future<Output = T>, 

type Output = T

fn race<'async_trait>(
    self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'async_trait>> where
    Self: 'async_trait, 

impl<T, A, B, C, D, E, F, G> Race for (A, B, C, D, E, F, G) where
    A: Future<Output = T>,
    B: Future<Output = T>,
    C: Future<Output = T>,
    D: Future<Output = T>,
    E: Future<Output = T>,
    F: Future<Output = T>,
    G: Future<Output = T>, 

type Output = T

fn race<'async_trait>(
    self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'async_trait>> where
    Self: 'async_trait, 

impl<T, A, B, C, D, E, F, G, H> Race for (A, B, C, D, E, F, G, H) where
    A: Future<Output = T>,
    B: Future<Output = T>,
    C: Future<Output = T>,
    D: Future<Output = T>,
    E: Future<Output = T>,
    F: Future<Output = T>,
    G: Future<Output = T>,
    H: Future<Output = T>, 

type Output = T

fn race<'async_trait>(
    self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'async_trait>> where
    Self: 'async_trait, 

impl<T, A, B, C, D, E, F, G, H, I> Race for (A, B, C, D, E, F, G, H, I) where
    A: Future<Output = T>,
    B: Future<Output = T>,
    C: Future<Output = T>,
    D: Future<Output = T>,
    E: Future<Output = T>,
    F: Future<Output = T>,
    G: Future<Output = T>,
    H: Future<Output = T>,
    I: Future<Output = T>, 

type Output = T

fn race<'async_trait>(
    self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'async_trait>> where
    Self: 'async_trait, 

impl<T, A, B, C, D, E, F, G, H, I, J> Race for (A, B, C, D, E, F, G, H, I, J) where
    A: Future<Output = T>,
    B: Future<Output = T>,
    C: Future<Output = T>,
    D: Future<Output = T>,
    E: Future<Output = T>,
    F: Future<Output = T>,
    G: Future<Output = T>,
    H: Future<Output = T>,
    I: Future<Output = T>,
    J: Future<Output = T>, 

type Output = T

fn race<'async_trait>(
    self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'async_trait>> where
    Self: 'async_trait, 

impl<T, A, B, C, D, E, F, G, H, I, J, K> Race for (A, B, C, D, E, F, G, H, I, J, K) where
    A: Future<Output = T>,
    B: Future<Output = T>,
    C: Future<Output = T>,
    D: Future<Output = T>,
    E: Future<Output = T>,
    F: Future<Output = T>,
    G: Future<Output = T>,
    H: Future<Output = T>,
    I: Future<Output = T>,
    J: Future<Output = T>,
    K: Future<Output = T>, 

type Output = T

fn race<'async_trait>(
    self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'async_trait>> where
    Self: 'async_trait, 

impl<T, A, B, C, D, E, F, G, H, I, J, K, L> Race for (A, B, C, D, E, F, G, H, I, J, K, L) where
    A: Future<Output = T>,
    B: Future<Output = T>,
    C: Future<Output = T>,
    D: Future<Output = T>,
    E: Future<Output = T>,
    F: Future<Output = T>,
    G: Future<Output = T>,
    H: Future<Output = T>,
    I: Future<Output = T>,
    J: Future<Output = T>,
    K: Future<Output = T>,
    L: Future<Output = T>, 

type Output = T

fn race<'async_trait>(
    self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'async_trait>> where
    Self: 'async_trait, 

impl<T> Race for Vec<T> where
    T: Future, 

type Output = <T as Future>::Output

fn race<'async_trait>(
    self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'async_trait>> where
    Self: 'async_trait, 

Implementors