Expunge remaining usages of "delegate" in docs

Author: odersky

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

@@ -43,10 +43,10 @@ affect implicits on the language level.
     Example:
 
         package p
-        delegate a for A
+        given a as A
 
         object o {
-          delegate b for B
+          given b as B
           type C
         }
 

docs/docs/reference/contextual/derivation.md

@@ -215,15 +215,15 @@ a mirror over that array, and finally uses the `reify` method in `Reflected` to
 
 ### How to Write Generic Typeclasses
 
-Based on the machinery developed so far it becomes possible to define type classes generically. This means that the `derived` method will compute a type class delegate for any ADT that has a `Generic` delegate, recursively.
+Based on the machinery developed so far it becomes possible to define type classes generically. This means that the `derived` method will compute a type class instance for any ADT that has a given `Generic` instance, recursively.
 The implementation of these methods typically uses three new type-level constructs in Dotty: inline methods, inline matches, and implicit matches. As an example, here is one possible implementation of a generic `Eql` type class, with explanations. Let's assume `Eql` is defined by the following trait:
 ```scala
 trait Eql[T] {
   def eql(x: T, y: T): Boolean
 }
 ```
-We need to implement a method `Eql.derived` that produces a delegate for `Eql[T]` provided
-there exists a delegate for `Generic[T]`. Here's a possible solution:
+We need to implement a method `Eql.derived` that produces a given instance for `Eql[T]` provided
+a given `Generic[T]`. Here's a possible solution:
 ```scala
   inline def derived[T] given (ev: Generic[T]): Eql[T] = new Eql[T] {
     def eql(x: T, y: T): Boolean = {
@@ -239,7 +239,7 @@ there exists a delegate for `Generic[T]`. Here's a possible solution:
     }
   }
 ```
-The implementation of the inline method `derived` creates a delegate for `Eql[T]` and implements its `eql` method. The right-hand side of `eql` mixes compile-time and runtime elements. In the code above, runtime elements are marked with a number in parentheses, i.e
+The implementation of the inline method `derived` creates a given instance for `Eql[T]` and implements its `eql` method. The right-hand side of `eql` mixes compile-time and runtime elements. In the code above, runtime elements are marked with a number in parentheses, i.e
 `(1)`, `(2)`, `(3)`. Compile-time calls that expand to runtime code are marked with a number in brackets, i.e. `[4]`, `[5]`. The implementation of `eql` consists of the following steps.
 
   1. Map the compared values `x` and `y` to their mirrors using the `reflect` method of the implicitly passed `Generic` `(1)`, `(2)`.
@@ -310,16 +310,16 @@ The last, and in a sense most interesting part of the derivation is the comparis
     case ev: Eql[T] =>
       ev.eql(x, y)                              // (15)
     case _ =>
