template<typename T>
decltype(auto) avg(T x, T y)
    noexcept(noexcept((x + y) / 2))
    requires requires { (x + y) / 2; }
{
    return (x + y) / 2;
}

std::tuple<X, Y, Z> f();

auto [...xs] = f();           // OK
auto [x, ...rest] = f();      // OK
auto [x,y,z, ...rest] = f();  // OK
auto [x, ...rest, z] = f();   // OK

auto a = [mutable x, y]() {
  x = 1;  // OK
  y = 2;  // Error
};

struct Foo { int x; double y; std::string z; };

Foo x{1, 2.0, "3"};
std::get<1>(x);  // Evaluate to 2.0
static_assert(std::is_same_v<
  std::string,
  typename std::tuple_element<2, Foo>::type
>);  // OK
static_assert(std::tuple_size<Foo> == 3);  // OK

const int &foo() {
  return 42;  // Ill-formed
}

void throws_nothing() throw();  // Effectively `noexcept`
void throws_a_b() throw(A, B);  // throws_a_b can throw A or B
void throws_any() throw(...);   // throws_any may throw any exception

void foo() throw(auto) { /* ... */ }

void foo() throw(A) {
  throws_a_b(); // Ill-formed: B is not listed above

  try {
    throws_a_b(); // Ill-formed: B is not caught
  }
  catch (A) {}

  try {
    throws_a_b(); // OK since B will be caught
  }
  catch (A) {}
  catch (B) {}
}

void foo(int ...);  // Ill-formed

#define FN(f...) [&]<typename... Args>(Args&&... args)->decltype(auto){return (f)(std::forward<Args>(args)...);}

#define FN(f) \
  [&]<typename ...Args>(Args &&...args) -> decltype(auto) \
    requires requires { (f)(std::forward<Args>(args)...); } \
  { return (f)(std::forward<Args>(args)...); }

[&]
<typename... Ts>
requires something<Ts...>
[[noreturn]]
(Ts&&... ts)
mutable
noexcept(true)
[[another_attr]]
-> decltype(auto)
requires requires { someThing(ts...); }
pre(somePre(ts...))
{
  ohFinallyTheBody();
}

template<size_t i>
consteval void count_to_one() {
    if constexpr (i <= 1) {
        return;
    }

    char buffer[i];
    if constexpr (i % 2 == 0) {
        // ... do something if `i` is even
        return count_to_one<i - 1>();
    } else {
        // ... do something if `i` is odd
        return count_to_one<i - 1>();
    }
}

int main() {
    count_to_one<10>();
}