Fix docs

- Fix the syntax of a sentence
- Fix a code example

Author: ShapelessCat

docs/docs/reference/changed-features/vararg-splices.md

@@ -7,23 +7,23 @@ The syntax of vararg splices in patterns and function arguments has changed. The
 
 ```scala
 val arr = Array(0, 1, 2, 3)
-val lst = List(arr*)                  // vararg splice argument
+val lst = List(arr*)                    // vararg splice argument
 lst match
-   case List(0, 1, xs*) => println(xs)   // binds xs to Seq(2, 3)
-   case List(1, _*) =>                   // wildcard pattern
+   case List(0, 1, xs*) => println(xs)  // binds xs to Seq(2, 3)
+   case List(1, _*) =>                  // wildcard pattern
 ```
 
 The old syntax for splice arguments will be phased out.
 
 ```scala
-/*!*/ val lst = List(arr: _*)         // syntax error
+/*!*/ val lst = List(arr: _*)      // syntax error
       lst match
-         case List(1, 2, xs @ _*)        // ok, equivalent to `xs*`
+         case List(0, 1, xs @ _*)  // ok, equivalent to `xs*`
 ```
 
 ## Syntax
 
-```
+```ebnf
 ArgumentPatterns  ::=  ‘(’ [Patterns] ‘)’
                     |  ‘(’ [Patterns ‘,’] Pattern2 ‘*’ ‘)’
 
@@ -37,6 +37,3 @@ To enable cross compilation between Scala 2 and Scala 3, the compiler will
 accept both the old and the new syntax. Under the `-source future` setting, an error
 will be emitted when the old syntax is encountered. An automatic rewrite from old
 to new syntax is offered under `-source future-migration`.
-
-
-

docs/docs/reference/metaprogramming/inline.md

@@ -285,11 +285,13 @@ val one: 1 = zero + 1
 ```
 
 ### Transparent vs. non-transparent inline
+
 As we already discussed, transparent inline methods may influence type checking at call site.
 Technically this implies that transparent inline methods must be expanded during type checking of the program.
 Other inline methods are inlined later after the program is fully typed.
 
 For example, the following two functions will be typed the same way but will be inlined at different times.
+
 ```scala
 inline def f1: T = ...
 transparent inline def f2: T = (...): T
@@ -298,7 +300,7 @@ transparent inline def f2: T = (...): T
 A noteworthy difference is the behavior of `transparent inline given`.
 If there is an error reported when inlining that definition, it will be considered as an implicit search mismatch and the search will continue.
 A `transparent inline given` can add a type ascription in its RHS (as in `f2` from the previous example) to avoid the precise type but keep the search behavior.
-On the other hand, `inline given` be taken as the implicit and then inlined after typing.
+On the other hand, an `inline given` is taken as an implicit and then inlined after typing.
 Any error will be emitted as usual.
 
 ## Inline Conditionals