future.then() 如何返回 Future？

Question

下面的函数，取自here：

fn connection_for(
    &self,
    pool_key: PoolKey,
) -> impl Future<Output = Result<Pooled<PoolClient<B>>, ClientError<B>>> {

    let checkout = self.pool.checkout(pool_key.clone());
    let connect = self.connect_to(pool_key);

    let executor = self.conn_builder.exec.clone();
    // The order of the `select` is depended on below...
    future::select(checkout, connect).then(move |either| match either {
         ...

应该返回一个Future。但是，它返回的返回结果是

    future::select(checkout, connect).then(...)

.then 在哪里这样做：

fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>

这不是Future。这怎么可能？

我试图了解此函数返回的内容。这是'.then'的结尾：

       Either::Right((Err(err), checkout)) => Either::Right(Either::Right({
            if err.is_canceled() {
                Either::Left(checkout.map_err(ClientError::Normal))
            } else {
                Either::Right(future::err(ClientError::Normal(err)))
            }
        })),

看起来它返回了 Either::Right(Either::Right 的东西。我很困惑。

Answer 1

.then() 用于将两个期货链接在一起。它返回一个Then<Fut1, Fut2, F>，它是一个Future，它执行以下工作：轮询第一个future，使用给定函数处理结果，并轮询生成的future。

---

Either 类型旨在将具有相同关联输出的两个不同期货组合成一个类型。假设您正在创建一个函数，该函数将根据输入返回两个不同的期货：

async fn do_a() -> () {}
async fn do_b() -> () {}

fn do_something(cond: bool) -> impl Future<Output = ()> {
    if cond {
        do_a()
    }
    else {
        do_b()
    }
}

This won't compile 因为do_a() 和do_b() 返回的Futures 是不同的类型。 Rust 编译器非常友好地建议使用 Box<dyn Future> 动态返回不同的类型，但是出于性能原因，有时不需要额外的间接性并且没有必要。

上面可以实现为使用Either返回一个具体的Future。

use std::future::Future;
use futures::future::Either;

async fn do_a() -> () {}
async fn do_b() -> () {}

fn do_something(cond: bool) -> impl Future<Output = ()> {
    if cond {
        Either::Left(do_a())
    }
    else {
        Either::Right(do_b())
    }
}

有问题的链接代码看起来有点粗糙，因为它不仅要协调两个不同的未来，还要协调五个。但是您可以毫无问题地嵌套Eithers，因为它们本身就是Futures。它更像这样：

use std::future::Future;
use futures::future::Either;

async fn do_a() -> () {}
async fn do_b() -> () {}
async fn do_c() -> () {}
async fn do_d() -> () {}
async fn do_e() -> () {}

fn do_something(cond1: bool, cond2: bool, cond3: bool) -> impl Future<Output = ()> {
    if cond1 {
        Either::Left(do_a())
    }
    else if cond2 {
        if cond3 {
            Either::Right(Either::Left(Either::Left(do_b())))
        }
        else {
            Either::Right(Either::Left(Either::Right(do_c())))
        }
    }
    else {
        if cond3 {
            Either::Right(Either::Right(Either::Left(do_d())))
        }
        else {
            Either::Right(Either::Right(Either::Right(do_e())))
        }
    }
}

这一切最终都会创建一个impl Future<Output = Result<Pooled<PoolClient<B>>, ClientError<B>>>，因为它可能产生的所有单个期货都返回一个Result<Pooled<PoolClient<B>>, ClientError<B>>。