home | help 
std::noop_coroutine(3)	       C++ Standard Libary	  std::noop_coroutine(3)

NAME
     std::noop_coroutine - std::noop_coroutine

Synopsis
	Defined in header <coroutine>
	std::noop_coroutine_handle noop_coroutine() noexcept;  (since C++20)

	Returns a coroutine handle referring to a no-op coroutine.

	If  there  has	been already a coroutine state of no-op coroutine, it is
     unspecified
	whether a subsequent call to noop_coroutine  returns  a  previously  ob-
     tained coroutine
	handle,  or a coroutine handle referring to a new coroutine state of no-
     op coroutine.

Parameters
	(none)

Return value
	A std::noop_coroutine_handle referring to a no-op coroutine.

Notes
	Return values from different calls to noop_coroutine  may  and	may  not
     compare equal.

	noop_coroutine	may  only  return a noop_coroutine_handle referring to a
     coroutine
	state object without starting a coroutine.

Example
     // Run this code

      #include <coroutine>
      #include <iostream>
      #include <utility>

      template<class T>
      struct task
      {
	  struct promise_type
	  {
	      auto get_return_object()
	      {
		  return				task(std::coroutine_han-
     dle<promise_type>::from_promise(*this));
	      }
	      std::suspend_always initial_suspend() { return {}; }
	      struct final_awaiter
	      {
		  bool await_ready() noexcept { return false; }
		  void await_resume() noexcept {}
		  std::coroutine_handle<>
		      await_suspend(std::coroutine_handle<promise_type> h) noex-
     cept
		  {
		      //  final_awaiter::await_suspend is called when the execu-
     tion of the
		      // current coroutine (referred to by 'h') is about to fin-
     ish.
		      // If the current coroutine was resumed by another  corou-
     tine via
		      //  co_await  get_task(),  a  handle to that coroutine has
     been stored
		      // as h.promise().previous. In that case, return the  han-
     dle to resume
		      // the previous coroutine.
		      //  Otherwise,  return  noop_coroutine(), whose resumption
     does nothing.

		      if (auto previous = h.promise().previous; previous)
			  return previous;
		      else
			  return std::noop_coroutine();
		  }
	      };
	      final_awaiter final_suspend() noexcept { return {}; }
	      void unhandled_exception() { throw; }
	      void return_value(T value) { result = std::move(value); }

	      T result;
	      std::coroutine_handle<> previous;
	  };

	  task(std::coroutine_handle<promise_type> h) : coro(h) {}
	  task(task&& t) = delete;
	  ~task() { coro.destroy(); }

	  struct awaiter
	  {
	      bool await_ready() { return false; }
	      T await_resume() { return std::move(coro.promise().result); }
	      auto await_suspend(std::coroutine_handle<> h)
	      {
		  coro.promise().previous = h;
		  return coro;
	      }
	      std::coroutine_handle<promise_type> coro;
	  };
	  awaiter operator co_await() { return awaiter{coro}; }
	  T operator()()
	  {
	      coro.resume();
	      return std::move(coro.promise().result);
	  }

      private:
	  std::coroutine_handle<promise_type> coro;
      };

      task<int> get_random()
      {
	  std::cout << "in get_random()\n";
	  co_return 4;
      }

      task<int> test()
      {
	  task<int> v = get_random();
	  task<int> u = get_random();
	  std::cout << "in test()\n";
	  int x = (co_await v + co_await u);
	  co_return x;
      }

      int main()
      {
	  task<int> t = test();
	  int result = t();
	  std::cout << result << '\n';
      }

Output:
      in test()
      in get_random()
      in get_random()
      8

See also
	noop_coroutine_promise used for coroutines with no observable effects
	(C++20) 	       (class)
	noop_coroutine_handle		  std::coroutine_handle<std::noop_corou-
     tine_promise>, intended
	(C++20) 	       to refer to a no-op coroutine
			       (typedef)

http://cppreference.com 	   2024.06.10		  std::noop_coroutine(3)
home | help