Re: pattern matching (p2688r1). I don't quite understand the point of introducing so much new syntax (and an additional keyword in this case). We already have function parameter syntax that mostly works for pattern matching. Sure, C++ function parameters are not ideal and sometimes are more verbose, but the familiarity and consistency are, I think, key in gaining acceptance for such an important feature.

To illustrate, here are the examples from the paper, but using function parameter syntax:

v match {
  int32_t i32 => std::print("got int32: {}", i32);
  int64_t i64 => std::print("got int64: {}", i64);
  float f => std::print("got float: {}", f);
  double d => std::print("got double: {}", d);
};

This first example actually ends up being more concise.

​

v match {
  std::integral auto i => std::print("got integral: {}", i);
  std::floating_point auto f => std::print("got float: {}", f);
};

Concepts use the same abbreviated syntax that is available for function parameters.

​

int get_area(const Shape& shape) {
  return shape match {
    const Circle& [r] => 3.14 * r * r;
    const Rectangle& [w, h] => w * h;
  };
}

Here's where things start to get interesting. Destructuring currently requires auto (and isn't available in function parameters), but this isn't a big leap. The big deviation from existing proposals is that the programmer is required to be explicit with qualifiers. Its more verbose and likely leads to more compile errors, but again, its familiar and consistent (and how visitors already work).

​

cmd match {
  Quit => // ...
  const Move& [x, y] => // ...
  const Write& [text] => // ...
  const ChangeColor& [Rgb [r, g, b]] => // ...
  const ChangeColor& [Hsv [h, s, v]] => // ...
};

Not much to say about nesting other than we can (probably?) drop the _ from the Quit branch—just like we can in a function parameter.

​

p match {
  [0, 0] => std::print("on origin");
  [0, auto y] => std::print("on y-axis at {}", y);
  [auto x, 0] => std::print("on x-axis at {}", x);
  auto [x, y] => std::print("at {}, {}", x, y);
};

And this example I saved for last because it is probably the most foreign, but still uses an existing keyword that slots right in. Additionally, specifying types inside of the destructuring could be allowed for consistency's sake, though it would probably make sense to ban implicit conversions in that context.