Use _ to simplify some pattern matching code examples

Author: ShapelessCat

docs/docs/reference/changed-features/match-syntax.md

@@ -11,9 +11,9 @@ The syntactical precedence of match expressions has been changed.
     ```scala
     xs match {
        case Nil => "empty"
-       case x :: xs1 => "nonempty"
+       case _   => "nonempty"
     } match {
-       case "empty" => 0
+       case "empty"    => 0
        case "nonempty" => 1
     }
     ```
@@ -23,7 +23,7 @@ The syntactical precedence of match expressions has been changed.
     ```scala
     xs match
        case Nil => "empty"
-       case x :: xs1 => "nonempty"
+       case _   => "nonempty"
     match
        case "empty" => 0
        case "nonempty" => 1
@@ -34,7 +34,7 @@ The syntactical precedence of match expressions has been changed.
      ```scala
      if xs.match
         case Nil => false
-        case _ => true
+        case _   => true
      then "nonempty"
      else "empty"
      ```
@@ -46,7 +46,7 @@ The syntactical precedence of match expressions has been changed.
 
 The new syntax of match expressions is as follows.
 
-```
+```ebnf
 InfixExpr    ::=  ...
                |  InfixExpr MatchClause
 SimpleExpr   ::=  ...

docs/docs/reference/contextual/extension-methods.md

@@ -76,30 +76,38 @@ extension [T: Numeric](x: T)
 
 Type parameters on extensions can also be combined with type parameters on the methods
 themselves:
+
 ```scala
 extension [T](xs: List[T])
    def sumBy[U](f: T => U)(using Numeric[U]): U = ...
 ```
 
 Type arguments matching method type parameters are passed as usual:
+
 ```scala
 List("a", "bb", "ccc").sumBy[Int](_.length)
 ```
+
 By contrast, type arguments matching type parameters following `extension` can be passed
 only if the method is referenced as a regular method:
+
 ```scala
 List[String]("a", "bb", "ccc").sumBy(_.length)
 ```
+
 or, passing, both type arguments
+
 ```scala
 List[String]("a", "bb", "ccc").sumBy[Int](_.length)
 ```
+
 Extensions can also take using clauses. For instance, the `+` extension above could equivalently be written with a using clause:
 
 ```scala
 extension [T](x: T)(using n: Numeric[T])
    def + (y: T): T = n.plus(x, y)
 ```
+
 ### Collective Extensions
 
 Sometimes, one wants to define several extension methods that share the same
@@ -214,7 +222,7 @@ class List[T]:
 object List:
    ...
    extension [T](xs: List[List[T]])
-      def flatten: List[T] = xs.foldLeft(Nil: List[T])(_ ++ _)
+      def flatten: List[T] = xs.foldLeft(List.empty[T])(_ ++ _)
 
    given [T: Ordering]: Ordering[List[T]] with
       extension (xs: List[T])
@@ -276,7 +284,7 @@ def position(s: String)(ch: Char, n: Int): Int =
 Here are the syntax changes for extension methods and collective extensions relative
 to the [current syntax](../syntax.md).
 
-```
+```ebnf
 BlockStat         ::=  ... | Extension
 TemplateStat      ::=  ... | Extension
 TopStat           ::=  ... | Extension

docs/docs/reference/enums/adts.md

@@ -65,7 +65,7 @@ enum Option[+T]:
 
    def isDefined: Boolean = this match
       case None => false
-      case some => true
+      case _    => true
 
 object Option:
 
@@ -153,7 +153,7 @@ The changes are specified below as deltas with respect to the Scala syntax given
 
  1. Enum definitions are defined as follows:
 
-    ```
+    ```ebnf
     TmplDef   ::=  `enum' EnumDef
     EnumDef   ::=  id ClassConstr [`extends' [ConstrApps]] EnumBody
     EnumBody  ::=  [nl] ‘{’ [SelfType] EnumStat {semi EnumStat} ‘}’
@@ -163,7 +163,7 @@ The changes are specified below as deltas with respect to the Scala syntax given
 
  2. Cases of enums are defined as follows:
 
-    ```
+    ```ebnf
     EnumCase  ::=  `case' (id ClassConstr [`extends' ConstrApps]] | ids)
     ```