constexpr, consteval, and Coroutines

The interaction between constexpr/consteval and coroutines is an interesting topic in C++20 and beyond. Let's explore this:

As of C++20, coroutines cannot be constexpr or consteval. The coroutine machinery involves runtime operations that are not compatible with compile-time evaluation.

First, let's recall what a basic coroutine looks like:

1#include <coroutine>
2#include <iostream>
3
4struct MyCoroutine {
5  struct promise_type {
6    int value;
7    MyCoroutine get_return_object() {
8      return MyCoroutine{this};
9    }
10    std::suspend_always initial_suspend() {
11      return {};
12    }
13    std::suspend_always final_suspend() noexcept {
14      return {};
15    }
16    void unhandled_exception() {}
17    std::suspend_always yield_value(int v) {
18      value = v;
19      return {};
20    }
21  };
22
23  std::coroutine_handle<promise_type> h;
24  MyCoroutine(promise_type* p)
25    : h(std::coroutine_handle<
26      promise_type>::from_promise(*p)) {}
27  ~MyCoroutine() {
28    if (h) h.destroy();
29  }
30};
31
32MyCoroutine simple_coroutine() {
33  co_yield 1;
34  co_yield 2;
35  co_yield 3;
36}
37
38int main() {
39  auto cor = simple_coroutine();
40  for (int i = 0; i < 3; ++i) {
41    cor.h.resume();
42    std::cout << cor.h.promise().value << ' ';
43  }
44}

11 2 3

Coroutines involve several runtime operations:

• Memory allocation for the coroutine frame
• Suspension and resumption of execution
• Potential dynamic dispatch through virtual function calls

These operations are not compatible with compile-time evaluation, which is why coroutines can't be constexpr or consteval.

While coroutines themselves can't be constexpr, you can still use constexpr functions to generate or manipulate coroutine-related data:

1#include <array>
2#include <coroutine>
3#include <iostream>
4
5constexpr std::array<int, 3> generate_values() {
6  return {1, 2, 3};
7}
8
MyCoroutine Struct|Show
9struct MyCoroutine {/*...*/};
34
35MyCoroutine value_coroutine() {
36  constexpr auto values = generate_values();
37  for (int v : values) {
38    co_yield v;
39  }
40}
41
42int main() {
43  auto cor = value_coroutine();
44  for (int i = 0; i < 3; ++i) {
45    cor.h.resume();
46    std::cout << cor.h.promise().value << ' ';
47  }
48}

11 2 3

The C++ committee is discussing potential ways to make coroutines more compile-time friendly in future standards. Some proposals include:

However, as of C++20, these are still in the proposal stage and not part of the standard.

• Compile-time coroutines for metaprogramming
• Static coroutines that don't require dynamic allocation

For compile-time sequential computation, you might consider using template metaprogramming techniques instead of coroutines:

While this approach is less intuitive than coroutines, it achieves compile-time sequential computation.

1#include <iostream>
2
3template <int... Sequence>
4struct sequence {};
5
6template <int N, int... Sequence>
7struct generate_sequence : generate_sequence<
8  N - 1, N - 1, Sequence...> {};
9
10template <int... Sequence>
11struct generate_sequence<0, Sequence...> {
12  using type = sequence<Sequence...>;
13};
14
15template <int... Seq>
16constexpr void print_sequence(sequence<Seq...>) {
17  ((std::cout << Seq << ' '), ...);
18}
19
20int main() {
21  print_sequence(
22    typename generate_sequence<3>::type{}
23  );
24}

10 1 2

In conclusion, while coroutines themselves cannot be constexpr or consteval in C++20, you can still use compile-time computation in conjunction with coroutines.

As the language evolves, we may see more integration between compile-time evaluation and coroutines in future C++ standards.