Fix right-associative-extension-methods.md

Author: Sporarum

docs/_docs/reference/contextual/right-associative-extension-methods.md

@@ -4,46 +4,54 @@ title: "Right-Associative Extension Methods: Details"
 nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual/right-associative-extension-methods.html
 ---
 
-The most general form of leading parameters of an extension method is as follows:
-
+The most general signature an extension method can have is as follows:
+  - An optional type clause `leadingTyParamss`
   - A possibly empty list of using clauses `leadingUsing`
-  - A single parameter `extensionParam`
+  - A single parameter `leftParamss`
   - A possibly empty list of using clauses `trailingUsing`
+  - A name (preceded by the `def` keyword)
+  - An optional type clause `rightTyParamss`
+  - An optional explicit term clause `rightParamss`
+  - Any number of any clauses `rest`
 
-This is then followed by `def`, the method name, and possibly further parameters
-`otherParams`. An example is:
+For example:
 
 ```scala
-  extension (using a: A, b: B)(using c: C)    // <-- leadingUsing
-            (x: X)                            // <-- extensionParam
+  extension [T]                               // <-- leadingTyParamss
+            (using a: A, b: B)(using c: C)    // <-- leadingUsing
+            (x: X)                            // <-- leftParamss
             (using d: D)                      // <-- trailingUsing
-    def +:: (y: Y)(using e: E)(z: Z)          // <-- otherParams
+    def +:: [U]                               // <-- rightTyParamss
+            (y: Y)                            // <-- rightParamss
+            [V](using e: E)[W](z: Z)          // <-- rest
 ```
 
+
 An extension method is treated as a right-associative operator
 (as in [SLS §6.12.3](https://www.scala-lang.org/files/archive/spec/2.13/06-expressions.html#infix-operations))
-if it has a name ending in `:` and is immediately followed by a
-single parameter. In the example above, that parameter is `(y: Y)`.
+if it has a name ending in `:`, and is immediately followed by a
+single explicit term parameter (in other words, `rightParamss` is present). In the example above, that parameter is `(y: Y)`.
 
 The Scala compiler pre-processes a right-associative infix operation such as `x +: xs`
 to `xs.+:(x)` if `x` is a pure expression or a call-by-name parameter and to `val y = x; xs.+:(y)` otherwise. This is necessary since a regular right-associative infix method
 is defined in the class of its right operand. To make up for this swap,
-the expansion of right-associative extension methods performs an analogous parameter swap. More precisely, if `otherParams` consists of a single parameter
-`rightParam` followed by `remaining`, the total parameter sequence
+the expansion of right-associative extension methods performs the inverse parameter swap. More precisely, if `rightParamss` is present, the total parameter sequence
 of the extension method's expansion is:
 
 ```
-    leadingUsing  rightParam  trailingUsing  extensionParam  remaining
+    leadingTyParamss  leadingUsing  rightTyParamss  rightParamss  leftParamss  trailingUsing  rest
 ```
 
 For instance, the `+::` method above would become
 
 ```scala
-  <extension> def +:: (using a: A, b: B)(using c: C)
+  <extension> def +:: [T]
+                      (using a: A, b: B)(using c: C)
+                      [U]
                       (y: Y)
-                      (using d: D)
                       (x: X)
-                      (using e: E)(z: Z)
+                      (using d: D)
+                      [V](using e: E)[W](z: Z)
 ```
 
 This expansion has to be kept in mind when writing right-associative extension