Using async/await

由于Rust 1.39，您可以使用async和await语法来涵盖大多数情况:

async fn a() -> usize {
    2
}
async fn b() -> usize {
    10
}

async fn f() -> usize {
    if 1 > 0 {
        a().await
    } else {
        b().await + 2
    }
}

另见:

• What is the purpose of async/await in Rust?

Either

通过FutureExt trait使用futures::future::Either没有额外的堆分配:

use futures::{Future, FutureExt}; // 0.3.5

async fn a() -> usize {
    2
}

async fn b() -> usize {
    10
}

fn f() -> impl Future<Output = usize> {
    if 1 > 0 {
        a().left_future()
    } else {
        b().right_future()
    }
}

但是，这需要固定的堆栈分配.如果A占用1字节，并且99%的时间发生，但是B占用512字节，那么Either将占用512字节(加上一些).这并不总是一场胜利.

此解决方案也适用于Stream秒.

Boxed trait objects

这里我们使用FutureExt::boxed返回一个trait对象:

use futures::{Future, FutureExt}; // 0.3.5

async fn a() -> usize {
    2
}

async fn b() -> usize {
    10
}

fn f() -> impl Future<Output = usize> {
    if 1 > 0 {
        a().boxed()
    } else {
        b().boxed()
    }
}

此解决方案也适用于Stream秒.

作为Matthieu M. points out，这两种解决方案可以结合使用:

我想指出的是，对于B:Either(A, Box<B>)的大样本，有一个中间解决方案.这样，您只需在罕见的情况下支付堆分配，即B

注意，如果你有Either:Either<A, Either<B, C>>的条件，也可以有Either:Either<Either<A, B>, Either<C, D>>的条件

use futures::{Future, FutureExt}; // 0.3.5

async fn a() -> i32 {
    2
}

async fn b() -> i32 {
    0
}

async fn c() -> i32 {
    -2
}

fn f(v: i32) -> impl Future<Output = i32> {
    use std::cmp::Ordering;

    match v.cmp(&0) {
        Ordering::Less => a().left_future(),
        Ordering::Equal => b().left_future().right_future(),
        Ordering::Greater => c().right_future().right_future(),
    }
}

另见:

• Conditionally iterate over one of several possible iterators