DetachedCoroutine 似乎没有必要？

[yanminhui]

当前逻辑：

struct FinalAwaiter {
    bool await_ready() const noexcept { return false; }
    template <typename PromiseType>
    auto await_suspend(std::coroutine_handle<PromiseType> h) noexcept {
        return h.promise()._continuation;
    }
    void await_resume() noexcept {}
};

// Lazy:
template <typename F>
void start(F&& callback) {
    // callback should take a single Try<T> as parameter, return value will
    // be ignored. a detached coroutine will not suspend at initial/final
    // suspend point.
    auto launchCoro = [](Lazy lazy,
                         std::decay_t<F> cb) -> detail::DetachedCoroutine {
        cb(std::move(co_await lazy.coAwaitTry()));
    };
    [[maybe_unused]] auto detached =
        launchCoro(std::move(*this), std::forward<F>(callback));
}

是不是可以简化成如下：移除 DetachedCoroutine ？

struct FinalAwaiter {
    bool await_ready() const noexcept { return false; }
    template <typename PromiseType>
    std::coroutine_handle<> await_suspend(std::coroutine_handle<PromiseType> h) noexcept {
        if (auto continue_h = h.promise()._continuation) {
            return continue_h;
        }
        return std::noop_coroutine();
    }
    void await_resume() noexcept {}
};

// Lazy:
template <typename F>
void start(F&& callback) {
    if (!isReady()) {
        _coro.resume(); // 激活当前挂起的协程
    }
    callback(coAwaitTry().await_resume()); // 获取协程运行结果
}

[ChuanqiXu9]

这种情况是不可以的，执行 coAwaitTry 时 Lazy 不一定执行完成。同时这种写法无法处理异常。

[yanminhui]

@ChuanqiXu9 我简单写个代码片段，运行是符合预期的，您能举个无法正常工作的示例让我学习一下吗？

#include <iostream>

#include "async_simple/coro/Lazy.h"

async_simple::coro::Lazy<int> testWithException() {
  throw std::runtime_error("runtime error from testWithException");
  co_return 1;
}

async_simple::coro::Lazy<int> testWithoutException() { co_return 2022; }

int main() {
  auto callback = [](async_simple::Try<int> res) {
    if (!res.hasError()) {
      std::cout << "value: " << res.value() << std::endl;
      return;
    }
    try {
      std::rethrow_exception(res.getException());
    } catch (const std::exception& e) {
      std::cerr << "error: " << e.what() << std::endl;
    }
  };
  testWithException().startEx(callback);  // `start` is replaced by `startEx`
  testWithoutException().startEx(callback);
}

输出：

error: runtime error from testWithException
value: 2022

[ChuanqiXu9]

hmmm 你可以试试跑跑测试

[yanminhui]

看了下原先 DetachedCoroutine 的作用只是激活挂起的协程，待协程结束后获取结果及释放内存而已，所以我想是不是只要在 start 里面激活，待控制权交回时获取结果就行。

至于协程内部再次 co_await 交由 await_transform 处理。

[ChuanqiXu9]

DetachedCoroutine 最大的作用是提供协程环境，这和无栈协程的工作机制有关系，你可能需要再了解一下。另外跑测试来验证会更快些。

[yanminhui]

⚠️ ⚠️ ⚠️ 嗯，发现问题了。⚠️ ⚠️ ⚠️ 当协程切换到子线程执行时，Lazy::start 所在线程（非协程）与子线程 并发执行，当在协程未执行结束时取结果将出错。

struct IntAwaiter {
  int value;
  ValueAwaiter(int v) : value(v) {}

  bool await_ready() { return false; }
  void await_suspend(std::coroutine_handle<> continuation) noexcept {
    std::thread([c = continuation]() mutable { c.resume(); }).detach();
  }
  int await_resume() noexcept { return value; }
};

async_simple::coro::Lazy<int> testWithoutException() {
  auto n = co_await IntAwaiter{2022};
  co_return n;
}

[ChuanqiXu9]

是的。另外我觉得你画的这个图挺不错的，有兴趣的话你可以尝试把这个图加到我们的文档里。

[RainMark]

DetachedCoroutine的存在使得回调函数能够在lazy执行返回后才被调用。如果没有这个的话就得把回调函数挂在顶层lazy的 final 阶段，感觉比较恶心。DetachedCoroutine来hold住lazy执行和回调处理感觉还是比较自然