Indent after match

Author: odersky

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

@@ -10,21 +10,31 @@ The syntactical precedence of match expressions has been changed.
 
     ```scala
     xs match {
-      case Nil => "empty"
-      case x :: xs1 => "nonempty"
+       case Nil => "empty"
+       case x :: xs1 => "nonempty"
     } match {
-      case "empty" => 0
-      case "nonempty" => 1
+       case "empty" => 0
+       case "nonempty" => 1
     }
     ```
 
+  (or, dropping the optional braces)
+
+    ```scala
+    xs match
+       case Nil => "empty"
+       case x :: xs1 => "nonempty"
+    match
+       case "empty" => 0
+       case "nonempty" => 1
+    ```
+
  2. `match` may follow a period:
 
      ```scala
-     if xs.match {
-       case Nil => false
-       case _ => true
-     }
+     if xs.match
+        case Nil => false
+        case _ => true
      then "nonempty"
      else "empty"
      ```

docs/docs/reference/changed-features/numeric-literals.md

@@ -15,7 +15,7 @@ val y: BigInt = 0x123_abc_789_def_345_678_901
 val z: BigDecimal = 110_222_799_799.99
 
 (y: BigInt) match
-  case 123_456_789_012_345_678_901 =>
+   case 123_456_789_012_345_678_901 =>
 ```
 The syntax of numeric literals is the same as before, except there are no pre-set limits
 how large they can be.
@@ -133,27 +133,27 @@ object BigFloat:
    def apply(digits: String): BigFloat =
       val (mantissaDigits, givenExponent) =
          digits.toUpperCase.split('E') match
-         case Array(mantissaDigits, edigits) =>
-            val expo =
-              try FromDigits.intFromDigits(edigits)
-              catch case ex: FromDigits.NumberTooLarge =>
-                throw FromDigits.NumberTooLarge(s"exponent too large: $edigits")
-            (mantissaDigits, expo)
-         case Array(mantissaDigits) =>
-            (mantissaDigits, 0)
+            case Array(mantissaDigits, edigits) =>
+               val expo =
+                  try FromDigits.intFromDigits(edigits)
+                  catch case ex: FromDigits.NumberTooLarge =>
+                     throw FromDigits.NumberTooLarge(s"exponent too large: $edigits")
+               (mantissaDigits, expo)
+            case Array(mantissaDigits) =>
+               (mantissaDigits, 0)
       val (intPart, exponent) =
          mantissaDigits.split('.') match
-         case Array(intPart, decimalPart) =>
-            (intPart ++ decimalPart, givenExponent - decimalPart.length)
-         case Array(intPart) =>
-            (intPart, givenExponent)
+            case Array(intPart, decimalPart) =>
+               (intPart ++ decimalPart, givenExponent - decimalPart.length)
+            case Array(intPart) =>
+               (intPart, givenExponent)
       BigFloat(BigInt(intPart), exponent)
 ```
 To accept `BigFloat` literals, all that's needed in addition is a `given` instance of type
 `FromDigits.Floating[BigFloat]`:
 ```scala
-  given FromDigits: FromDigits.Floating[BigFloat] with
-     def fromDigits(digits: String) = apply(digits)
+   given FromDigits: FromDigits.Floating[BigFloat] with
+      def fromDigits(digits: String) = apply(digits)
 end BigFloat
 ```
 Note that the `apply` method does not check the format of the `digits` argument. It is
@@ -194,17 +194,17 @@ no code that can be executed at runtime. That is why we define an intermediary c
 method in the `FromDigits` given instance. That method is defined in terms of a macro
 implementation method `fromDigitsImpl`. Here is its definition:
 ```scala
-  private def fromDigitsImpl(digits: Expr[String])(using ctx: Quotes): Expr[BigFloat] =
-     digits.value match
-     case Some(ds) =>
-        try
-           val BigFloat(m, e) = apply(ds)
-           '{BigFloat(${Expr(m)}, ${Expr(e)})}
-        catch case ex: FromDigits.FromDigitsException =>
-           ctx.error(ex.getMessage)
-           '{BigFloat(0, 0)}
-     case None =>
-        '{apply($digits)}
+   private def fromDigitsImpl(digits: Expr[String])(using ctx: Quotes): Expr[BigFloat] =
+      digits.value match
+         case Some(ds) =>
+            try
+               val BigFloat(m, e) = apply(ds)
+               '{BigFloat(${Expr(m)}, ${Expr(e)})}
+            catch case ex: FromDigits.FromDigitsException =>
+               ctx.error(ex.getMessage)
+               '{BigFloat(0, 0)}
+         case None =>
+            '{apply($digits)}
 end BigFloat
 ```
 The macro implementation takes an argument of type `Expr[String]` and yields

