Simplify the description of same-type requirements involving parameter packs.

Author: hborla

proposals/NNNN-parameter-packs.md

@@ -365,47 +365,28 @@ All existing kinds of generic requirements generalize to type parameter packs. S
   func variadic<each S>(_: repeat each S) where each S: Sequence { ... }
   ```
 
-  A valid substitution for the above might replace `S` with `{Array<Int>, Set<String>}`.
+  A valid substitution for the above might replace `S` with `{Array<Int>, Set<String>}`. Expanding the substitution into the requirement `each S: Sequence` conceptually produces the following conformance requirements: `Array<Int>: Sequence, Set<String>: Sequence`.
 
-2. A same-type requirement where one side is a type parameter pack and the other type is a concrete type that does not capture any type parameter packs is interpreted as constraining each element of the replacement type pack to _the same_ concrete type:
+2. A same-type requirement where one side is a type parameter pack and the other type is a scalar type that does not capture any type parameter packs is interpreted as constraining each element of the replacement type pack to _the same_ scalar type:
 
   ```swift
   func variadic<each S: Sequence, T>(_: repeat each S) where (each S).Element == T {}
   ```
 
-  This is called a _concrete same-element requirement_.
+  This is called a _same-element requirement_.
 
   A valid substitution for the above might replace `S` with `{Array<Int>, Set<Int>}`, and `T` with `Int`.
 
-3. A same-type requirement where one side is a type parameter pack and the other type is a scalar type parameter is interpreted as constraining each element of the replacement type pack to the type parameter:
 
-  ```swift
-  func variadic<each S: Sequence, each T>(_: repeat each S) where (each S).Element == each T {}
-  ```
-
-  This is called an _abstract same-element requirement_.
-
-  A valid substitution for the above might replace `S` with `{Array<Int>, Set<String>}`, and `T` with `{Int, String}`.
-
-4. A same-type requirement where one side is a type parameter pack and the other side is a concrete type capturing at least one type parameter pack is interpreted as expanding the concrete type and constraining each element of the replacement type pack to the concrete element type:
+3. A same-type requirement where each side is a pattern type that captures at least one type parameter pack is interpreted as expanding the type packs on each side of the requirement, equating each element pair-wise.
 
   ```swift
   func variadic<each S: Sequence, each T>(_: repeat each S) where (each S).Element == Array<each T> {}
   ```
 
-  This is called a _concrete same-type pack requirement_.
-
-  A valid substitution for the above might replace `S` with `{Array<Array<Int>>, Set<Array<String>>}`, and `T` with `{Int, String}`.
-
-5. A same-type requirement where both sides are type parameter packs constrains the elements of the replacement type pack element-wise:
-
-  ```swift
-  func append<each S: Sequence, each T: Sequence>(_: repeat each S, _: repeat each T) where (each T).Element == (each S).Element {}
-  ```
-  
-  This is called an _abstract same-type pack requirement_.
+  This is called a _same-type-pack requirement_.
 
-  A valid substitution for the above would replace `S` with `{Array<Int>, Set<String>}`, and `T` with `{Set<Int>, Array<String>}`.
+  A valid substitution for the above might replace `S` with `{Array<Array<Int>>, Set<Array<String>>}`, and `T` with `{Int, String}`. Expanding `(each S).Element == Array<each T>` will produce the following list of same-type requirements: `Array<Array<Int>.Element == Array<Int>, Set<Array<String>>.Element == String`.
 
 There is an additional kind of requirement called a _same-shape requirement_. There is no surface syntax for spelling a same-shape requirement; they are always inferred, as described in the next section.