fn try_join<Fut2>(self, other: Fut2) -> TryJoin<Self, Fut2>
    where
        Fut2: TryFuture<Error = Self::Error>,
        Self: Sized,
    {
        TryJoin::new(self, other)
    }
/// Joins the result of two futures, waiting for them both to complete or
/// for one to produce an error.
///
/// This function will return a new future which awaits both this and the
/// `other` future to complete. If successful, the returned future will
/// finish with a tuple of both results. If unsuccesful, it will complete
/// with the first error encountered.
///
/// Note that this function consumes the receiving future and returns a
/// wrapped version of it.
///
/// # Examples
///
/// When used on multiple futures that return [`Ok`], `try_join` will return
/// [`Ok`] of a tuple of the values:
///
/// ```
/// #![feature(async_await, await_macro, futures_api)]
/// # futures::executor::block_on(async {
/// use futures::future::{self, TryFutureExt};
///
/// let a = future::ready(Ok::<i32, i32>(1));
/// let b = future::ready(Ok::<i32, i32>(2));
/// let pair = a.try_join(b);
///
/// assert_eq!(await!(pair), Ok((1, 2)));
/// # });
/// ```
///
/// If one of the futures resolves to an error, `try_join` will return
/// that error:
///
/// ```
/// #![feature(async_await, await_macro, futures_api)]
/// # futures::executor::block_on(async {
/// use futures::future::{self, TryFutureExt};
///
/// let a = future::ready(Ok::<i32, i32>(1));
/// let b = future::ready(Err::<i32, i32>(2));
/// let pair = a.try_join(b);
///
/// assert_eq!(await!(pair), Err(2));
/// # });
/// ```
Joins the result of two futures, waiting for them both to complete or
for one to produce an error.

This function will return a new future which awaits both this and the
`other` future to complete. If successful, the returned future will
finish with a tuple of both results. If unsuccesful, it will complete
with the first error encountered.

Note that this function consumes the receiving future and returns a
wrapped version of it.
Joins the result of two futures waiting for them both to complete or for one to produce an error . This function will return a new future which awaits both this and the ` other ` future to complete . If successful the returned future will finish with a tuple of both results . If unsuccesful it will complete with the first error encountered . Note that this function consumes the receiving future and returns a wrapped version of it .
fn try_join<Fut2>(self, other: Fut2) -> TryJoin<Self, Fut2>
    where
        Fut2: TryFuture<Error = Self::Error>,
        Self: Sized,
    {
        TryJoin::new(self, other)
    }
fn try_join < Fut2 > ( self , other : Fut2 ) -> TryJoin < Self , Fut2 > where Fut2 : TryFuture < Error = Self :: Error > , Self : Sized , { TryJoin :: new ( self , other ) }
Joins the result of two futures, waiting for them both to complete or
for one to produce an error.
Joins the result of two futures waiting for them both to complete or for one to produce an error .
self
other
Fut2
examples
When used on multiple futures that return [`Ok`], `try_join` will return
[`Ok`] of a tuple of the values.


When used on multiple futures that return [ ` Ok ` ] ` try_join ` will return [ ` Ok ` ] of a tuple of the values .
![feature(async_await, await_macro, futures_api)]
None
futures::executor::block_on(async {
use futures::future::{self, TryFutureExt}.




use futures :: future :: { self TryFutureExt } .
});


If one of the futures resolves to an error, `try_join` will return
that error.


If one of the futures resolves to an error ` try_join ` will return that error .
![feature(async_await, await_macro, futures_api)]
None
futures::executor::block_on(async {
use futures::future::{self, TryFutureExt}.




use futures :: future :: { self TryFutureExt } .
});
None