docs/docs/reference/changed-features/operators.md

@@ -60,7 +60,7 @@ val x: String or Int = ...
 
 ### Motivation
 
-The purpose of the `infix` modifier is to achieve consistency across a code base in how a method or type is applied. The idea is that the author of a method decides whether that method should be applied as an infix operator or in a regular application. Use sites then implement that decision consistently.
+The purpose of the `infix` modifier is to achieve consistency actross a code base in how a method or type is applied. The idea is that the author of a method decides whether that method should be applied as an infix operator or in a regular application. Use sites then implement that decision consistently.
 
 ### Details
 

docs/docs/reference/changed-features/pattern-matching.md

@@ -104,9 +104,9 @@ object Even:
    def unapply(s: String): Boolean = s.size % 2 == 0
 
 "even" match
-case s @ Even() => println(s"$s has an even number of characters")
-case s          => println(s"$s has an odd number of characters")
-   
+   case s @ Even() => println(s"$s has an even number of characters")
+   case s          => println(s"$s has an odd number of characters")
+
 // even has an even number of characters
 ```
 
@@ -134,8 +134,8 @@ object FirstChars:
    def unapply(s: String): FirstChars = new FirstChars(s)
 
 "Hi!" match
-case FirstChars(char1, char2) =>
-   println(s"First: $char1; Second: $char2")
+   case FirstChars(char1, char2) =>
+      println(s"First: $char1; Second: $char2")
 
 // First: H; Second: i
 ```
@@ -155,8 +155,8 @@ object Nat:
    def unapply(x: Int): Nat = new Nat(x)
 
 5 match
-case Nat(n) => println(s"$n is a natural number")
-case _      => ()
+   case Nat(n) => println(s"$n is a natural number")
+   case _      => ()
 
 // 5 is a natural number
 ```
@@ -175,8 +175,8 @@ object ProdEmpty:
    def get = this
 
 "" match
-case ProdEmpty(_, _) => ???
-case _ => ()
+   case ProdEmpty(_, _) => ???
+   case _ => ()
 ```
 
 
@@ -186,10 +186,10 @@ case _ => ()
 
 ```Scala
 type X = {
-  def lengthCompare(len: Int): Int // or, `def length: Int`
-  def apply(i: Int): T1
-  def drop(n: Int): scala.Seq[T2]
-  def toSeq: scala.Seq[T3]
+   def lengthCompare(len: Int): Int // or, `def length: Int`
+   def apply(i: Int): T1
+   def drop(n: Int): scala.Seq[T2]
+   def toSeq: scala.Seq[T3]
 }
 ```
 
@@ -200,13 +200,13 @@ type X = {
 
 ```scala
 object CharList:
-  def unapplySeq(s: String): Option[Seq[Char]] = Some(s.toList)
+   def unapplySeq(s: String): Option[Seq[Char]] = Some(s.toList)
 
 "example" match
-case CharList(c1, c2, c3, c4, _, _, _) =>
-   println(s"$c1,$c2,$c3,$c4")
-case _ =>
-   println("Expected *exactly* 7 characters!")
+   case CharList(c1, c2, c3, c4, _, _, _) =>
+      println(s"$c1,$c2,$c3,$c4")
+   case _ =>
+      println("Expected *exactly* 7 characters!")
 
 // e,x,a,m
 ```

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

@@ -8,8 +8,8 @@ like one writes them in expressions, using a `: _*` type annotation:
 
 ```scala
 xs match
-case List(1, 2, xs: _*) => println(xs)    // binds xs
-case List(1, _ : _*) =>                   // wildcard pattern
+   case List(1, 2, xs: _*) => println(xs)    // binds xs
+   case List(1, _ : _*) =>                   // wildcard pattern
 ```
 
 The old syntax, which is shorter but less regular, is no longer supported.

docs/docs/reference/contextual/derivation-macro.md

@@ -46,17 +46,17 @@ given derived[T: Type](using Quotes): Expr[Eq[T]] =
    val ev: Expr[Mirror.Of[T]] = Expr.summon[Mirror.Of[T]].get
 
    ev match
-   case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = elementTypes }} =>
-      val elemInstances = summonAll[elementTypes]
-      val eqProductBody: (Expr[T], Expr[T]) => Expr[Boolean] = (x, y) =>
-         elemInstances.zipWithIndex.foldLeft(Expr(true: Boolean)) {
-            case (acc, (elem, index)) =>
-               val e1 = '{$x.asInstanceOf[Product].productElement(${Expr(index)})}
-               val e2 = '{$y.asInstanceOf[Product].productElement(${Expr(index)})}
-               '{ $acc && $elem.asInstanceOf[Eq[Any]].eqv($e1, $e2) }
-         }
-
-      '{ eqProduct((x: T, y: T) => ${eqProductBody('x, 'y)}) }
+      case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = elementTypes }} =>
+         val elemInstances = summonAll[elementTypes]
+         val eqProductBody: (Expr[T], Expr[T]) => Expr[Boolean] = (x, y) =>
+            elemInstances.zipWithIndex.foldLeft(Expr(true: Boolean)) {
+               case (acc, (elem, index)) =>
+                  val e1 = '{$x.asInstanceOf[Product].productElement(${Expr(index)})}
+                  val e2 = '{$y.asInstanceOf[Product].productElement(${Expr(index)})}
+                  '{ $acc && $elem.asInstanceOf[Eq[Any]].eqv($e1, $e2) }
+            }
+
+         '{ eqProduct((x: T, y: T) => ${eqProductBody('x, 'y)}) }
 
    // case for Mirror.ProductOf[T]
    // ...
