Use new extension method syntax in instnace-defs doc

Author: odersky

docs/docs/reference/instances/instance-defs.md

@@ -7,18 +7,18 @@ Instance definitions provide a concise and uniform syntax for defining implicit
 
 ```scala
 trait Ord[T] {
-  def compareTo(this x: T)(y: T): Int
-  def < (this x: T)(y: T) = x.compareTo(y) < 0
-  def > (this x: T)(y: T) = x.compareTo(y) > 0
+  def (x: T) compareTo (y: T): Int
+  def (x: T) < (y: T) = x.compareTo(y) < 0
+  def (x: T) > (y: T) = x.compareTo(y) > 0
 }
 
 instance IntOrd of Ord[Int] {
-  def compareTo(this x: Int)(y: Int) =
+  def (x: Int) compareTo (y: Int) =
     if (x < y) -1 else if (x > y) +1 else 0
 }
 
 instance ListOrd[T: Ord] of Ord[List[T]] {
-  def compareTo(this xs: List[T])(ys: List[T]): Int = (xs, ys) match {
+  def (xs: List[T]) compareTo (ys: List[T]): Int = (xs, ys) match {
     case (Nil, Nil) => 0
     case (Nil, _) => -1
     case (_, Nil) => +1
@@ -32,12 +32,12 @@ instance ListOrd[T: Ord] of Ord[List[T]] {
 Instance can be seen as shorthands for what is currently expressed as implicit definitions. The instance definitions above could also have been formulated as implicits as follows:
 ```scala
 implicit object IntOrd extends Ord[Int] {
-  def compareTo(this x: Int)(y: Int) =
+  def (x: Int) compareTo (y: Int) =
     if (x < y) -1 else if (x > y) +1 else 0
 }
 
 class ListOrd[T: Ord] extends Ord[List[T]] {
-  def compareTo(this xs: List[T])(ys: List[T]): Int = (xs, ys) match {
+  def (xs: List[T]) compareTo (ys: List[T]): Int = (xs, ys) match {
     case (Nil, Nil) => 0
     case (Nil, _) => -1
     case (_, Nil) => +1
@@ -60,14 +60,14 @@ Instances can also be defined without an `of` clause. A typical application is t
 
 ```scala
 instance StringOps {
-  def longestStrings(this xs: Seq[String]): Seq[String] = {
+  def (xs: Seq[String]) longestStrings: Seq[String] = {
     val maxLength = xs.map(_.length).max
     xs.filter(_.length == maxLength)
   }
 }
 
 instance ListOps {
-  def second[T](this xs: List[T]) = xs.tail.head
+  def (xs: List[T]) second[T] = xs.tail.head
 }
 ```
 Instances like these translate to `implicit` objects without an extends clause.
@@ -80,7 +80,7 @@ instance of Ord[Int] { ... }
 instance [T: Ord] of Ord[List[T]] { ... }
 
 instance {
-  def second[T](this xs: List[T]) = xs.tail.head
+  def (xs: List[T]) second[T] = xs.tail.head
 }
 ```
 If the name of an instance is missing, the compiler will synthesize a name from
@@ -92,11 +92,11 @@ extension method. Details remain to be specified.
 An instance definition can depend on another instance being defined. For instance:
 ```scala
 trait Convertible[From, To] {
-  def convert (this x: From): To
+  def convert(x: From): To
 }
 
 instance [From, To] with (c: Convertible[From, To]) of Convertible[List[From], List[To]] {
-  def convert (this x: List[From]): List[To] = x.map(c.convert)
+  def convert(x: List[From]): List[To] = x.map(c.convert)
 }
 ```
 
@@ -105,7 +105,7 @@ The `with` clause instance defines required instances. The instance of `Converti
 ```scala
 class Convertible_List_List_instance[From, To](implicit c: Convertible[From, To])
 extends Convertible[List[From], List[To]] {
-  def convert (this x: List[From]): List[To] = x.map(c.convert)
+  def convert (x: List[From]): List[To] = x.map(c.convert)
 }
 implicit def Convertible_List_List_instance[From, To](implicit c: Convertible[From, To])
   : Convertible[List[From], List[To]] =
@@ -132,14 +132,14 @@ Semigroups and monoids:
 
 ```scala
 trait SemiGroup[T] {
-  def combine(this x: T)(y: T): T
+  def (x: T) combine (y: T): T
 }
 trait Monoid[T] extends SemiGroup[T] {
   def unit: T
 }
 
 instance of Monoid[String] {
-  def combine(this x: String)(y: String): String = x.concat(y)
+  def (x: String) combine (y: String): String = x.concat(y)
   def unit: String = ""
 }
 
@@ -149,25 +149,25 @@ def sum[T: Monoid](xs: List[T]): T =
 Functors and monads:
 ```scala
 trait Functor[F[_]] {
-  def map[A, B](this x: F[A])(f: A => B): F[B]
+  def (x: F[A]) map[A, B] (f: A => B): F[B]
 }
 
 trait Monad[F[_]] extends Functor[F] {
-  def flatMap[A, B](this x: F[A])(f: A => F[B]): F[B]
-  def map[A, B](this x: F[A])(f: A => B) = x.flatMap(f `andThen` pure)
+  def (x: F[A]) flatMap[A, B] (f: A => F[B]): F[B]
+  def (x: F[A]) map[A, B] (f: A => B) = x.flatMap(f `andThen` pure)
 
   def pure[A](x: A): F[A]
 }
 
 instance ListMonad of Monad[List] {
-  def flatMap[A, B](this xs: List[A])(f: A => List[B]): List[B] =
+  def (xs: List[A]) flatMap[A, B] (f: A => List[B]): List[B] =
     xs.flatMap(f)
   def pure[A](x: A): List[A] =
     List(x)
 }
 
 instance ReaderMonad[Ctx] of Monad[[X] => Ctx => X] {
-  def flatMap[A, B](this r: Ctx => A)(f: A => Ctx => B): Ctx => B =
+  def (r: Ctx => A) flatMap[A, B] (f: A => Ctx => B): Ctx => B =
     ctx => f(r(ctx))(ctx)
   def pure[A](x: A): Ctx => A =
     ctx => x
@@ -178,7 +178,7 @@ instance ReaderMonad[Ctx] of Monad[[X] => Ctx => X] {
 
 Here is the new syntax of instance definitions, seen as a delta from the [standard context free syntax of Scala 3](http://dotty.epfl.ch/docs/internals/syntax.html).
 ```
-TmplDef         ::=  ...
+TmplDef          ::=  ...
                   |  ‘instance’ InstanceDef
 InstanceDef      ::=  [id] InstanceParams [‘of’ ConstrApps] [TemplateBody]
 InstanceParams   ::=  [DefTypeParamClause] {‘with’ ‘(’ [DefParams] ‘)}