Use : instead of as

Following the discussion in #7151, choose `:` instead of `as` for given clauses.

Author: odersky

docs/docs/reference/contextual/delegates.md

@@ -13,12 +13,12 @@ trait Ord[T] {
   def (x: T) > (y: T) = compare(x, y) > 0
 }
 
-given IntOrd as Ord[Int] {
+given intOrd: Ord[Int] {
   def compare(x: Int, y: Int) =
     if (x < y) -1 else if (x > y) +1 else 0
 }
 
-given ListOrd[T](given ord: Ord[T]) as Ord[List[T]] {
+given listOrd[T](given ord: Ord[T]): Ord[List[T]] {
 
   def compare(xs: List[T], ys: List[T]): Int = (xs, ys) match {
     case (Nil, Nil) => 0
@@ -30,19 +30,19 @@ given ListOrd[T](given ord: Ord[T]) as Ord[List[T]] {
   }
 }
 ```
-This code defines a trait `Ord` with two given instances. `IntOrd` defines
-a given for the type `Ord[Int]` whereas `ListOrd[T]` defines givens
+This code defines a trait `Ord` with two given instances. `intOrd` defines
+a given for the type `Ord[Int]` whereas `listOrd[T]` defines givens
 for `Ord[List[T]]` for all types `T` that come with a given instance for `Ord[T]` themselves.
-The `given (ord: Ord[T])` clause in `ListOrd` defines an implicit parameter.
+The `(given ord: Ord[T])` clause in `listOrd` defines an implicit parameter.
 Given clauses are further explained in the [next section](./given-clauses.md).
 
 ## Anonymous Given Instances
 
 The name of a given instance can be left out. So the definitions
 of the last section can also be expressed like this:
 ```scala
-given as Ord[Int] { ... }
-given [T](given Ord[T]) as Ord[List[T]] { ... }
+given Ord[Int] { ... }
+given [T](given Ord[T]): Ord[List[T]] { ... }
 ```
 If the name of a given is missing, the compiler will synthesize a name from
 the type(s) in the `as` clause.
@@ -51,7 +51,7 @@ the type(s) in the `as` clause.
 
 An alias can be used to define a given instance that is equal to some expression. E.g.:
 ```scala
-given global as ExecutionContext = new ForkJoinPool()
+given global: ExecutionContext = new ForkJoinPool()
 ```
 This creates a given `global` of type `ExecutionContext` that resolves to the right
 hand side `new ForkJoinPool()`.
@@ -60,8 +60,8 @@ returned for this and all subsequent accesses to `global`.
 
 Alias givens can be anonymous, e.g.
 ```scala
-given as Position = enclosingTree.position
-given (given outer: Context) as Context = outer.withOwner(currentOwner)
+given Position = enclosingTree.position
+given (given outer: Context): Context = outer.withOwner(currentOwner)
 ```
 An alias given can have type parameters and given clauses just like any other given instance, but it can only implement a single type.
 
@@ -78,11 +78,12 @@ Here is the new syntax of given instances, seen as a delta from the [standard co
 ```
 TmplDef          ::=  ...
                   |   ‘given’ GivenDef
-GivenDef         ::=  [id] [DefTypeParamClause] {GivenParamClause} GivenBody
-GivenBody        ::=  [‘as’ ConstrApp {‘,’ ConstrApp }] [TemplateBody]
-                   |  ‘as’ Type ‘=’ Expr
+GivenDef         ::=  GivenBody
+                  |   [id] [DefTypeParamClause] {GivenParamClause}
+                      (‘:’ GivenBody | ‘<:’ Type ‘=’ Expr)
+GivenBody        ::=  [ConstrApp {‘,’ ConstrApp }] [TemplateBody]
+                  |   Type ‘=’ Expr
 GivenParamClause ::=  ‘(’ ‘given’ (DefParams | GivenTypes) ‘)’
 GivenTypes       ::=  AnnotType {‘,’ AnnotType}
 ```
-The identifier `id` can be omitted only if either the `as` part or the template body is present.
-If the `as` part is missing, the template body must define at least one extension method.
+The identifier `id` can be omitted only if some types are implemented or the template body defines at least one extension method.

docs/docs/reference/contextual/import-delegate.md

@@ -3,12 +3,12 @@ layout: doc-page
 title: "Import Given"
 ---
 
-A special form of import selector is used to import given instances. Example:
+A special form of import wildcard selector is used to import given instances. Example:
 ```scala
 object A {
   class TC
-  given tc as TC
-  def f where TC = ???
+  given tc: TC
+  def f(given TC) = ???
 }
 object B {
   import A._
@@ -19,16 +19,16 @@ In the code above, the `import A._` clause of object `B` will import all members
 of `A` _except_ the given instance `tc`. Conversely, the second import `import A.given` will import _only_ that given instance.
 The two import clauses can also be merged into one:
 ```scala
-object B:
+object B
   import A.{given, _}
 ```
 
-Generally, a normal import selector brings definitions other than given instances into scope whereas a `given` import selector brings only given instances into scope.
+Generally, a normal wildcard selector `_` brings all definitions other than given instances into scope whereas a `given` selector brings all given instances into scope.
 
 There are two main benefits arising from these rules:
 
  - It is made clearer where givens in scope are coming from.
-   In particular, it is not possible to hide imported givens in a long list of regular imports.
+   In particular, it is not possible to hide imported givens in a long list of regular wildcard imports.
  - It enables importing all givens
    without importing anything else. This is particularly important since givens
    can be anonymous, so the usual recourse of using named imports is not
@@ -39,32 +39,32 @@ There are two main benefits arising from these rules:
 Since givens can be anonymous it is not always practical to import them by their name, and wildcard imports are typically used instead. By-type imports provide a more specific alternative to wildcard imports, which makes it clearer what is imported. Example:
 
 ```scala
-import A.{given as TC}
+import A.{given TC}
 ```
 This imports any given in `A` that has a type which conforms to `TC`. Importing givens of several types `T1,...,Tn`
 is expressed by multiple `given` selectors.
 ```
-import A.{given as T1, ..., given as Tn}
+import A.{given T1, ..., given Tn}
 ```
 Importing all given instances of a parameterized type is expressed by wildcard arguments.
 For instance, assuming the object
 ```scala
 object Instances {
-  given intOrd as Ordering[Int]
-  given [T: Ordering] listOrd as Ordering[List[T]]
-  given ec as ExecutionContext = ...
-  given im as Monoid[Int]
+  given intOrd: Ordering[Int]
+  given [T: Ordering] listOrd: Ordering[List[T]]
+  given ec: ExecutionContext = ...
+  given im: Monoid[Int]
 }
 ```
 the import
 ```scala
-import Instances.{given as Ordering[?], given as ExecutionContext}
+import Instances.{given Ordering[?], given ExecutionContext}
 ```
 would import the `intOrd`, `listOrd`, and `ec` instances but leave out the `im` instance, since it fits none of the specified bounds.
 
 By-type imports can be mixed with by-name imports. If both are present in an import clause, by-type imports come last. For instance, the import clause
 ```scala
-import Instances.{given im, given as Ordering[?]}
+import Instances.{im, given Ordering[?]}
 ```
 would import `im`, `intOrd`, and `listOrd` but leave out `ec`.
 
@@ -89,15 +89,13 @@ normal imports to given instances and imports.
 The following modifications avoid this hurdle to migration.
 
  1. A `given` import selector also brings old style implicits into scope. So, in Scala 3.0
-    an old-style implicit definition can be brought into scope either by a normal import or by an import given.
+    an old-style implicit definition can be brought into scope either by a `_` wildcard import or by a `given` import.
 
- 2. In Scala 3.1, old-style implicits accessed through a normal import
-    will give a deprecation warning.
+ 2. In Scala 3.1, old-style implicits accessed through a `_` wildcard import will give a deprecation warning.
 
- 3. In some version after 3.1, old-style implicits accessed through a normal import
-    will give a compiler error.
+ 3. In some version after 3.1, old-style implicits accessed through a `_` wildcard import will give a compiler error.
 
-These rules mean that library users can use `import given` to access old-style implicits in Scala 3.0,
+These rules mean that library users can use `given` imports to access old-style implicits in Scala 3.0,
 and will be gently nudged and then forced to do so in later versions. Libraries can then switch to
 representation clauses once their user base has migrated.
 
@@ -110,7 +108,7 @@ ImportSpec        ::=  id
                     | ‘_’
                     | ‘given’
                     | ‘{’ ImportSelectors) ‘}’
-ImportSelectors   ::=  [‘given’] id [‘=>’ id | ‘=>’ ‘_’] [‘,’ ImportSelectors]
+ImportSelectors   ::=  id [‘=>’ id | ‘=>’ ‘_’] [‘,’ ImportSelectors]
                     |  WildCardSelector {‘,’ WildCardSelector}
 WildCardSelector  ::=  ‘given’ [‘as’ InfixType]
                     |  ‘_' [‘:’ InfixType]

docs/docs/reference/contextual/multiversal-equality.md

@@ -33,7 +33,7 @@ class T derives Eql
 ```
 Alternatively, one can also provide an `Eql` given instance directly, like this:
 ```scala
-given as Eql[T, T] = Eql.derived
+given Eql[T, T] = Eql.derived
 ```
 This definition effectively says that values of type `T` can (only) be
 compared to other values of type `T` when using `==` or `!=`. The definition
@@ -59,10 +59,10 @@ definitions below make values of type `A` and type `B` comparable with
 each other, but not comparable to anything else:
 
 ```scala
-given as Eql[A, A] = Eql.derived
-given as Eql[B, B] = Eql.derived
-given as Eql[A, B] = Eql.derived
-given as Eql[B, A] = Eql.derived
+given Eql[A, A] = Eql.derived
+given Eql[B, B] = Eql.derived
+given Eql[A, B] = Eql.derived
+given Eql[B, A] = Eql.derived
 ```
 The `scala.Eql` object defines a number of `Eql` givens that together
 define a rule book for what standard types can be compared (more details below).
@@ -97,7 +97,7 @@ class Box[T](x: T) derives Eql
 By the usual rules if [typeclass derivation](./derivation.md),
 this generates the following `Eql` instance in the companion object of `Box`:
 ```scala
-given [T, U](given Eql[T, U]) as Eql[Box[T], Box[U]] = Eql.derived
+given [T, U](given Eql[T, U]) : Eql[Box[T], Box[U]] = Eql.derived
 ```
 That is, two boxes are comparable with `==` or `!=` if their elements are. Examples:
 ```scala

docs/docs/reference/contextual/relationship-implicits.md

@@ -13,15 +13,15 @@ Given instances can be mapped to combinations of implicit objects, classes and i
 
  1. Given instances without parameters are mapped to implicit objects. E.g.,
     ```scala
-      given IntOrd as Ord[Int] { ... }
+      given intOrd: Ord[Int] { ... }
     ```
     maps to
     ```scala
       implicit object IntOrd extends Ord[Int] { ... }
     ```
  2. Parameterized given instances are mapped to combinations of classes and implicit methods. E.g.,
     ```scala
-      given ListOrd[T](given (ord: Ord[T]) as Ord[List[T]] { ... }
+      given listOrd[T](given (ord: Ord[T]): Ord[List[T]] { ... }
     ```
     maps to
     ```scala
@@ -35,10 +35,10 @@ Given instances can be mapped to combinations of implicit objects, classes and i
  Examples:
 
     ```scala
-      given global as ExecutionContext = new ForkJoinContext()
+      given global: ExecutionContext = new ForkJoinContext()
 
       val ctx: Context
-      given as Context = ctx
+      given Context = ctx
     ```
     would map to
     ```scala
@@ -50,14 +50,14 @@ Given instances can be mapped to combinations of implicit objects, classes and i
 
 Anonymous given instances get compiler synthesized names, which are generated in a reproducible way from the implemented type(s). For example, if the names of the `IntOrd` and `ListOrd` givens above were left out, the following names would be synthesized instead:
 ```scala
-  given Ord_Int_given as Ord[Int] { ... }
-  given Ord_List_given[T] as Ord[List[T]] { ... }
+  given given_Ord_Int : Ord[Int] { ... }
+  given given_Ord_List[T] : Ord[List[T]] { ... }
 ```
 The synthesized type names are formed from
 
+ - the prefix `given_`,
  - the simple name(s) of the implemented type(s), leaving out any prefixes,
- - the simple name(s) of the toplevel argument type constructors to these types
- - the suffix `_given`.
+ - the simple name(s) of the toplevel argument type constructors to these types.
 
 Anonymous given instances that define extension methods without also implementing a type
 get their name from the name of the first extension method and the toplevel type
@@ -67,7 +67,7 @@ constructor of its first parameter. For example, the given instance
     def (xs: List[T]) second[T] = ...
   }
 ```
-gets the synthesized name `second_of_List_T_given`.
+gets the synthesized name `given_second_of_List_T`.
 
 ### Given Clauses
 
@@ -134,7 +134,7 @@ Implicit conversion methods in Scala 2 can be expressed as given instances of th
 ```
 one can write
 ```scala
-  given stringToToken as Conversion[String, Token] {
+  given stringToToken: Conversion[String, Token] {
     def apply(str: String): Token = new KeyWord(str)
   }
 ```
@@ -153,7 +153,7 @@ E.g., Scala 2's
 can be expressed in Dotty as
 ```scala
   lazy val pos: Position = tree.sourcePos
-  given as Position = pos
+  given Position = pos
 ```
 
 ### Abstract Implicits
@@ -165,7 +165,7 @@ An abstract implicit `val` or `def` in Scala 2 can be expressed in Dotty using a
 can be expressed in Dotty as
 ```scala
   def symDeco: SymDeco
-  given as SymDeco = symDeco
+  given SymDeco = symDeco
 ```
 
 ## Implementation Status and Timeline

docs/docs/reference/contextual/typeclasses.md

@@ -20,12 +20,12 @@ object Monoid {
   def apply[T](given Monoid[T]) = the[Monoid[T]]
 }
 
-given as Monoid[String] {
+given Monoid[String] {
   def (x: String) combine (y: String): String = x.concat(y)
   def unit: String = ""
 }
 
-given as Monoid[Int] {
+given Monoid[Int] {
   def (x: Int) combine (y: Int): Int = x + y
   def unit: Int = 0
 }
@@ -48,14 +48,14 @@ trait Monad[F[_]] extends Functor[F] {
   def pure[A](x: A): F[A]
 }
 
-given ListMonad as Monad[List] {
+given listMonad: Monad[List] {
   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)
 }
 
-given ReaderMonad[Ctx] as Monad[[X] =>> Ctx => X] {
+given readerMonad[Ctx]: Monad[[X] =>> Ctx => X] {
   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 =