原文標題：Understanding Futures in Rust -- Part 2
原文連結：https://www.viget.com/articles/understanding-futures-is-rust-part-2/
公眾號： Rust 碎碎念
翻譯 by： Praying

背景

如果你還沒有看前面的內容，可以在這裡^[1]檢視（譯註：已有譯文，可在公眾號檢視）。

在第一部分，我們介紹了 Future trait，瞭解了 future 是如何被建立和執行的，並且開始知道它們如何能被連結到一起。

上次內容的程式碼可以在這個 playground 連結^[2]檢視，並且本文中所有示例程式碼將會以這段程式碼為基礎。

注意：所有的程式碼示例都有對應的 playground 連結，其中一些用於解釋說明但無法編譯的程式碼會有相應的標記。

目標

如果你熟悉 JavaScript 中的 promise 並且閱讀了最新的部落格，你可能會對先前文章中提到的組合子（then、catch和finally）感到困惑。

你將會在本文章找到與它們對等的東西，並且在最後，下面這段程式碼將能夠編譯。你將會理解使得 future 能夠運作的型別，trait 和底層概念。

// This does not compile, yet

fn main() {
    let my_future = future::ready(1)
        .map(|x| x + 3)
        .map(Ok)
        .map_err(|e: ()| format!("Error: {:?}", e))
        .and_then(|x| future::ready(Ok(x - 3)))
        .then(|res| {
            future::ready(match res {
                Ok(val) => Ok(val + 3),
                err => err,
            })
        });

    let val = block_on(my_future);
    assert_eq!(val, Ok(4));
}
 

工具函式

首先，我們需要一些工具函式，future::ready和block_on。這些函式能夠讓我們很容易地建立和執行 future 直到它們完成，這些函式雖然有用，但是在生產環境的程式碼中並不常見。

在開始之前，我們先把我們的Future trait 和Context結構體整合到模組裡以免和標準庫衝突。

mod task {
    use crate::NOTIFY;

    pub struct Context<'a> {
        waker: &'a Waker,
    }

    impl<'a> Context<'a> {
        pub fn from_waker(waker: &'a Waker) -> Self {
            Context { waker }
        }

        pub fn waker(&self) -> &'a Waker {
            &self.waker
        }
    }

    pub struct Waker;

    impl Waker {
        pub fn wake(&self) {
            NOTIFY.with(|f| *f.borrow_mut() = true)
        }
    }

}
use crate::task::*;

mod future {
    use crate::task::*;

    pub enum Poll<T> {
        Ready(T),
        Pending,
    }

    pub trait Future {
        type Output;

        fn poll(&mut self, cx: &Context) -> Poll<Self::Output>;
    }
}
use crate::future::*;
 

Playground 連結^[3]

這裡唯一需要注意的就是，只有將模組，型別和函式公開，才能在程式碼中使用它們。這可以通過pub關鍵字來完成。

工具函式實現

Future::Ready

future::ready建立了一個 future，該 future 帶有傳入值並且是立即就緒（ready）的。當你有一個已經不是 future 的值的時候，這個函式可以用於開啟一個 future 鏈，就像前一個示例那樣。

mod future {
    // ...

    pub struct Ready<T>(Option<T>);

    impl<T> Future for Ready<T> {
        type Output = T;

        fn poll(&mut self, _: &Context) -> Poll<Self::Output> {
            Poll::Ready(self.0.take().unwrap())
        }
    }

    pub fn ready<T>(val: T) -> Ready<T> {
        Ready(Some(val))
    }
}

fn main() {
    let my_future = future::ready(1);
    println!("Output: {}", run(my_future));
}

Playground 連結^[4]

我們建立了一個型別為Ready<T>的泛型結構體，該結構體包裝了一個Option。這裡我們使用Option列舉以保證 poll 函式只被呼叫一次。在 executor 的實現中，在返回一個Poll::Ready之後呼叫 poll 將會報錯。

BLOCK_ON

為了我們的目標，我們把我們的 run 函式重新命名為block_on。在future-preview 這個 crate 中，該函式使用內部的LocalPool來執行一個 future 直到完成，同時會阻塞當前執行緒。我們的函式也做了相似的事情。

fn block_on<F>(mut f: F) -> F::Output
where
    F: Future,
{
    NOTIFY.with(|n| loop {
        if *n.borrow() {
            *n.borrow_mut() = false;
            let ctx = Context::from_waker(&Waker);
            if let Poll::Ready(val) = f.poll(&ctx) {
                return val;
            }
        }
    })
}

fn main() {
    let my_future = future::ready(1);
    println!("Output: {}", block_on(my_future));
}

Playground 連結^[5]

