Add folly::coro::makeTask

Summary: Reduce boilerplate when defining simple coroutines, e.g. in tests

Reviewed By: yfeldblum

Differential Revision: D23404552

fbshipit-source-id: a19e9cb6640e3897d3c166499014ebe4c19fbf04

folly/experimental/coro/Task.h

@@ -625,6 +625,33 @@ class FOLLY_NODISCARD Task {
   handle_t coro_;
 };
 
+// By analogy to folly::makeSemiFuture
+// Make a completed Task by moving in a value.
+template <class T>
+Task<T> makeTask(T t) {
+  co_return t;
+}
+
+// Make a completed void Task.
+inline Task<void> makeTask() {
+  co_return;
+}
+inline Task<void> makeTask(Unit) {
+  co_return;
+}
+
+// Make a failed Task from an exception_wrapper.
+template <class T>
+Task<T> makeErrorTask(exception_wrapper ew) {
+  co_yield co_error(std::move(ew));
+}
+
+// Make a Task out of a Try.
+template <class T>
+Task<drop_unit_t<T>> makeResultTask(Try<T> t) {
+  co_yield co_result(std::move(t));
+}
+
 template <typename T>
 Task<T> detail::TaskPromise<T>::get_return_object() noexcept {
   return Task<T>{

folly/experimental/coro/test/TaskTest.cpp

@@ -504,4 +504,39 @@ TEST_F(TaskTest, YieldTry) {
     EXPECT_TRUE(retInt.hasValue());
   }());
 }
+
+TEST_F(TaskTest, MakeTask) {
+  folly::coro::blockingWait([]() -> folly::coro::Task<void> {
+    auto ret = co_await folly::coro::makeTask(42);
+    EXPECT_EQ(ret, 42);
+
+    co_await folly::coro::makeTask();
+    co_await folly::coro::makeTask(folly::unit);
+
+    auto err = co_await co_awaitTry(folly::coro::makeErrorTask<int>(
+        folly::make_exception_wrapper<std::runtime_error>("")));
+    EXPECT_TRUE(err.hasException());
+
+    err = co_await co_awaitTry(folly::coro::makeResultTask(folly::Try<int>(
+        folly::make_exception_wrapper<std::runtime_error>(""))));
+    EXPECT_TRUE(err.hasException());
+
+    auto try1 = co_await co_awaitTry(
+        folly::coro::makeResultTask(folly::Try<folly::Unit>(
+            folly::make_exception_wrapper<std::runtime_error>(""))));
+    EXPECT_TRUE(try1.hasException());
+    try1 = co_await co_awaitTry(
+        folly::coro::makeResultTask(folly::Try<folly::Unit>(folly::unit)));
+    EXPECT_TRUE(try1.hasValue());
+
+    // test move happens immediately (i.e. no dangling reference)
+    struct {
+      int i{0};
+    } s;
+    auto t = folly::coro::makeTask(std::move(s));
+    s.i = 1;
+    auto s2 = co_await std::move(t);
+    EXPECT_EQ(s2.i, 0);
+  }());
+}
 #endif