Change some code examples to follow the Scala coding style conventions

Author: ShapelessCat

docs/docs/reference/contextual/givens.md

@@ -134,7 +134,7 @@ object Foo:
    given fooTagged[A](using Tagged[A]): Foo[A] = Foo(true)
    given fooNotTagged[A](using NotGiven[Tagged[A]]): Foo[A] = Foo(false)
 
-@main def test() =
+@main def test(): Unit =
    given Tagged[Int] with {}
    assert(summon[Foo[Int]].value) // fooTagged is found
    assert(!summon[Foo[String]].value) // fooNotTagged is found
@@ -150,7 +150,7 @@ is created for each reference.
 
 Here is the syntax for given instances:
 
-```
+```ebnf
 TmplDef             ::=  ...
                      |   ‘given’ GivenDef
 GivenDef            ::=  [GivenSig] StructuralInstance

docs/docs/reference/dropped-features/nonlocal-returns.md

@@ -19,7 +19,7 @@ extension [T](xs: List[T])
       false
    }
 
-@main def test =
+@main def test(): Unit =
    val xs = List(1, 2, 3, 4, 5)
    assert(xs.has(2) == xs.contains(2))
 ```

docs/docs/reference/enums/desugarEnums.md

@@ -127,7 +127,6 @@ map into `case class`es or `val`s.
    starting from 0. The anonymous class also
    implements the abstract `Product` methods that it inherits from `Enum`.
 
-
    It is an error if a value case refers to a type parameter of the enclosing `enum`
    in a type argument of `<parents>`.
 
@@ -198,6 +197,7 @@ Even though translated enum cases are located in the enum's companion object, re
 this object or its members via `this` or a simple identifier is also illegal. The compiler typechecks enum cases in the scope of the enclosing companion object but flags any such illegal accesses as errors.
 
 ### Translation of Java-compatible enums
+
 A Java-compatible enum is an enum that extends `java.lang.Enum`. The translation rules are the same as above, with the reservations defined in this section.
 
 It is a compile-time error for a Java-compatible enum to have class cases.
@@ -206,9 +206,9 @@ Cases such as `case C` expand to a `@static val` as opposed to a `val`. This all
 
 ### Other Rules
 
- - A normal case class which is not produced from an enum case is not allowed to extend
-`scala.reflect.Enum`. This ensures that the only cases of an enum are the ones that are
-explicitly declared in it.
+- A normal case class which is not produced from an enum case is not allowed to extend
+  `scala.reflect.Enum`. This ensures that the only cases of an enum are the ones that are
+  explicitly declared in it.
 
- - If an enum case has an `extends` clause, the enum class must be one of the
-   classes that's extended.
+- If an enum case has an `extends` clause, the enum class must be one of the
+  classes that's extended.

docs/docs/reference/enums/enums.md

@@ -93,6 +93,7 @@ end Planet
 As a library author, you may want to signal that an enum case is no longer intended for use. However you could still want to gracefully handle the removal of a case from your public API, such as special casing deprecated cases.
 
 To illustrate, say that the `Planet` enum originally had an additional case:
+
 ```diff
  enum Planet(mass: Double, radius: Double):
     ...
@@ -128,9 +129,11 @@ object Planet {
    }
 }
 ```
+
 We could imagine that a library may use [type class derivation](../contextual/derivation.md) to automatically provide an instance for `Deprecations`.
 
 ### Compatibility with Java Enums
+
 If you want to use the Scala-defined enums as [Java enums](https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html), you can do so by extending
 the class `java.lang.Enum`, which is imported by default, as follows:
 

docs/docs/reference/metaprogramming/tasty-inspect.md

@@ -22,11 +22,11 @@ import scala.quoted.*
 import scala.tasty.inspector.*
 
 class MyInspector extends Inspector:
-    def inspect(using Quotes)(tastys: List[Tasty[quotes.type]]): Unit =
+   def inspect(using Quotes)(tastys: List[Tasty[quotes.type]]): Unit =
       import quotes.reflect.*
       for tasty <- tastys do
-        val tree = tasty.ast
-        // Do something with the tree
+         val tree = tasty.ast
+         // Do something with the tree
 ```
 
 Then the consumer can be instantiated with the following code to get the tree of the `foo/Bar.tasty` file.
@@ -36,7 +36,6 @@ object Test:
    def main(args: Array[String]): Unit =
       val tastyFiles = List("foo/Bar.tasty")
       TastyInspector.inspectTastyFiles(tastyFiles)(new MyInspector)
-
 ```
 
 Note that if we need to run the main (in the example below defined in an object called `Test`) after compilation we need to make the compiler available to the runtime: