通过 c++20 协程制作 python 生成器

Question

假设我有这个 python 代码：

def double_inputs():
    while True:
        x = yield
        yield x * 2
gen = double_inputs()
next(gen)
print(gen.send(1))

正如预期的那样，它打印“2”。我可以像这样在 c++20 中制作一个生成器：

#include <coroutine>

template <class T>
struct generator {
    struct promise_type;
    using coro_handle = std::coroutine_handle<promise_type>;

    struct promise_type {
        T current_value;
        auto get_return_object() { return generator{coro_handle::from_promise(*this)}; }
        auto initial_suspend() { return std::suspend_always{}; }
        auto final_suspend() { return std::suspend_always{}; }
        void unhandled_exception() { std::terminate(); }
        auto yield_value(T value) {
            current_value = value;
            return std::suspend_always{};
        }
    };

    bool next() { return coro ? (coro.resume(), !coro.done()) : false; }
    T value() { return coro.promise().current_value; }

    generator(generator const & rhs) = delete;
    generator(generator &&rhs)
        :coro(rhs.coro)
    {
        rhs.coro = nullptr;
    }
    ~generator() {
        if (coro)
            coro.destroy();
    }
private:
    generator(coro_handle h) : coro(h) {}
    coro_handle coro;
};

generator<char> hello(){
    //TODO:send string here via co_await, but HOW???
    std::string word = "hello world";
    for(auto &ch:word){
        co_yield ch;
    }
}

int main(int, char**) {
    for (auto i = hello(); i.next(); ) {
        std::cout << i.value() << ' ';
    }
}

这个生成器只是一个字母一个字母地产生一个字符串，但是这个字符串是硬编码的。在 python 中，不仅可以从生成器中产生一些东西，而且还可以产生一些东西给它。我相信它可以通过 C++ 中的 co_await 来完成。

我需要它像这样工作：

generator<char> hello(){
    std::string word = co_await producer; // Wait string from producer somehow 
    for(auto &ch:word){
        co_yield ch;
    }
}

int main(int, char**) {
    auto gen = hello(); //make consumer
    producer("hello world"); //produce string
    for (; gen.next(); ) {
        std::cout << gen.value() << ' '; //consume string letter by letter
    }
}

我怎样才能做到这一点？如何使用 c++20 协程制作这个“生产者”？

Answer 1

如果你想这样做，你基本上有两个问题需要克服。

首先是 C++ 是一种静态类型语言。这意味着需要在编译时知道所涉及的所有类型。这就是为什么你的generator类型需要是一个模板，以便用户可以指定它从协程到调用者的牧羊人类型。

所以如果你想拥有这个双向接口，那么你的函数上的某些东西hello必须同时指定输出类型和输入类型。

最简单的方法是创建一个对象并将const对该对象的非引用传递给生成器。每次执行 a 时co_yield，调用者都可以修改引用的对象，然后请求一个新值。协程可以从引用中读取并查看给定的数据。

但是，如果您坚持使用协程的 future 类型作为输出和输入，那么您需要同时解决第一个问题（通过使您的generator模板采用OutputTypeand InputType）以及第二个问题。

看，您的目标是获得协程的价值。问题是该值的来源（调用协程的函数）有一个 future 对象。但是协程无法访问future 对象。它也不能访问未来引用的承诺对象。

或者至少，它不能那么容易地做到。

有两种方法可以解决这个问题，适用于不同的用例。第一个操作协程机制以通过后门进入承诺。第二个操作一个属性co_yield来做基本相同的事情。

转变

协程的承诺对象通常是隐藏的，并且无法从协程中访问。它可以被承诺创建的未来对象访问，它充当承诺数据的接口。但在co_await机器的某些部分也可以访问它。

具体来说，当您co_await对协程中的任何表达式执行 a时，机器会查看您的 Promise 类型以查看它是否有一个名为 的函数await_transform。如果是这样，它将await_transform在您使用的每个表达式co_await上调用该 promise 对象（至少，在co_await您直接编写的 a 中，而不是隐式等待，例如由 创建的那个co_yield）。

因此，我们需要做两件事：await_transform在承诺类型上创建一个重载，并创建一个唯一目的是允许我们调用该await_transform函数的类型。

所以这看起来像这样：

struct generator_input {};

...

//Within the promise type:
auto await_transform(generator_input);

一个快速说明。await_transform像这样使用的缺点是，通过为我们的承诺指定这个函数的一个重载，我们会影响使用这种类型的任何协程中的每一个 co_await。对于生成器协程，这不是很重要，因为co_await除非您进行这样的 hack ，否则没有太多理由这样做。但是，如果您正在创建一个更通用的机制，可以明显地等待任意可等待对象作为其生成的一部分，那么您就会遇到问题。

好的，所以我们有了这个await_transform功能；这个函数需要做什么？它需要返回一个可等待的对象，因为co_await它将等待它。但是这个可等待对象的目的是传递对输入类型的引用。幸运的是，co_await用于将 awaitable 转换为值的机制是由 awaitable 的await_resume方法提供的。所以我们的可以只返回一个InputType&：

//Within the `generator<OutputType, InputType>`:
    struct passthru_value
    {
        InputType &ret_;

        bool await_ready() {return true;}
        void await_suspend(coro_handle) {}
        InputType &await_resume() { return ret_; }
    };


//Within the promise type:
auto await_transform(generator_input)
{
    return passthru_value{input_value}; //Where `input_value` is the `InputType` object stored by the promise.
}

这使协程可以通过调用来访问该值co_await generator_input{};。请注意，这将返回对对象的引用。

该generator类型可以很容易地进行修改，以允许修改的能力InputType存储在许对象。只需添加一对send用于覆盖输入值的函数：

void send(const InputType &input)
{
    coro.promise().input_value = input;
} 

void send(InputType &&input)
{
    coro.promise().input_value = std::move(input);
} 

这代表了一种不对称的传输机制。协程在自己选择的地点和时间检索值。因此，没有义务立即对任何变化做出反应。这在某些方面是好的，因为它允许协程将自己与有害更改隔离开来。如果您在for容器上使用基于范围的循环，则外部世界不能直接修改该容器（在大多数情况下），否则您的程序将显示 UB。因此，如果协程以这种方式脆弱，它可以从用户那里复制数据，从而防止用户对其进行修改。

总而言之，所需的代码并不大。以下是经过这些修改的代码的可运行示例：

#include <coroutine>
#include <exception>
#include <string>
#include <iostream>

struct generator_input {};


template <typename OutputType, typename InputType>
struct generator {
    struct promise_type;
    using coro_handle = std::coroutine_handle<promise_type>;

    struct passthru_value
    {
        InputType &ret_;

        bool await_ready() {return true;}
        void await_suspend(coro_handle) {}
        InputType &await_resume() { return ret_; }
    };

    struct promise_type {
        OutputType current_value;
        InputType input_value;


        auto get_return_object() { return generator{coro_handle::from_promise(*this)}; }
        auto initial_suspend() { return std::suspend_always{}; }
        auto final_suspend() { return std::suspend_always{}; }
        void unhandled_exception() { std::terminate(); }
        auto yield_value(OutputType value) {
            current_value = value;
            return std::suspend_always{};
        }

        void return_void() {}

        auto await_transform(generator_input)
        {
            return passthru_value{input_value};
        }
    };

    bool next() { return coro ? (coro.resume(), !coro.done()) : false; }
    OutputType value() { return coro.promise().current_value; }

    void send(const InputType &input)
    {
        coro.promise().input_value = input;
    } 

    void send(InputType &&input)
    {
        coro.promise().input_value = std::move(input);
    } 

    generator(generator const & rhs) = delete;
    generator(generator &&rhs)
        :coro(rhs.coro)
    {
        rhs.coro = nullptr;
    }
    ~generator() {
        if (coro)
            coro.destroy();
    }
private:
    generator(coro_handle h) : coro(h) {}
    coro_handle coro;
};

generator<char, std::string> hello(){
    auto word = co_await generator_input{};

    for(auto &ch: word){
        co_yield ch;
    }
}

int main(int, char**)
{
    auto test = hello();
    test.send("hello world");

    while(test.next())
    {
        std::cout << test.value() << ' ';
    }
}

更有收获

使用显式的另一种方法co_await是利用 的属性co_yield。即，co_yield是一个表达式，因此它有一个值。具体来说，它（大部分）等价于co_await p.yield_value(e)，ppromise 对象在哪里（哦！）并且e是我们正在产生的东西。

幸运的是，我们已经有了一个yield_value函数；它返回std::suspend_always。但它也可以返回一个对象，总是暂停，但也这co_await可以解压到InputType&：

struct yield_thru
{
    InputType &ret_;

    bool await_ready() {return false;}
    void await_suspend(coro_handle) {}
    InputType &await_resume() { return ret_; }
};

...

//in the promise
auto yield_value(OutputType value) {
    current_value = value;
    return yield_thru{input_value};
}

这是一种对称传输机制；对于您产生的每个值，您都会收到一个值（可能与以前相同）。与显式co_await方法不同，您无法在开始生成值之前接收值。这对于某些接口可能很有用。

当然，您可以根据需要将它们组合起来。