組合子（Combinators）

首先，讓我們從一些能夠讓你直接作用於另一個 Future 的Output值的一些組合子開始。在本文中，我們使用非正式的但是比較流行的組合子定義，即能夠允許你對某種型別執行操作，並與其他型別結合起來的函式。例如，一個巢狀的 future 可以由一個組合子函式函式建立，它可以有一個複雜的型別Future< Output = Future < Output = i32>>。這可以被稱為一個 future，該 future 的輸出（Output）是另一個 future，新的 future 的輸出是 i32 型別。這樣的組合子中，最簡單的一個就是map。

Map

如果你熟悉Result或者Option型別的map函式，那麼對它應該不陌生。map 組合子持有一個函式並將其應用到 future 的Output值上，返回一個新的 future，這個新 future 把函式的結果（Result）作為它的Output。Future 中的 map 組合子甚至比Result或者Option中更簡單，因為不需要考慮 failure 的情況。map 就是簡單的Future->Future。

下面是函式簽名：

// does not compile
fn map<U, F>(self: Sized, f: F) -> Map<Self, F>
where
    F: FnOnce(Self::Output) -> U,
    Self: Sized,

map是一個泛型函式，它接收一個閉包，返回一個實現了 Future 的Map結構體。不是每當我們在值上進行連結都需要實現Futuretrait，正如我們在最後一部分做的那樣，我們可以使用這些函式來為我們完成這些工作。

讓我們來分析一下：

• Map<Self, F>聲明瞭 map 函式的（返回）型別，包括當前的 future，以及傳入函式的 future。

• where是一個能夠讓我們新增型別約束的關鍵字。對於F型別引數，我們可以在內部定義約束map<U, F: FnOnce(Self::Output) -> U，但是使用 where 語句可讀性會更好。

• FnOnce(Self::Output) -> U是一個函式的型別定義，該函式接收當前型別的Output並返回任意型別U。FnOnce是函式 trait 中的一個，其他還包括FnMut和Fn。FnOnce是用起來最簡單的，因為編譯器可以保證這個函式只被呼叫一次。它使用環境中用到的值並獲取其所有權。Fn和FnMut分別以不可變和可變的方式借用環境中值的引用。所有的閉包都實現了FnOncetrait，並且其中一些沒有移動值的閉包還實現了FnMut和Fntrait。這是 Rust 做的最酷的事情之一，允許對閉包和第一類函式引數進行真正有表達力的使用。Rust book 中的相關內容^[6]值得一讀。

• Self: Sized是一個約束，允許map只能被Sized的 trait 實現者呼叫。你不必考慮這個問題，但是確實有些型別不是Sized。例如，[i32]是一個不確定大小的陣列。因為我們不知道它多長。如果我們想要為它實現我們的Future trait，那麼我們就不能對它呼叫map。

大多數組合子都遵循這個模式，因此接下來的文章我們就不需要分析的這麼仔細了。

下面是一個map的完整實現，它的Map型別以及它對Future的實現

mod future {
    trait Future {
        // ...

        fn map<U, F>(self, f: F) -> Map<Self, F>
        where
            F: FnOnce(Self::Output) -> U,
            Self: Sized,
        {
            Map {
                future: self,
                f: Some(f),
            }
        }
    }

    // ...

    pub struct Map<Fut, F> {
        future: Fut,
        f: Option<F>,
    }

    impl<Fut, F, T> Future for Map<Fut, F>
    where
        Fut: Future,
        F: FnOnce(Fut::Output) -> T,
    {
        type Output = T;

        fn poll(&mut self, cx: &Context) -> Poll<T> {
            match self.future.poll(cx) {
                Poll::Ready(val) => {
                    let f = self.f.take().unwrap();
                    Poll::Ready(f(val))
                }
                Poll::Pending => Poll::Pending,
            }
        }
    }
}

fn main() {
    let my_future = future::ready(1).map(|val| val + 1);
    println!("Output: {}", block_on(my_future));
}

Playground 連結^[7]

從高層次來講，當我們呼叫一個 future 上的map時，我們構造了一個Map型別，該型別持有當前 future 的引用以及我們傳入的閉包。Map物件自身也是一個 Future。當它被輪詢時，它依次輪詢底層的 future。當底層的 future 就緒後，它獲取那個 future 的Output的值並且把它傳入閉包，對Poll::Ready中的閉包返回的值進行包裝（wrapping）並且把新值向上傳遞。

如果你閱讀了最新的部落格，你對在這裡看到的東西應該感到很熟悉，但是在我們繼續之前，我會快速地講解作為一個複習。

• pub struct Map<Fut, F>是一個關於 future——Fut和函式F的泛型。