@@ -78,19 +78,19 @@ Instead we extract the tuple-type for element types using pattern matching over
 quotes and more specifically of the refined type:
 
 ```scala
- case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = elementTypes }} => ...
+   case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = elementTypes }} => ...
 ```
 
 Shown below is the implementation of `summonAll` as a macro. We assume that
 given instances for our primitive types exist.
 
 ```scala
-  def summonAll[T: Type](using Quotes): List[Expr[Eq[_]]] =
-     Type.of[T] match
-     case '[String *: tpes] => '{ summon[Eq[String]] } :: summonAll[tpes]
-     case '[Int *: tpes]    => '{ summon[Eq[Int]] }    :: summonAll[tpes]
-     case '[tpe *: tpes]    => derived[tpe] :: summonAll[tpes]
-     case '[EmptyTuple]     => Nil
+def summonAll[T: Type](using Quotes): List[Expr[Eq[_]]] =
+   Type.of[T] match
+      case '[String *: tpes] => '{ summon[Eq[String]] } :: summonAll[tpes]
+      case '[Int *: tpes]    => '{ summon[Eq[Int]] }    :: summonAll[tpes]
+      case '[tpe *: tpes]    => derived[tpe] :: summonAll[tpes]
+      case '[EmptyTuple]     => Nil
 ```
 
 One additional difference with the body of `derived` here as opposed to the one
@@ -101,9 +101,9 @@ class that holds a name of type `String` and an age of type `Int`, the equality
 check we want to generate is the following:
 
 ```scala
-true
-  && Eq[String].eqv(x.productElement(0),y.productElement(0))
-  && Eq[Int].eqv(x.productElement(1), y.productElement(1))
+   true
+   && Eq[String].eqv(x.productElement(0),y.productElement(0))
+   && Eq[Int].eqv(x.productElement(1), y.productElement(1))
 ```
 
 ### Calling the derived method inside the macro
@@ -159,39 +159,39 @@ object Eq:
 
    def summonAll[T: Type](using Quotes): List[Expr[Eq[_]]] =
       Type.of[T] match
-      case '[String *: tpes] => '{ summon[Eq[String]] } :: summonAll[tpes]
-      case '[Int *: tpes]    => '{ summon[Eq[Int]] }    :: summonAll[tpes]
-      case '[tpe *: tpes]    => derived[tpe] :: summonAll[tpes]
-      case '[EmptyTuple]     => Nil
+         case '[String *: tpes] => '{ summon[Eq[String]] } :: summonAll[tpes]
+         case '[Int *: tpes]    => '{ summon[Eq[Int]] }    :: summonAll[tpes]
+         case '[tpe *: tpes]    => derived[tpe] :: summonAll[tpes]
+         case '[EmptyTuple]     => Nil
 
    given derived[T: Type](using q: Quotes): Expr[Eq[T]] =
       import quotes.reflect._
 
       val ev: Expr[Mirror.Of[T]] = Expr.summon[Mirror.Of[T]].get
 
       ev match
