addressed comments

Author: michelou

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

@@ -122,8 +122,7 @@ most (but not all) divergence errors in Scala 2 would terminate the implicit sea
   def buzz(y: A) = ???
   buzz(1)   // error: ambiguous
 ```
-**7.** The rule for picking a _most specific_ alternative among a set of overloaded or implicit alternatives is refined to take context parameters into account. All else being equal, an alternative that takes some context parameters is taken to be less specific than an alternative that takes none. If both alternatives take context parameters, we try to choose between them as if they were methods with regular parameters. The following paragraph in the [SLS §
-6.26.3](https://scala-lang.org/files/archive/spec/2.13/06-expressions.html#overloading-resolution) is affected by this change:
+**7.** The rule for picking a _most specific_ alternative among a set of overloaded or implicit alternatives is refined to take context parameters into account. All else being equal, an alternative that takes some context parameters is taken to be less specific than an alternative that takes none. If both alternatives take context parameters, we try to choose between them as if they were methods with regular parameters. The following paragraph in the [SLS §6.26.3](https://scala-lang.org/files/archive/spec/2.13/06-expressions.html#overloading-resolution) is affected by this change:
 
 _Original version:_
 

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

@@ -33,8 +33,7 @@ g(2)(3)(4)     // ok
 g(2)(3)("")    // ok
 ```
 