• f: Option<F>是一個包裝了閉包了Option型別。這裡是個小技巧，以保證閉包只被呼叫一次。當你獲取一個Option的值，它會用None替換內部的值並且返回裡面包含的值。如果在返回一個Poll::Ready之後被輪詢，這個函式會 panic。在實際中，future 的 executor 不會允許這種情況發生。

• type Output = T;定義了 map future 的輸出和我們的閉包的返回值是將會是相同的。

• Poll::Read(f(val))返回帶有閉包返回結果的就緒（ready）狀態。

• Poll::Pending => Poll::Pending 如果底層的 future 返回 pending，繼續傳遞。

• future::ready(1).map(|val| val + 1); 這對就緒（ready）future 的輸出進行了 map，並對其加 1。它返回了一個 map future，其中帶有對原先的 future 的一個引用。map future 在執行期間輪詢原先的 future 是否就緒（ready）。這和我們的AddOneFuture做的是相同的事情。

這真的很酷，主要有以下幾個原因。首先，你不必對每一個你想要進行的計算都實現一個新的 future，它們可以被包裝（wrap）進組合子。事實上，除非你正在實現你自己的非同步操作，否則你可能從來都不需要自己去實現Future trait。

Then

現在我們有了map，我們可以把任何我們想要的計算連結起來，對麼？答案是對的，但是對此還有一個相當大的警告。

想象一下，當你有一些函式，這些函式返回你想要連結起來的 future。對於這個例子，我們可以想象，它們是下面的 api 呼叫，這些呼叫返回包裝（wrap）在 future 中的結果，get_user和get_files_for_user。

// does not compile
fn main() {
    let files_future = get_user(1).map(|user| get_files_for_user(user));
    println!("User Files: {}", block_on(files_future));
}

這段程式碼無法編譯，但是你可以想象你在這裡構建的型別，看起來應該像這樣：Future<Output = Future<Output= FileList>>。這在使用Result和Option型別的時候也是一個常見問題。使用map函式經常會導致巢狀的輸出和對這些巢狀的繁瑣處理。在這種情況下，你不得不去跟蹤到底嵌套了多少層並且對每一個巢狀的 future 都呼叫block_on。

幸運地是，Result，Option有一個被稱為and_then的解決方案。Option的and_then通過對T應用一個函式來對映（map）Some(T) -> Some(U)，並且返回閉包所返回的Option。對於 future，它是通過一個稱為then的函式來實現的，該函式看起來很像對映（map），但是這個閉包應該它自己的 future。在一些語言中，這被稱為flatmap。這裡值得注意的是，傳遞給then的閉包返回的值必須是實現了Future，否則你將會得到一個編譯器錯誤。

這裡是我們的對於then，Then結構體和它的對Future trait 的實現。其中的大部分內容和我們在 map 中做的很像。

mod future {
    trait Future {
        // ...
        fn then<Fut, F>(self, f: F) -> Then<Self, F>
        where
            F: FnOnce(Self::Output) -> Fut,
            Fut: Future,
            Self: Sized,
        {
            Then {
                future: self,
                f: Some(f),
            }
        }
    }

    // ...

    pub struct Then<Fut, F> {
        future: Fut,
        f: Option<F>,
    }

    impl<Fut, NextFut, F> Future for Then<Fut, F>
    where
        Fut: Future,
        NextFut: Future,
        F: FnOnce(Fut::Output) -> NextFut,
    {
        type Output = NextFut::Output;

        fn poll(&mut self, cx: &Context) -> Poll<Self::Output> {
            match self.future.poll(cx) {
                Poll::Ready(val) => {
                    let f = self.f.take().unwrap();
                    f(val).poll(cx)
                }
                Poll::Pending => Poll::Pending,
            }
        }
    }
}

fn main() {
    let my_future = future::ready(1)
        .map(|val| val + 1)
        .then(|val| future::ready(val + 1));
    println!("Output: {}", block_on(my_future));
}

Playground 連結^[8]

這裡面沒見過的程式碼可能是f(val).poll(cx)。它呼叫了帶有先前 future 的閉包並且直接返回給你poll的值。

聰明的你可能會意識到，我們的Then::poll函式可能會 panic。如果第一個 future 返回就緒（ready）但是第二個 future 返回Poll::Pending，接著let f = self.f.take().unwrap();這行程式碼就會在下次被輪詢（poll）的時候 panic 並退出程式。在future-preview中，這種情況會通過一個稱為Chain^[9]的型別來處理。Chain 通過 unsafe 程式碼塊來實現，並且使用了新型別——Pin。這些內容超出了本文的範圍。目前來講，我們可以假定任何通過