Num operator+(const Num& rhs) const & { ... }
Num operator+(const Num& rhs) && { ... }
Num operator+(Num&& rhs) const & { ... }
Num operator+(Num&& rhs) && { ... }

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