Change new ... with to new ... :

`new ... with` is currently under discussion, but not supported.

Author: odersky

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

@@ -43,7 +43,7 @@ the context parameters `xi`.
 The context function literal is evaluated as the instance creation
 expression
 ```scala
-new scala.ContextFunctionN[T1, ..., Tn, T] with
+new scala.ContextFunctionN[T1, ..., Tn, T]:
    def apply(using x1: T1, ..., xn: Tn): T = e
 ```
 A context parameter may also be a wildcard represented by an underscore `_`. In that case, a fresh name for the parameter is chosen arbitrarily.

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

@@ -150,11 +150,11 @@ object Eq:
       def eqv(x: Int, y: Int) = x == y
 
    def eqProduct[T](body: (T, T) => Boolean): Eq[T] =
-      new Eq[T] with
+      new Eq[T]:
          def eqv(x: T, y: T): Boolean = body(x, y)
 
    def eqSum[T](body: (T, T) => Boolean): Eq[T] =
-      new Eq[T] with
+      new Eq[T]:
          def eqv(x: T, y: T): Boolean = body(x, y)
 
    def summonAll[T: Type](using Quotes): List[Expr[Eq[_]]] =

docs/docs/reference/contextual/derivation.md

@@ -84,7 +84,7 @@ For the `Tree` ADT from above the following `Mirror` instances will be automatic
 
 ```scala
 // Mirror for Tree
-new Mirror.Sum with
+new Mirror.Sum:
    type MirroredType = Tree
    type MirroredElemTypes[T] = (Branch[T], Leaf[T])
    type MirroredMonoType = Tree[_]
@@ -96,7 +96,7 @@ new Mirror.Sum with
       case _: Leaf[_] => 1
 
 // Mirror for Branch
-new Mirror.Product with
+new Mirror.Product:
    type MirroredType = Branch
    type MirroredElemTypes[T] = (Tree[T], Tree[T])
    type MirroredMonoType = Branch[_]
@@ -107,7 +107,7 @@ new Mirror.Product with
       new Branch(...)
 
 // Mirror for Leaf
-new Mirror.Product with
+new Mirror.Product:
    type MirroredType = Leaf
    type MirroredElemTypes[T] = Tuple1[T]
    type MirroredMonoType = Leaf[_]
@@ -212,7 +212,7 @@ instance for the appropriate ADT subtype using the auxiliary method `check` (4).
 
 ```scala
 def eqSum[T](s: Mirror.SumOf[T], elems: List[Eq[_]]): Eq[T] =
-   new Eq[T] with
+   new Eq[T]:
       def eqv(x: T, y: T): Boolean =
          val ordx = s.ordinal(x)                            // (3)
          (s.ordinal(y) == ordx) && check(elems(ordx))(x, y) // (4)
