How to launch a coroutine without blocking current coroutine, and then launch another coroutine and wait for its result?

[ChihHao-Su]

Let's assume we have two coroutine functions:

#include <async_simple/coro/SyncAwait.h>
#include <async_simple/coro/Lazy.h>
#include <async_simple/coro/Sleep.h>
#include <async_simple/executors/SimpleExecutor.h>

using namespace std::chrono_literals;
namespace coro = async_simple::coro;

coro::Lazy<> coro1() {
	for(int i = 0; i <= 40; i++){
		co_await coro::sleep(1s);
		std::println("1");
	}
	co_return;
}

coro::Lazy<std::string_view> coro2() {
	for(int i = 0; i <= 40; i++) {
		co_await coro::sleep(1s);
		std::println("2");
	}
	co_return "FINISHED";
}

What I want to do is like the code below in JavaScript:

async function run() {
    // Launch coro1 without blocking
    coro1().finally(() => { console.log("coro1 done"); });
    // Launch coro2, block until coro2 `co_return`
    const coro2Result= await coro2();
    console.log(coro2Result);
}

I try to write code like this, but it doesn't work as expected

coro::Lazy<> run() {
	coro1().start([](auto &&_) {});
	auto coro2Result = co_await coro2();
	std::cout << coro2Result << '\n';
	co_return;
}

int main() {
	coro::syncAwait(run());
	return 0;
}

Result: run will block at line coro1().start([](auto &&_) {}); until coro1 finishes

[ChihHao-Su]

After some exploration, it turns out:

• An executor is needed in case of running multiple coroutines in parallel, in order to schedule them. The code below runs as expected:

  async_simple::executors::SimpleExecutor executor{ 1 };
  
  coro::Lazy<> coro1() {
      while(true){
          co_await coro::Yield{};
          std::println("1");
      }
      co_return;
  }
  
  coro::Lazy<> coro2() {
      while(true) {
          co_await coro::Yield{};
          std::println("2");
      }
      co_return;
  }
  
  coro::Lazy<> run() {
      coro1().directlyStart([](auto &&_) {}, &executor);
      co_await coro2();
      co_return;
  }
  
  int main() {
      try {
          coro::syncAwait(run(), &executor);
      } catch(const std::exception &ex) {
          std::cerr << "Exception: " << ex.what() << '\n';
      }
      return 0;
  }

  We can pass an executor to coro::syncAwait. (There's no documentation about it!).

• SimpleExecutor doesn't work with coro::sleep

  async_simple::executors::SimpleExecutor executor{ 1 };
  
  coro::Lazy<> coro1() {
      for(int i = 0; i <= 40; i++) {
          co_await coro::sleep(1s);
          std::println("1");
      }
      co_return;
  }
  
  coro::Lazy<std::string_view> coro2() {
      for(int i = 0; i <= 40; i++) {
          co_await coro::sleep(1s);
          std::println("2");
      }
      co_return "FINISHED";
  }
  
  coro::Lazy<> run() {
      coro1().directlyStart([](auto &&_) {}, &executor);
      auto coro2Result = co_await coro2();
      std::cout << coro2Result << '\n';
      co_return;
  }
  int main() {
      try {
          coro::syncAwait(run(), &executor);
      } catch(const std::exception &ex) {
          std::cerr << "Exception: " << ex.what() << '\n';
      }
      return 0;
  }

  co_await coro::sleep(1s); is useless except causing an "yield".

[ChuanqiXu9]

syncAwait is only suggested to use in test.

[ChihHao-Su]

Let's assume we have two coroutine functions:

#include <async_simple/coro/SyncAwait.h>
#include <async_simple/coro/Lazy.h>
#include <async_simple/coro/Sleep.h>
#include <async_simple/executors/SimpleExecutor.h>

using namespace std::chrono_literals;
namespace coro = async_simple::coro;

coro::Lazy<> coro1() {
	for(int i = 0; i <= 40; i++){
		co_await coro::sleep(1s);
		std::println("1");
	}
	co_return;
}

coro::Lazy<std::string_view> coro2() {
	for(int i = 0; i <= 40; i++) {
		co_await coro::sleep(1s);
		std::println("2");
	}
	co_return "FINISHED";
}

What I want to do is like the code below in JavaScript:

async function run() {
    // Launch coro1 without blocking
    coro1().finally(() => { console.log("coro1 done"); });
    // Launch coro2, block until coro2 `co_return`
    const coro2Result= await coro2();
    console.log(coro2Result);
}

I try to write code like this, but it doesn't work as expected

coro::Lazy<> run() {
	coro1().start([](auto &&_) {});
	auto coro2Result = co_await coro2();
	std::cout << coro2Result << '\n';
	co_return;
}

int main() {
	coro::syncAwait(run());
	return 0;
}

Result: run will block at line coro1().start([](auto &&_) {}); until coro1 finishes

p.s. co_await coro::sleep(1s); works here because, this function will simply sleep the thread, if there's no executor.

[ChihHao-Su]

This is bad, we should provide a full-functional, out-of-box executor to users.

[ChuanqiXu9]

By design, the users can and should provide their own executors.

[ChuanqiXu9]

It will be better to call via() for lazy to bind an executor for it.