Add a few more bits from SE-0393.

Author: amartini51

TSPL.docc/GuidedTour/GuidedTour.md

@@ -2357,6 +2357,17 @@ anyCommonElements([1, 2, 3], [3])
 Writing `<T: Equatable>`
 is the same as writing `<T> ... where T: Equatable`.
 
+Use `repeat` and `each` to make generic functions
+where the number of arguments can vary.
+
+```
+func printEach<each T>(_ t: repeat each T) {
+  repeat print(each t)
+}
+
+printEach(1, "hello", true)
+```
+
 > Beta Software:
 >
 > This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software.

TSPL.docc/LanguageGuide/Generics.md

@@ -2007,7 +2007,7 @@ What else can you repeat?
 How do you repeat more than one type?
 
 - In the simple case, where only one type repeats,
-  this means you write `repeat each T` or similar.
+  you write `repeat each T` or similar.
 
 - For collections or other generic types,
   the pack expansion can happen inside,
@@ -2035,6 +2035,12 @@ How do you constrain the types in a parameter pack?
 - In the more complex case,
   use `repeat each T ` in a trailing `where` clause.
 
+- You must restrict the types that appear in a type-parameter pack;
+  conformance requirements don't implicitly propagate.
+  For example, given `each T: Hashable` writing `repeat Set<each T>` works,
+  but it doesn't work with just `each T`
+  because `Set` requires `T` to be hashable but the pack doesn't.
+
 How do you access the values of a parameter pack?
 
 - Inside the function body, you use `repeat`

TSPL.docc/ReferenceManual/Expressions.md

@@ -1527,7 +1527,7 @@ A single expression inside parentheses is a parenthesized expression.
 
 XXX OUTLINE:
 
-- a `repeat` expression must contain one or more `each` expressions
+- A `repeat` expression must contain one or more `each` expressions
   and has the shape `repeat <#repetition pattern#>`
 
 - TODO list of contexts where expansion is supported
@@ -1538,11 +1538,27 @@ XXX OUTLINE:
 
 - The *repetition pattern* is repeated once for each type in the pack
 
-- all of the `each` expressions must expand packs with the same number of types
+- If an expression includes both the `repeat` operator and
+  a `try` or `await` operator,
+  the `repeat` operator must appear first.
+  (So `repeat try each foo` or `repeat each try foo`)
+
+- All of the `each` expressions in a parameter-pack expression
+  must expand packs that have the same number of types.
+
+- In a function declaration,
+  an argument whose type is a parameter-pack expansion type
+  must be the last parameter
+  or the parameter after it must have a label.
 
 - It's valid for a pack expression contain no elements,
   in which case the parameter-pack expansion expression isn't evaluated at all (zero times)
 
+<!--
+You can't write ( immediately after `each`
+because `each(` is parsed as a function call.
+-->
+
 > Grammar of a pack-expansion expression:
 >
 > *parameter-pack-expression* → **`each`** *expression*