T f(T1 a1, T2 a2 ...) {

   co_await ...
   co_return ...
}

T f(T1 a1, T2 a2 ...) {
struct Arguments {
  coroutine_traits<T, T1, T2...>::promise_type this_corutine;
  T1 a1;
  T2 a2;
};
  Arguments args { coroutine_traits::promise_type, std::move(a1), std::move(a2) ... };
  ...
  return args->this_corutine.get_return_object();
}

auto res = co_await fnested(...);

TResult fnested(...)

  auto fnested_awaiter = operator co_await(fnested(...));

  auto rest_code = [std::move(fnested_awaiter), std::move(args)]() {
      auto res = fnested_awaiter.await_resume();
      ...//Rest code
  };

  if(!fnested_awaiter.await_ready()){
    //Suspend
    fnested_awaiter.await_suspend(std::move(rest_code));
  } else {
    rest_code();
  }

T f(T1 a1, T2 a2 ...) {

   auto res = co_await fnested(...);
   co_return ...;
}

T f(T1 a1, T2 a2 ...) {
 struct Arguments {
  coroutine_traits<T, T1, T2...>::promise_type this_corutine;
  T1 a1;
  T2 a2;
 };
 Arguments args { coroutine_traits::promise_type, std::move(a1), std::move(a2) ... };
 
 auto fnested_awaiter = operator co_await(fnested(...));
 auto rest_code = [std::move(fnested_awaiter), std::move(args)]() {
      auto res = fnested_awaiter.await_resume();
      args->this_corutine.return_value(...);//co_return ...;
  };
 if(!fnested_awaiter.await_ready()){
  //Suspend
  fnested_awaiter.await_suspend(std::move(rest_code));
 } else {
  rest_code();
 }
 return args->this_corutine.get_return_object();
}

В послевоенные годы множество калек нуждались в помощи пластических хирургов.

std::function<void()> type_erased_labmda = [=]{ ... };

std::function<int()> make();

void someNestedFunction(coro someCoro)
{
    int a = soSomething();
    if (nothing())
    {
        someCoro.yield();
        use(a);  // упс.
    }
}

R>>>а за этим потянется и расщирения стека и перемещение объектов по стеку не нарушая их состояния, наверняка у комитета от этого взрывался мозг

R> при расширении границы стека это неизбежно,

R>>>следить ручками и глазками за размером стека и пытаться сразу же угадать сколько нужно аллоцировать памяти на очередной фрейм это

EP>>Размер фрейма любой функции тривиально известен во время компиляции. Глубина прыжков stackless корутин огранична scope'ом одной фукции, что в C++20, что в C#, что в Python, на то они и stackless. Поэтому и размер корутины, как и её конкретный тип легко может быть известен во время компиляции

https://www.boost.org/doc/libs/1_75_0/libs/coroutine2/doc/html/coroutine2/stack/segmented.html
Boost.Coroutine2 supports usage of a segmented_stack, e. g. the size of the stack grows on demand. The coroutine is created with a minimal stack size and will be increased as required

https://en.cppreference.com/w/cpp/language/coroutines
Each coroutine is associated with
* the coroutine state, which is an internal, heap-allocated (unless the allocation is optimized out)

EP>std::function<void()> type_erased_labmda = [=]{ ... };
EP>

EP>Это привело бы к неменуемым аллокациям (разные замыканиия имеют разный контекст, и соответсвенно разный размер, и поэтому все не могут быть сохранены целиком в один и тот же тип sizeof которого фиксирован), и проблемам с оптимизацией. Вот в случае с сабжем, мы именно это и получили

template<typename U>
    void await_suspend(std::experimental::coroutine_handle<U> hndl) noexcept {
      this->_future.then([hndl]() mutable {
        hndl();
      });

template<typename U, typename... Locals>
    void await_suspend(U hndl, Locals args...) noexcept {
      this->_future.then(hndl, std::forward<Locals>(args));

х>template<typename U, typename... Locals>
х>    void await_suspend(U hndl, Locals args...) noexcept {
      this->>_future.then(hndl, std::forward<Locals>(args));
х>

template<typename R, typename... Args> struct coroutine_traits;

template<typename ConcreteCoroutine, typename R, typename... Args> struct coroutine_traits;

generator<int> iota(int n);

generator<int> even(int n);

EP>>generator<int> iota(int n);
EP>>

EP>>generator<int> even(int n);
EP>>

generator<int> three()
{
    co_yield 1;
    co_yield 2;
    co_yield 3;
}

for(auto g=three(); g;)
    print(g());

EP>>>generator<int> iota(int n);
EP>>>

EP>>>generator<int> even(int n);
EP>>>

generator<int> iota(int n);
generator<int> even(int n);

generator<int> (*p)(int n) = (test ? iota : even);
(*p)(n);