Trait futures_concurrency::Join

pub trait Join {
    type Output;
    type Future: Future<Output = Self::Output>;
    fn join(self) -> Self::Future;
}

Wait for multiple futures to complete.

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

Associated Types

type Output

The resulting output type.

type Future: Future<Output = Self::Output>

The resulting joined future.

Required methods

fn join(self) -> Self::Future

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> Join for [T; N] where
    T: Future, 

type Output = [T::Output; N]

type Future = Join<T, N>

fn join(self) -> Self::Future

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

type Output = Vec<T::Output>

type Future = Join<T>

fn join(self) -> Self::Future

impl<A, B> Join for (A, B) where
    A: Future,
    B: Future, 

type Output = (A::Output, B::Output)

type Future = Join2<A, B>

fn join(self) -> Self::Future

impl<A, B, C> Join for (A, B, C) where
    A: Future,
    B: Future,
    C: Future, 

type Output = (A::Output, B::Output, C::Output)

type Future = Join3<A, B, C>

fn join(self) -> Self::Future

impl<A, B, C, D> Join for (A, B, C, D) where
    A: Future,
    B: Future,
    C: Future,
    D: Future, 

type Output = (A::Output, B::Output, C::Output, D::Output)

type Future = Join4<A, B, C, D>

fn join(self) -> Self::Future

impl<A, B, C, D, E> Join for (A, B, C, D, E) where
    A: Future,
    B: Future,
    C: Future,
    D: Future,
    E: Future, 

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output)

type Future = Join5<A, B, C, D, E>

fn join(self) -> Self::Future

impl<A, B, C, D, E, F> Join for (A, B, C, D, E, F) where
    A: Future,
    B: Future,
    C: Future,
    D: Future,
    E: Future,
    F: Future, 

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output)

type Future = Join6<A, B, C, D, E, F>

fn join(self) -> Self::Future

impl<A, B, C, D, E, F, G> Join for (A, B, C, D, E, F, G) where
    A: Future,
    B: Future,
    C: Future,
    D: Future,
    E: Future,
    F: Future,
    G: Future, 

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output)

type Future = Join7<A, B, C, D, E, F, G>

fn join(self) -> Self::Future

impl<A, B, C, D, E, F, G, H> Join for (A, B, C, D, E, F, G, H) where
    A: Future,
    B: Future,
    C: Future,
    D: Future,
    E: Future,
    F: Future,
    G: Future,
    H: Future, 

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output)

type Future = Join8<A, B, C, D, E, F, G, H>

fn join(self) -> Self::Future

impl<A, B, C, D, E, F, G, H, I> Join for (A, B, C, D, E, F, G, H, I) where
    A: Future,
    B: Future,
    C: Future,
    D: Future,
    E: Future,
    F: Future,
    G: Future,
    H: Future,
    I: Future, 

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output)

type Future = Join9<A, B, C, D, E, F, G, H, I>

fn join(self) -> Self::Future

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

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output)

type Future = Join10<A, B, C, D, E, F, G, H, I, J>

fn join(self) -> Self::Future

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

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output)

type Future = Join11<A, B, C, D, E, F, G, H, I, J, K>

fn join(self) -> Self::Future

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

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output)

type Future = Join12<A, B, C, D, E, F, G, H, I, J, K, L>

fn join(self) -> Self::Future

Implementors