Fill in the discussion in the guide

- Start with the generic syntax, since that's what readers have seen in
  previous chapters already.
- Walk through an example of using 'some' more than once.
- Match func/subscript/init order in prose to chapter ordering.

Author: amartini51

TSPL.docc/LanguageGuide/OpaqueTypes.md

@@ -925,41 +925,57 @@ which means that the type of `twelve` is also inferred to be `Int`.
 ## Opaque Parameter Types
 
 In addition to writing `some` to return an opaque type,
-you can also write `some` in the type for a parameter.
+you can also write `some` in the type for a parameter
+to a function, subscript, or initializer.
 However, when you write `some` in a parameter type
 that's just a shorter syntax for generics, not an opaque type.
 For example,
 both of the functions below are equivalent:
 
 ```swift
-func drawTwiceSome(_ shape: some Shape) -> String {
+func drawTwiceGeneric<SomeShape: Shape>(_ shape: SomeShape) -> String {
     let drawn = shape.draw()
     return drawn + "\n" + drawn
 }
 
-func drawTwiceGeneric<SomeShape: Shape>(_ shape: SomeShape) -> String { ... }
+func drawTwiceSome(_ shape: some Shape) -> String {
+    let drawn = shape.draw()
+    return drawn + "\n" + drawn
+}
 ```
 
+The `drawTwiceGeneric(_:)` function
+uses a generic type parameter named `SomeShape`,
+and explicitly includes the protocol conformance requirement.
 The `drawTwiceSome(_:)` function
 uses the type `some Shape` for its argument.
 This creates a new, unnamed, generic type parameter for the function
 with a constraint that requires the type to conform to the `Shape` protocol.
 Because the generic type doesn't have a name,
 you can't refer to that type elsewhere in the function.
-The `drawTwiceGeneric(_:)` function
-uses a generic type parameter named `SomeShape`,
-and explicitly includes the protocol conformance requirement.
 
-XXX Every parameter's type is independent
+If you write `some` before more than one parameter's type,
+each of the generic types are independent.
+For example:
 
 ```swift
 func combine(shape s1: some Shape, with s2: some Shape) -> String {
     return s1.draw() + "\n" + s2.draw()
 }
-func combine<S1: Shape, S2: Shape>(shape s1: S1, with s2: S2) -> String { ... }
+
+combine(smallTriangle, trapezoid)
 ```
 
-If you need to multiple generic parameters that are all the same type,
+In the `combine(shape:with:)` function,
+the types of the first and second parameter
+must both conform to the `Shape` protocol,
+but there's no constraint that requires them to be the same type.
+When you call `combine(shape:with)`,
+you can pass two different shapes ---
+in this case, one triangle and one trapezoid.
+If you need to write a function
+that has multiple generic parameters
+and constrain them to be are all the same type,
 use the usual generic syntax instead.
 
 <!--

TSPL.docc/ReferenceManual/Types.md

@@ -864,7 +864,7 @@ that conforms to a protocol or protocol composition,
 without specifying the underlying concrete type.
 
 Opaque types appear as the return type of a function or subscript,
-as the type of a parameter to a function, initializer, or subscript,
+as the type of a parameter to a function, subscript, or initializer,
 or as the type of a property.
 Opaque types can't appear as part of a tuple type or a generic type,
 such as the element type of an array or the wrapped type of an optional.