@@ -223,7 +223,7 @@ on the `Eq` instances for the fields of the data type (5),
 
 ```scala
 def eqProduct[T](p: Mirror.ProductOf[T], elems: List[Eq[_]]): Eq[T] =
-   new Eq[T] with
+   new Eq[T]:
       def eqv(x: T, y: T): Boolean =
          iterator(x).zip(iterator(y)).zip(elems.iterator).forall {  // (5)
             case ((x, y), elem) => check(elem)(x, y)
@@ -254,13 +254,13 @@ object Eq:
    def iterator[T](p: T) = p.asInstanceOf[Product].productIterator
 
    def eqSum[T](s: Mirror.SumOf[T], elems: => List[Eq[_]]): Eq[T] =
-      new Eq[T] with
+      new Eq[T]:
          def eqv(x: T, y: T): Boolean =
             val ordx = s.ordinal(x)
             (s.ordinal(y) == ordx) && check(elems(ordx))(x, y)
 
    def eqProduct[T](p: Mirror.ProductOf[T], elems: => List[Eq[_]]): Eq[T] =
-      new Eq[T] with
+      new Eq[T]:
          def eqv(x: T, y: T): Boolean =
             iterator(x).zip(iterator(y)).zip(elems.iterator).forall {
                case ((x, y), elem) => check(elem)(x, y)

docs/docs/reference/contextual/using-clauses.md

@@ -44,7 +44,7 @@ Generally, context parameters may be defined either as a full parameter list `(p
 
 Here are two other methods that have a context parameter of type `Ord[T]`:
 ```scala
-def descending[T](using asc: Ord[T]): Ord[T] = new Ord[T] with
+def descending[T](using asc: Ord[T]): Ord[T] = new Ord[T]:
    def compare(x: T, y: T) = asc.compare(y, x)
 
 def minimum[T](xs: List[T])(using Ord[T]) =

docs/docs/reference/enums/desugarEnums.md

@@ -176,7 +176,7 @@ If `E` contains at least one simple case, its companion object will define in ad
      follows.
 
      ```scala
-     private def $new(_$ordinal: Int, $name: String) = new E with runtime.EnumValue with
+     private def $new(_$ordinal: Int, $name: String) = new E with runtime.EnumValue:
         def ordinal = _$ordinal
         override def productPrefix = $name // if not overridden in `E`
         override def toString = $name      // if not overridden in `E`

docs/docs/reference/enums/enums.md

@@ -127,7 +127,7 @@ Enum values with `extends` clauses get expanded to anonymous class instances.
 For instance, the `Venus` value above would be defined like this:
 
 ```scala
-val Venus: Planet = new Planet(4.869E24, 6051800.0) with
+val Venus: Planet = new Planet(4.869E24, 6051800.0):
    def ordinal: Int = 1
    override def productPrefix: String = "Venus"
    override def toString: String = "Venus"

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

@@ -104,7 +104,7 @@ example, collects the pattern variables of a tree.
 
 ```scala
 def collectPatternVariables(tree: Tree)(implicit ctx: Context): List[Symbol] =
-   val acc = new TreeAccumulator[List[Symbol]] with
+   val acc = new TreeAccumulator[List[Symbol]]:
       def apply(syms: List[Symbol], tree: Tree)(implicit ctx: Context) =
          tree match
          case Bind(_, body) => apply(tree.symbol :: syms, body)

docs/docs/reference/other-new-features/matchable.md

@@ -21,7 +21,7 @@ However, there is a potential hole due to pattern matching. Consider:
 ```scala
 val imm: IArray[Int] = ...
 imm match
-  case a: Array[Int] => a(0) = 1
+   case a: Array[Int] => a(0) = 1
 ```
 
 The test will succeed at runtime since `IArray`s _are_ represented as
@@ -40,7 +40,7 @@ type `T` as match selector leads to the same problem:
 
 ```scala
 def f[T](x: T) = x match
-  case a: Array[Int] => a(0) = 0
+   case a: Array[Int] => a(0) = 0
 f(imm)
 ```
 
@@ -76,15 +76,15 @@ Here is the hierarchy of top-level classes and traits with their defined methods
 
 ```scala
 abstract class Any:
-  def getClass
-  def isInstanceOf
-  def asInstanceOf
-  def ==
-  def !=
-  def ##
-  def equals
-  def hashCode
-  def toString
+   def getClass
+   def isInstanceOf
+   def asInstanceOf
+   def ==
+   def !=
+   def ##
+   def equals
+   def hashCode
+   def toString
 
 trait Matchable extends Any
 

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

@@ -59,7 +59,7 @@ We could create a type test at call site where the type test can be performed wi
 
 ```scala
 val tt: TypeTest[Any, String] =
-   new TypeTest[Any, String] with
+   new TypeTest[Any, String]:
       def unapply(s: Any): Option[s.type & String] =
          s match
          case s: String => Some(s)
@@ -70,7 +70,7 @@ f[AnyRef, String]("acb")(using tt)
 
 The compiler will synthesize a new instance of a type test if none is found in scope as:
 ```scala
-new TypeTest[A, B] with
+new TypeTest[A, B]:
    def unapply(s: A): Option[s.type & B] =
       s match
       case s: B => Some(s)