Proposal: Variadics

[geoffromer]

Proposes a set of core features for declaring and implementing generic variadic
functions.

A "pack expansion" is a syntactic unit beginning with ..., which is a kind of
compile-time loop over sequences called "packs". Packs are initialized and
referred to using "pack bindings", which are marked with the each keyword at
the point of declaration and the point of use.

The syntax and behavior of a pack expansion depends on its context, and in some
cases by a keyword following the ...:

• In a tuple literal expression (such as a function call argument list), ...
  iteratively evaluates its operand expression, and treats the values as
  successive elements of the tuple.
• ...and and ...or iteratively evaluate a boolean expression, combining
  the values using and and or, and ending the loop early if the underlying
  operator short-circuits.
• In a statement context, ... iteratively executes a statement.
• In a tuple literal pattern (such as a function parameter list), ...
  iteratively matches the elements of the scrutinee tuple. In conjunction with
  pack bindings, this enables functions to take an arbitrary number of
  arguments.

[josh11b]

I made another pass without diving into the type checking bits, since those seem like something that could be handled in a separate proposal once the other issues are handled.

[josh11b]

Looking good! I think this is ready for leads review.

[chandlerc]

Reviewed all but the appendix (largely trusting Josh's review there) and generally pretty happy across the board. Left a bunch of comments, but mostly minor wording / presentation improvements.

[zygoloid]

@josh11b asked me whether I'd write / prefer the form with if constexpr (with two termination conditions) or the form with the extra function overload. I said I'd actually write this:

Suggested change

	```cpp
	template <ConvertibleToString... Ts>
	std::string StrCat(const Ts&... params) {
	std::string result;
	result.reserve((params.Length() + ... + 0));
	StrCatImpl(&result, params...);
	return result;
	if constexpr (sizeof...(params) == 0) {
	return "";
	} else {
	std::string result;
	result.reserve((params.Length() + ... + 0));
	StrCatImpl(&result, params...);
	return result;
	}
	}
	void StrCatImpl(std::string* out) { return; }
	template <ConvertibleToString T, ConvertibleToString... Ts>
	void StrCatImpl(std::string* out, const T& first, const Ts&... rest) {
	out->append(first.ToString());
	StrCatImpl(out, rest...);
	if constexpr (sizeof...(rest) > 0) {
	StrCatImpl(out, rest...);
	}
	}
	```
	```cpp
	template <ConvertibleToString... Ts>
	std::string StrCat(const Ts&... params) {
	std::string result;
	result.reserve((params.Length() + ... + 0));
	(out->append(params.ToString()), ...);
	return result;
	}
	```

[geoffromer]

Me too, but I don't think that's representative of what a typical C++ programmer would do in this situation, so this gets back to the question of whether we want the C++ examples to reflect typical usage or expert usage (see also this comment thread).

Addressed

[chandlerc]

I think this LG, but should confirm that other leads don't want a last look.

[chandlerc]

I think this LG, but should confirm that other leads don't want a last look.