-To make this work, the rules for overloading resolution in [SLS §
-6.26.3](https://www.scala-lang.org/files/archive/spec/2.13/06-expressions.html#overloading-resolution) are augmented
+To make this work, the rules for overloading resolution in [SLS §6.26.3](https://www.scala-lang.org/files/archive/spec/2.13/06-expressions.html#overloading-resolution) are augmented
 as follows:
 
 > In a situation where a function is applied to more than one argument list, if overloading
@@ -58,8 +57,7 @@ def f(x: String, f2: String => String) = f2(x)
 f("a", _.toUpperCase)
 f(2, _ * 2)
 ```
-To make this work, the rules for overloading resolution in [SLS §
-6.26.3](https://www.scala-lang.org/files/archive/spec/2.13/06-expressions.html#overloading-resolution) are modified
+To make this work, the rules for overloading resolution in [SLS §6.26.3](https://www.scala-lang.org/files/archive/spec/2.13/06-expressions.html#overloading-resolution) are modified
 as follows:
 
 Replace the sentence

docs/docs/reference/contextual/motivation.md

@@ -49,7 +49,7 @@ The following pages introduce a redesign of contextual abstractions in Scala. Th
 
  1. [Given Instances](./givens.md) are a new way to define basic terms that can be synthesized.  They replace implicit definitions. The core principle of the proposal is that, rather than mixing the `implicit` modifier with a large number of features, we have a single way to define terms that can be synthesized for types.
 
- 2. [`using` Clauses](./using-clauses.md) are a new syntax for implicit _parameters_ and their _arguments_. It unambiguously aligns parameters and arguments, solving a number of language warts. It also allows us to have several `using` clauses in a definition.
+ 2. [Using Clauses](./using-clauses.md) are a new syntax for implicit _parameters_ and their _arguments_. It unambiguously aligns parameters and arguments, solving a number of language warts. It also allows us to have several `using` clauses in a definition.
 
  3. ["Given" Imports](./given-imports.md) are a new class of import selectors that specifically import
     givens and nothing else.

docs/docs/reference/metaprogramming/inline.md

@@ -226,8 +226,7 @@ pure expressions of constant type.
 #### The definition of constant expression
 
 Right-hand sides of inline values and of arguments for inline parameters must be
-constant expressions in the sense defined by the [SLS §
-6.24](https://www.scala-lang.org/files/archive/spec/2.13/06-expressions.html#constant-expressions),
+constant expressions in the sense defined by the [SLS §6.24](https://www.scala-lang.org/files/archive/spec/2.13/06-expressions.html#constant-expressions),
 including _platform-specific_ extensions such as constant folding of pure
 numeric computations.
 
@@ -501,8 +500,7 @@ val conjunction: true && true = true
 val multiplication: 3 * 5 = 15
 ```
 
-Many of these singleton operation types are meant to be used infix (as in [SLS §
-3.2.10](https://www.scala-lang.org/files/archive/spec/2.13/03-types.html#infix-types)).
+Many of these singleton operation types are meant to be used infix (as in [SLS §3.2.10](https://www.scala-lang.org/files/archive/spec/2.13/03-types.html#infix-types)).
 
 Since type aliases have the same precedence rules as their term-level
 equivalents, the operations compose with the expected precedence rules:

docs/docs/reference/metaprogramming/macros.md

@@ -78,8 +78,8 @@ ${'[T]} = T
 The type signatures of quotes and splices can be described using
 two fundamental types:
 
-  - `Expr[T]`: abstract syntax trees representing expressions of type `T`
-  - `Type[T]`: type structures representing type `T`.
+- `Expr[T]`: abstract syntax trees representing expressions of type `T`
+- `Type[T]`: type structures representing type `T`.
 
 Quoting takes expressions of type `T` to expressions of type `Expr[T]`
 and it takes types `T` to expressions of type `Type[T]`. Splicing
@@ -103,7 +103,7 @@ operations that will be discussed later on.
 A fundamental *phase consistency principle* (PCP) regulates accesses
 to free variables in quoted and spliced code:
 
- - _For any free variable reference `x`, the number of quoted scopes and the number of spliced scopes between the reference to `x` and the definition of `x` must be equal_.
+- _For any free variable reference `x`, the number of quoted scopes and the number of spliced scopes between the reference to `x` and the definition of `x` must be equal_.
 
 Here, `this`-references count as free variables. On the other
 hand, we assume that all imports are fully expanded and that `_root_` is
@@ -129,8 +129,8 @@ situations described above.
 
 In what concerns the range of features it covers, this form of macros introduces
 a principled metaprogramming framework that is quite close to the MetaML family of
-languages. One difference is that MetaML does not have an equivalent of the PCP
-- quoted code in MetaML _can_ access variables in its immediately enclosing
+languages. One difference is that MetaML does not have an equivalent of the PCP -
+quoted code in MetaML _can_ access variables in its immediately enclosing
 environment, with some restrictions and caveats since such accesses involve
 serialization. However, this does not constitute a fundamental gain in
 expressiveness.
@@ -632,10 +632,9 @@ It is possible to deconstruct or extract values out of `Expr` using pattern matc
 
 `scala.quoted` contains objects that can help extracting values from `Expr`.
 
-* `scala.quoted.Expr`/`scala.quoted.Exprs`: matches an expression of a value (or list of values) and returns the value (or list of values).
-* `scala.quoted.Const`/`scala.quoted.Consts`: Same as `Expr`/`Exprs` but only works on primitive values.
-* `scala.quoted.Varargs`: matches an explicit sequence of expressions and returns them. These sequences are useful to get individual `Expr[T]` out of a varargs expression of type `Expr[Seq[T]]`.
-
+- `scala.quoted.Expr`/`scala.quoted.Exprs`: matches an expression of a value (or list of values) and returns the value (or list of values).
+- `scala.quoted.Const`/`scala.quoted.Consts`: Same as `Expr`/`Exprs` but only works on primitive values.
+- `scala.quoted.Varargs`: matches an explicit sequence of expressions and returns them. These sequences are useful to get individual `Expr[T]` out of a varargs expression of type `Expr[Seq[T]]`.
 
 These could be used in the following way to optimize any call to `sum` that has statically known values.
 ```scala
@@ -646,7 +645,7 @@ private def sumExpr(argsExpr: Expr[Seq[Int]])(using Quotes): Expr[Int] = argsExp
     // argValues is of type Seq[Int]
     Expr(argValues.sum) // precompute result of sum
   case Varargs(argExprs) => // argExprs is of type Seq[Expr[Int]]
-    val staticSum: Int = argExprs.map(_.value.getOrElse(0))
+    val staticSum: Int = argExprs.map(_.value.getOrElse(0)).sum
     val dynamicSum: Seq[Expr[Int]] = argExprs.filter(_.value.isEmpty)
     dynamicSum.foldLeft(Expr(staticSum))((acc, arg) => '{ $acc + $arg })
   case _ =>
@@ -695,7 +694,7 @@ private def sumExpr(args1: Seq[Expr[Int]])(using Quotes): Expr[Int] = {
 Sometimes it is necessary to get a more precise type for an expression. This can be achived using the following pattern match.
 
 ```scala
-def f(exp: Expr[Any])(using Quotes) =
+def f(expr: Expr[Any])(using Quotes) =
   expr match
     case '{ $x: t } =>
       // If the pattern match succeeds, then there is some type `t` such that
@@ -713,10 +712,11 @@ private def showMeExpr(sc: Expr[StringContext], argsExpr: Expr[Seq[Any]])(using
   argsExpr match {
     case Varargs(argExprs) =>
       val argShowedExprs = argExprs.map {
-        case '{ $arg: t } =>
-          Expr.summon[Show[t]] match {
+        case '{ $arg: tp } =>
+          val showTp = Type.of[Show[tp]]
+          Expr.summon(using showTp) match {
             case Some(showExpr) => '{ $showExpr.show($arg) }
-            case None => report.error(s"could not find implicit for ${showTp.show}", arg); '{???}
+            case None           => report.error(s"could not find implicit for ${Type.show[Show[tp]]}", arg); '{???}
           }
       }
       val newArgsExpr = Varargs(argShowedExprs)
@@ -759,7 +759,7 @@ private def evalExpr(e: Expr[Int])(using Quotes): Expr[Int] = {
   e match {
     case '{ val y: Int = $x; $body(y): Int } =>
       // body: Expr[Int => Int] where the argument represents references to y
-      evalExpr(Expr.betaReduce(body)(evalExpr(x)))
+      evalExpr(Expr.betaReduce('{$body(${evalExpr(x)})}))
     case '{ ($x: Int) * ($y: Int) } =>
       (x.value, y.value) match
         case (Some(a), Some(b)) => Expr(a * b)