Adress review comments

Author: odersky

docs/docs/internals/syntax.md

@@ -104,8 +104,7 @@ yield
 ### Soft keywords
 
 ```
-derives   end   extension   inline   infix   opaque   oapque   open
-transparent   using   |   *   +   -
+derives  end  extension  inline  infix  opaque  open  transparent  using  |  *  +  -
 ```
 ## Context-free Syntax
 

docs/docs/reference/changed-features/compiler-plugins.md

@@ -79,11 +79,11 @@ class DivideZeroPhase extends PluginPhase:
 
    override def transformApply(tree: Apply)(implicit ctx: Context): Tree =
       tree match
-      case Apply(Select(rcvr, nme.DIV), List(Literal(Constant(0))))
-          if rcvr.tpe <:< defn.IntType =>
-        report.error("dividing by zero", tree.pos)
-      case _ =>
-        ()
+         case Apply(Select(rcvr, nme.DIV), List(Literal(Constant(0))))
+         if rcvr.tpe <:< defn.IntType =>
+            report.error("dividing by zero", tree.pos)
+         case _ =>
+            ()
       tree
 end DivideZeroPhase
 ```

docs/docs/reference/changed-features/implicit-conversions.md

@@ -44,10 +44,10 @@ types:
 ```scala
 import scala.language.implicitConversions
 implicit def ordT[T, S](
-   implicit conv: Conversion[T, S],
-            ordS: Ordering[S]
-  ): Ordering[T] =
-   // `ordS` compares values of type `S`, but we can convert from `T` to `S`
+      implicit conv: Conversion[T, S],
+               ordS: Ordering[S]
+   ): Ordering[T] =
+    // `ordS` compares values of type `S`, but we can convert from `T` to `S`
    (x: T, y: T) => ordS.compare(x, y)
 
 class A(val x: Int) // The type for which we want an `Ordering`

docs/docs/reference/changed-features/implicit-resolution.md

@@ -13,23 +13,23 @@ where the type may still be inferred:
 ```scala
   class C {
 
-    val ctx: Context = ...        // ok
+     val ctx: Context = ...        // ok
 
-    /*!*/ implicit val x = ...    // error: type must be given explicitly
+     /*!*/ implicit val x = ...    // error: type must be given explicitly
 
-    /*!*/ implicit def y = ...    // error: type must be given explicitly
+     /*!*/ implicit def y = ...    // error: type must be given explicitly
   }
   val y = {
-    implicit val ctx = this.ctx // ok
-    ...
+     implicit val ctx = this.ctx // ok
+     ...
   }
 ```
 **2.** Nesting is now taken into account for selecting an implicit. Consider for instance the following scenario:
 ```scala
   def f(implicit i: C) = {
-    def g(implicit j: C) = {
-      implicitly[C]
-    }
+     def g(implicit j: C) = {
+        implicitly[C]
+     }
   }
 ```
 This will now resolve the `implicitly` call to `j`, because `j` is nested
@@ -43,10 +43,10 @@ no longer applies.
   package p
 
   given a: A = A()
-  
+
   object o:
-    given b: B = B()
-    type C
+     given b: B = B()
+     type C
 ```
 Both `a` and `b` are visible as implicits at the point of the definition
 of `type C`. However, a reference to `p.o.C` outside of package `p` will

docs/docs/reference/changed-features/structural-types.md

@@ -126,7 +126,7 @@ than other classes. Here is an example:
 trait Vehicle extends reflect.Selectable:
    val wheels: Int
 
-val i3 = new Vehicle with // i3: Vehicle { val range: Int }
+val i3 = new Vehicle: // i3: Vehicle { val range: Int }
    val wheels = 4
    val range = 240
 
@@ -139,10 +139,10 @@ defines the necessary `selectDynamic` member.
 
 `Vehicle` could also extend some other subclass of `scala.Selectable` that implements `selectDynamic` and `applyDynamic` differently. But if it does not extend a `Selectable` at all, the code would no longer typecheck:
 ```scala
-class Vehicle:
+trait Vehicle:
    val wheels: Int
 
-val i3 = new Vehicle with // i3: Vehicle
+val i3 = new Vehicle: // i3: Vehicle
    val wheels = 4
    val range = 240
 

docs/docs/reference/contextual/context-functions.md

@@ -141,9 +141,10 @@ does not need boxing either. Hence, the implementation of `ensuring` is as about
 as the best possible code one could write by hand:
 
 ```scala
-  val result = List(1, 2, 3).sum
-  assert(result == 6)
-  result
+val s =
+   val result = List(1, 2, 3).sum
+   assert(result == 6)
+   result
 ```
 ### Reference
 

docs/docs/reference/other-new-features/control-syntax.md

@@ -38,7 +38,7 @@ The rules in detail are:
  - The enumerators of a `for`-expression can be written without enclosing parentheses or braces if they are followed by a `yield` or `do`.
  - A `do` in a `for`-expression expresses a `for`-loop.
  - A `catch` can be followed by a single case on the same line.
-   If there are multiple cases, thesÍe have to be appear within braces (just like in Scala 2)
+   If there are multiple cases, these have to be appear within braces (just like in Scala 2)
    or an indented block.
 ### Rewrites
 

docs/docs/reference/other-new-features/type-test.md

@@ -121,7 +121,7 @@ trait Peano:
    val Zero: Zero
 
    val Succ: SuccExtractor
-   trait SuccExtractor
+   trait SuccExtractor:
       def apply(nat: Nat): Succ
       def unapply(nat: Succ): Option[Nat]
 

docs/docs/reference/syntax.md

@@ -103,8 +103,7 @@ type      val       var       while     with      yield
 ### Soft keywords
 
 ```
-derives   end   extension   inline   infix   opaque   oapque   open
-transparent   using   |   *   +   -
+derives  end  extension  inline  infix  opaque  open  transparent  using  |  *  +  -
 ```
 See the [separate section on soft keywords](./soft-modifier.md) for additional
 details on where a soft keyword is recognized.