-      error("No `Eql` delegate was found for $T")
+      error("No `Eql` instance was found for $T")
   }
 ```
-`tryEql` is an inline method that takes an element type `T` and two element values of that type as arguments. It is defined using an `implicit match` that tries to find a delegate for `Eql[T]`. If a delegate `ev` is found, it proceeds by comparing the arguments using `ev.eql`. On the other hand, if no delegate is found
-this signals a compilation error: the user tried a generic derivation of `Eql` for a class with an element type that does not have an `Eql` delegate itself. The error is signaled by
+`tryEql` is an inline method that takes an element type `T` and two element values of that type as arguments. It is defined using an `implicit match` that tries to find a given instance for `Eql[T]`. If an instance `ev` is found, it proceeds by comparing the arguments using `ev.eql`. On the other hand, if no instance is found
+this signals a compilation error: the user tried a generic derivation of `Eql` for a class with an element type that does not have an `Eql` instance itself. The error is signaled by
 calling the `error` method defined in `scala.compiletime`.
 
 **Note:** At the moment our error diagnostics for metaprogramming does not support yet interpolated string arguments for the `scala.compiletime.error` method that is called in the second case above. As an alternative, one can simply leave off the second case, then a missing typeclass would result in a "failure to reduce match" error.
 
-**Example:** Here is a slightly polished and compacted version of the code that's generated by inline expansion for the derived `Eql` delegate for class `Tree`.
+**Example:** Here is a slightly polished and compacted version of the code that's generated by inline expansion for the derived `Eql` instance for class `Tree`.
 
 ```scala
 given [T] as Eql[Tree[T]] where (elemEq: Eql[T]) {
@@ -341,21 +341,21 @@ given [T] as Eql[Tree[T]] where (elemEq: Eql[T]) {
 }
 ```
 
-One important difference between this approach and Scala-2 typeclass derivation frameworks such as Shapeless or Magnolia is that no automatic attempt is made to generate typeclass delegates for elements recursively using the generic derivation framework. There must be a delegate for `Eql[T]` (which can of course be produced in turn using `Eql.derived`), or the compilation will fail. The advantage of this more restrictive approach to typeclass derivation is that it avoids uncontrolled transitive typeclass derivation by design. This keeps code sizes smaller, compile times lower, and is generally more predictable.
+One important difference between this approach and Scala-2 typeclass derivation frameworks such as Shapeless or Magnolia is that no automatic attempt is made to generate typeclass instances for elements recursively using the generic derivation framework. There must be a given instance for `Eql[T]` (which can of course be produced in turn using `Eql.derived`), or the compilation will fail. The advantage of this more restrictive approach to typeclass derivation is that it avoids uncontrolled transitive typeclass derivation by design. This keeps code sizes smaller, compile times lower, and is generally more predictable.
 
-### Deriving Delegates Elsewhere
+### Deriving Instances Elsewhere
 
-Sometimes one would like to derive a typeclass delegate for an ADT after the ADT is defined, without being able to change the code of the ADT itself.
-To do this, simply define a delegate with the `derived` method of the typeclass as right-hand side. E.g, to implement `Ordering` for `Option`, define:
+Sometimes one would like to derive a typeclass instance for an ADT after the ADT is defined, without being able to change the code of the ADT itself.
+To do this, simply define an instance with the `derived` method of the typeclass as right-hand side. E.g, to implement `Ordering` for `Option`, define:
 ```scala
-delegate [T: Ordering]: Ordering[Option[T]] = Ordering.derived
+instance [T: Ordering] as Ordering[Option[T]] = Ordering.derived
 ```
 Usually, the `Ordering.derived` clause has an implicit parameter of type
 `Generic[Option[T]]`. Since the `Option` trait has a `derives` clause,
-the necessary delegate is already present in the companion object of `Option`.
-If the ADT in question does not have a `derives` clause, a `Generic` delegate
+the necessary instance is already present in the companion object of `Option`.
+If the ADT in question does not have a `derives` clause, a `Generic` instance
 would still be synthesized by the compiler at the point where `derived` is called.
-This is similar to the situation with type tags or class tags: If no delegate
+This is similar to the situation with type tags or class tags: If no instance
 is found, the compiler will synthesize one.
 
 ### Syntax
@@ -371,7 +371,7 @@ ConstrApps        ::=  ConstrApp {‘with’ ConstrApp}
 ### Discussion
 
 The typeclass derivation framework is quite small and low-level. There are essentially
-two pieces of infrastructure in the compiler-generated `Generic` delegates:
+two pieces of infrastructure in the compiler-generated `Generic` instances:
 
  - a type representing the shape of an ADT,
  - a way to map between ADT instances and generic mirrors.

docs/docs/reference/features-classification.md

@@ -36,7 +36,7 @@ Since these are additions, there's generally no migration cost for old code. An
 These constructs replace existing constructs with the aim of making the language safer and simpler to use, and to promote uniformity in code style.
 
  - [Trait Parameters](other-new-features/trait-parameters.md) replace [early initializers](dropped-features/early-initializers.md) with a more generally useful construct.
- - [Delegates](contextual/delegates.md)
+ - [Given Instances](contextual/delegates.md)
    replace implicit objects and defs, focussing on intent over mechanism.
  - [Given Clauses](contextual/given-clauses.md) replace implicit parameters, avoiding their ambiguities.
  - [Extension Methods](contextual/extension-methods.md) replace implicit classes with a clearer and simpler mechanism.
@@ -71,7 +71,7 @@ For the next several versions, old features will remain available and deprecatio
 These constructs are restricted to make the language safer.
 
  - [Implicit Conversions](contextual/conversions.md): there is only one way to define implicit conversions instead of many, and potentially surprising implicit conversions require a language import.
- - [Delegate Imports](contextual/import-delegate.md): implicits now require a special form of import, to make the import clearly visible.
+ - [Given Imports](contextual/import-delegate.md): implicits now require a special form of import, to make the import clearly visible.
  - [Type Projection](dropped-features/type-projection.md): only classes can be used as prefix `C` of a type projection `C#A`. Type projection on abstract types is no longer supported since it is unsound.
  - [Multiversal Equality](contextual/multiversal-equality.md) implements an "opt-in" scheme to rule out nonsensical comparisons with `==` and `!=`.
  - [@infix and @alpha](https://github.com/lampepfl/dotty/pull/5975)

docs/docs/reference/metaprogramming/macros-spec.md

@@ -190,7 +190,7 @@ With the right extractors, the "AsFunction" conversion
 that maps expressions over functions to functions over expressions can
 be implemented in user code:
 ```scala
-    delegate AsFunction1[T, U] for Conversion[Expr[T => U], Expr[T] => Expr[U]] {
+    given AsFunction1[T, U] as Conversion[Expr[T => U], Expr[T] => Expr[U]] {
       def apply(f: Expr[T => U]): Expr[T] => Expr[U] =
        (x: Expr[T]) => f match {
          case Lambda(g) => g(x)

docs/docs/reference/metaprogramming/macros.md

@@ -194,7 +194,7 @@ would be rewritten to
     def reflect[T: Type, U: Type](f: Expr[T] => Expr[U]): Expr[T => U] =
       '{ (x: ${ the[Type[T]] }) => ${ f('x) } }
 ```
-The `the` query succeeds because there is a delegate of
+The `the` query succeeds because there is a given instance of
 type `Type[T]` available (namely the given parameter corresponding
 to the context bound `: Type`), and the reference to that value is
 phase-correct. If that was not the case, the phase inconsistency for
@@ -224,7 +224,7 @@ Here’s a compiler that maps an expression given in the interpreted
 language to quoted Scala code of type `Expr[Int]`.
 The compiler takes an environment that maps variable names to Scala `Expr`s.
 ```scala
-    import delegate scala.quoted._
+    import given scala.quoted._
 
     def compile(e: Exp, env: Map[String, Expr[Int]]): Expr[Int] = e match {
       case Num(n) =>
@@ -251,15 +251,15 @@ The `toExpr` extension method is defined in package `quoted`:
 ```scala
     package quoted
 
-    delegate ExprOps {
+    given ExprOps {
       def (x: T) toExpr[T: Liftable] given QuoteContext: Expr[T] = the[Liftable[T]].toExpr(x)
       ...
     }
 ```
 The extension says that values of types implementing the `Liftable` type class can be
-converted ("lifted") to `Expr` values using `toExpr`, provided a delegate import of `scala.quoted._` is in scope.
+converted ("lifted") to `Expr` values using `toExpr`, provided a given import of `scala.quoted._` is in scope.
 
-Dotty comes with delegate definitions of `Liftable` for
+Dotty comes with given instances of `Liftable` for
 several types including `Boolean`, `String`, and all primitive number
 types. For example, `Int` values can be converted to `Expr[Int]`
 values by wrapping the value in a `Literal` tree node. This makes use
@@ -269,7 +269,7 @@ in the sense that they could all be defined in a user program without
 knowing anything about the representation of `Expr` trees. For
 instance, here is a possible instance of `Liftable[Boolean]`:
 ```scala
-    delegate for Liftable[Boolean] {
+    given as Liftable[Boolean] {
       def toExpr(b: Boolean) given QuoteContext: Expr[Boolean] =
         if (b) '{ true } else '{ false }
     }
@@ -278,7 +278,7 @@ Once we can lift bits, we can work our way up. For instance, here is a
 possible implementation of `Liftable[Int]` that does not use the underlying
 tree machinery:
 ```scala
-    delegate for Liftable[Int] {
+    given as Liftable[Int] {
       def toExpr(n: Int) given QuoteContext: Expr[Int] = n match {
         case Int.MinValue    => '{ Int.MinValue }
         case _ if n < 0      => '{ - ${ toExpr(-n) } }
@@ -291,7 +291,7 @@ tree machinery:
 Since `Liftable` is a type class, its instances can be conditional. For example,
 a `List` is liftable if its element type is:
 ```scala
-    delegate [T: Liftable] for Liftable[List[T]] {
+    given [T: Liftable] as Liftable[List[T]] {
       def toExpr(xs: List[T]) given QuoteContext: Expr[List[T]] = xs match {
         case head :: tail => '{ ${ toExpr(head) } :: ${ toExpr(tail) } }
         case Nil => '{ Nil: List[T] }
@@ -337,7 +337,7 @@ implicit search. For instance, to implement
     the[Type[List[T]]]
 ```
 where `T` is not defined in the current stage, we construct the type constructor
-of `List` applied to the splice of the result of searching for a delegate for `Type[T]`:
+of `List` applied to the splice of the result of searching for a given instance for `Type[T]`:
 ```scala
     '[ List[ ${ the[Type[T]] } ] ]
 ```

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

@@ -43,7 +43,7 @@ They can be accessed inside `Copier` as well as from outside:
 An export clause has the same format as an import clause. Its general form is:
 ```scala
   export path . { sel_1, ..., sel_n }
-  export delegate path . { sel_1, ..., sel_n }
+  export given path . { sel_1, ..., sel_n }
 ```
 It consists of a qualifier expression `path`, which must be a stable identifier, followed by
 one or more selectors `sel_i` that identify what gets an alias. Selectors can be
@@ -61,14 +61,14 @@ A member is _eligible_ if all of the following holds:
  - its owner is not a base class of the class(*) containing the export clause,
  - it is accessible at the export clause,
  - it is not a constructor, nor the (synthetic) class part of an object,
- - it is delegate (or an old-style `implicit` value)
-   if and only if the export is tagged with `delegate`.
+ - it is a given instance (or an old-style `implicit` value)
+   if and only if the export is tagged with `given`.
 
 It is a compile-time error if a simple or renaming selector does not identify any eligible
 members.
 
 Type members are aliased by type definitions, and term members are aliased by method definitions. Export aliases copy the type and value parameters of the members they refer to.
-Export aliases are always `final`. Aliases of delegates are again defines as delegates (and aliases of old-style implicits are `implicit`). There are no other modifiers that can be given to an alias. This has the following consequences for overriding:
+Export aliases are always `final`. Aliases of given instances are again defined as givens (and aliases of old-style implicits are `implicit`). There are no other modifiers that can be given to an alias. This has the following consequences for overriding:
 
  - Export aliases cannot be overridden, since they are final.
  - Export aliases cannot override concrete members in base classes, since they are
@@ -105,7 +105,7 @@ TemplateStat   ::=  ...
                  |  Export
 TopStat        ::=  ...
                  |  Export
-Export         ::=  ‘export’ [‘delegate’] ImportExpr {‘,’ ImportExpr}
+Export         ::=  ‘export’ [‘given’] ImportExpr {‘,’ ImportExpr}
 ```
 
 ### Elaboration of Export Clauses

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

@@ -20,7 +20,7 @@ object Logarithms {
   }
 
   // Extension methods define opaque types' public APIs
-  delegate LogarithmOps {
+  given LogarithmOps {
     def (x: Logarithm) toDouble: Double = math.exp(x)
     def (x: Logarithm) + (y: Logarithm): Logarithm = Logarithm(math.exp(x) + math.exp(y))
     def (x: Logarithm) * (y: Logarithm): Logarithm = Logarithm(x + y)

docs/docs/reference/overview.md

@@ -33,7 +33,7 @@ These new constructs directly model core features of DOT, higher-kinded types, a
 These constructs replace existing constructs with the aim of making the language safer and simpler to use, and to promote uniformity in code style.
 
  - [Trait Parameters](other-new-features/trait-parameters.md) replace [early initializers](dropped-features/early-initializers.md) with a more generally useful construct.
- - [Delegates](contextual/delegates.md)
+ - [Given Instances](contextual/delegates.md)
    replace implicit objects and defs, focussing on intent over mechanism.
  - [Given Clauses](contextual/given-clauses.md) replace implicit parameters, avoiding their ambiguities.
  - [Extension Methods](contextual/extension-methods.md) replace implicit classes with a clearer and simpler mechanism.
@@ -58,7 +58,7 @@ e a special case. There are currently no deprecation plans for value classes, si
 These constructs are restricted to make the language safer.
 
  - [Implicit Conversions](contextual/conversions.md): there is only one way to define implicit conversions instead of many, and potentially surprising implicit conversions require a language import.
- - [Delegate Imports](contextual/import-delegate.md): implicits now require a special form of import, to make the import clearly visible.
+ - [Given Imports](contextual/import-delegate.md): implicits now require a special form of import, to make the import clearly visible.
  - [Type Projection](dropped-features/type-projection.md): only classes can be used as prefix `C` of a type projection `C#A`. Type projection on abstract types is no longer supported since it is unsound.
  - [Multiversal Equality](contextual/multiversal-equality.md) implements an "opt-in" scheme to rule out nonsensical comparisons with `==` and `!=`.
  - [@infix and @alpha](https://github.com/lampepfl/dotty/pull/5975)

docs/sidebar.yml

@@ -43,13 +43,13 @@ sidebar:
           subsection:
             - title: Overview
               url: docs/reference/contextual/motivation.html
-            - title: Delegates
+            - title: Given Instances
               url: docs/reference/contextual/delegates.html
             - title: Given Clauses
               url: docs/reference/contextual/given-clauses.html
             - title: Context Bounds
               url: docs/reference/contextual/context-bounds.html
-            - title: Delegate Imports
+            - title: Given Imports
               url: docs/reference/contextual/import-delegate.html
             - title: Extension Methods
               url: docs/reference/contextual/extension-methods.html