-      case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = elementTypes }} =>
-         val elemInstances = summonAll[elementTypes]
-         val eqProductBody: (Expr[T], Expr[T]) => Expr[Boolean] = (x, y) =>
-            elemInstances.zipWithIndex.foldLeft(Expr(true: Boolean)) {
-               case (acc, (elem, index)) =>
-                  val e1 = '{$x.asInstanceOf[Product].productElement(${Expr(index)})}
-                  val e2 = '{$y.asInstanceOf[Product].productElement(${Expr(index)})}
-
-                  '{ $acc && $elem.asInstanceOf[Eq[Any]].eqv($e1, $e2) }
-            }
-         '{ eqProduct((x: T, y: T) => ${eqProductBody('x, 'y)}) }
-
-      case '{ $m: Mirror.SumOf[T] { type MirroredElemTypes = elementTypes }} =>
-         val elemInstances = summonAll[elementTypes]
-         val eqSumBody: (Expr[T], Expr[T]) => Expr[Boolean] = (x, y) =>
-            val ordx = '{ $m.ordinal($x) }
-            val ordy = '{ $m.ordinal($y) }
-
-            val elements = Expr.ofList(elemInstances)
-            '{ $ordx == $ordy && $elements($ordx).asInstanceOf[Eq[Any]].eqv($x, $y) }
-
-        '{ eqSum((x: T, y: T) => ${eqSumBody('x, 'y)}) }
+         case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = elementTypes }} =>
+            val elemInstances = summonAll[elementTypes]
+            val eqProductBody: (Expr[T], Expr[T]) => Expr[Boolean] = (x, y) =>
+               elemInstances.zipWithIndex.foldLeft(Expr(true: Boolean)) {
+                  case (acc, (elem, index)) =>
+                     val e1 = '{$x.asInstanceOf[Product].productElement(${Expr(index)})}
+                     val e2 = '{$y.asInstanceOf[Product].productElement(${Expr(index)})}
+
+                     '{ $acc && $elem.asInstanceOf[Eq[Any]].eqv($e1, $e2) }
+               }
+            '{ eqProduct((x: T, y: T) => ${eqProductBody('x, 'y)}) }
+
+         case '{ $m: Mirror.SumOf[T] { type MirroredElemTypes = elementTypes }} =>
+            val elemInstances = summonAll[elementTypes]
+            val eqSumBody: (Expr[T], Expr[T]) => Expr[Boolean] = (x, y) =>
+               val ordx = '{ $m.ordinal($x) }
+               val ordy = '{ $m.ordinal($y) }
+
+               val elements = Expr.ofList(elemInstances)
+               '{ $ordx == $ordy && $elements($ordx).asInstanceOf[Eq[Any]].eqv($x, $y) }
+
+         '{ eqSum((x: T, y: T) => ${eqSumBody('x, 'y)}) }
    end derived
 end Eq
 

docs/docs/reference/contextual/derivation.md

@@ -180,8 +180,8 @@ a `Mirror[T]`. Here is a possible implementation,
 inline given derived[T](using m: Mirror.Of[T]): Eq[T] =
    val elemInstances = summonAll[m.MirroredElemTypes]           // (1)
    inline m match                                               // (2)
-   case s: Mirror.SumOf[T]     => eqSum(s, elemInstances)
-   case p: Mirror.ProductOf[T] => eqProduct(p, elemInstances)
+      case s: Mirror.SumOf[T]     => eqSum(s, elemInstances)
+      case p: Mirror.ProductOf[T] => eqProduct(p, elemInstances)
 ```
 
 Note that `derived` is defined as an `inline` given. This means that the method will be expanded at
@@ -197,8 +197,8 @@ implementation of `summonAll` is `inline` and uses Scala 3's `summonInline` cons
 
 inline def summonAll[T <: Tuple]: List[Eq[_]] =
    inline erasedValue[T] match
-   case _: EmptyTuple => Nil
-   case _: (t *: ts) => summonInline[Eq[t]] :: summonAll[ts]
+      case _: EmptyTuple => Nil
+      case _: (t *: ts) => summonInline[Eq[t]] :: summonAll[ts]
 ```
 
 with the instances for children in hand the `derived` method uses an `inline match` to dispatch to methods which can
@@ -238,8 +238,8 @@ import scala.compiletime.{erasedValue, summonInline}
 
 inline def summonAll[T <: Tuple]: List[Eq[_]] =
    inline erasedValue[T] match
-   case _: EmptyTuple => Nil
-   case _: (t *: ts) => summonInline[Eq[t]] :: summonAll[ts]
+      case _: EmptyTuple => Nil
+      case _: (t *: ts) => summonInline[Eq[t]] :: summonAll[ts]
 
 trait Eq[T]:
    def eqv(x: T, y: T): Boolean
@@ -269,8 +269,8 @@ object Eq:
    inline given derived[T](using m: Mirror.Of[T]): Eq[T] =
       lazy val elemInstances = summonAll[m.MirroredElemTypes]
       inline m match
-      case s: Mirror.SumOf[T]     => eqSum(s, elemInstances)
-      case p: Mirror.ProductOf[T] => eqProduct(p, elemInstances)
+         case s: Mirror.SumOf[T]     => eqSum(s, elemInstances)
+         case p: Mirror.ProductOf[T] => eqProduct(p, elemInstances)
 end Eq
 ```