Syntax change: inferred for instead of instance of

Author: odersky

docs/docs/reference/instances/context-params.md

@@ -1,6 +1,6 @@
 ---
 layout: doc-page
-title: "Implicit Parameters and Arguments"
+title: "Inferred Parameters and Arguments"
 ---
 
 A new syntax for implicit parameters aligns definition and call syntax. Parameter definitions and method arguments both follow a `given` keyword. On the definition side, the old syntax
@@ -54,8 +54,8 @@ lists in a definition. Example:
 ```scala
 def f given (u: Universe) (x: u.T) given Context = ...
 
-instance global of Universe { type T = String ... }
-instance ctx of Context { ... }
+inferred global for Universe { type T = String ... }
+inferred ctx for Context { ... }
 ```
 Then the following calls are all valid (and normalize to the last one)
 ```scala
@@ -69,7 +69,7 @@ or as a sequence of types. To distinguish the two, a leading `(` always indicate
 
 ## Summoning an Instance
 
-A method `summon` in `Predef` creates an implicit instance value for a given type, analogously to what `implicitly[T]` did. The only difference between the two is that
+A method `summon` in `Predef` returns the inferred value for a given type, analogously to what `implicitly[T]` did. The only difference between the two is that
 `summon` takes a context parameter, where `implicitly` took an old-style implicit parameter:
 ```scala
 def summon[T] with (x: T) = x

docs/docs/reference/instances/implicit-conversions.md

@@ -3,14 +3,14 @@ layout: doc-page
 title: "Implicit Conversions"
 ---
 
-Implicit conversions are defined by instances of the `scala.Conversion` class.
+Implicit conversions are defined by inferred instances of the `scala.Conversion` class.
 This class is defined in package `scala` as follows:
 ```scala
 abstract class Conversion[-T, +U] extends (T => U)
 ```
 For example, here is an implicit conversion from `String` to `Token`:
 ```scala
-instance of Conversion[String, Token] {
+inferred for Conversion[String, Token] {
   def apply(str: String): Token = new KeyWord(str)
 }
 ```
@@ -33,7 +33,7 @@ If such an instance `C` is found, the expression `e` is replaced by `C.apply(e)`
 primitive number types to subclasses of `java.lang.Number`. For instance, the
 conversion from `Int` to `java.lang.Integer` can be defined as follows:
 ```scala
-instance int2Integer of Conversion[Int, java.lang.Integer] {
+inferred int2Integer for Conversion[Int, java.lang.Integer] {
   def apply(x: Int) = new java.lang.Integer(x)
 }
 ```
@@ -56,13 +56,13 @@ object Completions {
     //
     //   CompletionArg.from(statusCode)
 
-    instance from of Conversion[String, CompletionArg] {
+    inferred from for Conversion[String, CompletionArg] {
       def apply(s: String) = CompletionArg.Error(s)
     }
-    instance from of Conversion[Future[HttpResponse], CompletionArg] {
+    inferred from for Conversion[Future[HttpResponse], CompletionArg] {
       def apply(f: Future[HttpResponse]) = CompletionArg.Response(f)
     }
-    instance from of Conversion[Future[StatusCode], CompletionArg] {
+    inferred from for Conversion[Future[StatusCode], CompletionArg] {
       def apply(code: Future[StatusCode]) = CompletionArg.Status(code)
     }
   }

docs/docs/reference/instances/implicit-function-types.md

@@ -3,31 +3,31 @@ layout: doc-page
 title: "Implicit Function Types and Closures"
 ---
 
-An implicit function type describes functions with implicit (context) parameters. Example:
+An implicit function type describes functions with inferred parameters. Example:
 ```scala
 type Contextual[T] = given Context => T
 ```
-A value of implicit function type is applied to context arguments, in
-the same way a method with context parameters is applied. For instance:
+A value of implicit function type is applied to inferred arguments, in
+the same way a method with inferred parameters is applied. For instance:
 ```scala
-  implicit val ctx: Context = ...
+  inferred ctx for Context = ...
 
   def f(x: Int): Contextual[Int] = ...
 
   f(2) given ctx   // explicit argument
-  f(2)             // argument left implicit
+  f(2)             // argument is inferred
 ```
 Conversely, if the expected type of an expression `E` is an implicit
 function type `given (T_1, ..., T_n) => U` and `E` is not already an
-implicit function value, `E` is converted to an implicit function value
+implicit function value, `E` is converted to an inferred function value
 by rewriting to
 ```scala
   given (x_1: T1, ..., x_n: Tn) => E
 ```
-where the names `x_1`, ..., `x_n` are arbitrary. Implicit closures are written
-with a `given` prefix. They differ from normal closures in two ways:
+where the names `x_1`, ..., `x_n` are arbitrary. inferred function values are written
+with a `given` prefix. They differ from normal function values in two ways:
 
- 1. Their parameters are implicit context parameters
+ 1. Their parameters are inferred parameters
  2. Their types are implicit function types.
 
 For example, continuing with the previous definitions,

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

@@ -1,9 +1,10 @@
 ---
 layout: doc-page
-title: "Instance Definitions"
+title: "Inferred Instances"
 ---
 
-Instance definitions provide a concise and uniform syntax for defining implicit values. Example:
+Inferred instance definitions provide a concise and uniform syntax for defining values
+that can be inferred as implicit arguments. Example:
 
 ```scala
 trait Ord[T] {
@@ -12,12 +13,12 @@ trait Ord[T] {
   def (x: T) > (y: T) = x.compareTo(y) > 0
 }
 
-instance IntOrd of Ord[Int] {
+inferred IntOrd for Ord[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]] {
+inferred ListOrd[T: Ord] for Ord[List[T]] {
   def (xs: List[T]) compareTo (ys: List[T]): Int = (xs, ys) match {
     case (Nil, Nil) => 0
     case (Nil, _) => -1
@@ -28,16 +29,16 @@ instance ListOrd[T: Ord] of Ord[List[T]] {
   }
 }
 ```
-Instance definitions can be seen as shorthands for what is currently expressed with implicit object and method definitions.
-For example, the definition of instance `IntOrd` above defines an implicit value of type `Ord[Int]`. It is hence equivalent
+Inferred instance definitions can be seen as shorthands for what is currently expressed with implicit object and method definitions.
+For example, the definition of the inferred instance `IntOrd` above defines an implicit value of type `Ord[Int]`. It is hence equivalent
 to the following implicit object definition:
 ```scala
 implicit object IntOrd extends Ord[Int] {
   def (x: Int) compareTo (y: Int) =
     if (x < y) -1 else if (x > y) +1 else 0
 }
 ```
-The definition of instance `ListOrd` defines an ordering for `List[T]` provided there is an ordering for type `T`. With existing
+The definition of the inferred instance `ListOrd` defines an ordering for `List[T]` provided there is an ordering for type `T`. With existing
 implicits, this could be expressed as a pair of a class and an implicit method:
 ```scala
 class ListOrd[T: Ord] extends Ord[List[T]] {
@@ -52,70 +53,70 @@ class ListOrd[T: Ord] extends Ord[List[T]] {
 }
 implicit def ListOrd[T: Ord]: Ord[List[T]] = new ListOrd[T]
 ```
-## Instances for Extension Methods
+## Inferred Instances for Extension Methods
 
-Instances can also be defined without an `of` clause. A typical application is to use a instance to package some extension methods. Examples:
+Inferred instances can also be defined without a `for` clause. A typical application is to use an inferred instance to package some extension methods. Examples:
 
 ```scala
-instance StringOps {
+inferred StringOps {
   def (xs: Seq[String]) longestStrings: Seq[String] = {
     val maxLength = xs.map(_.length).max
     xs.filter(_.length == maxLength)
   }
 }
 
-instance ListOps {
+inferred ListOps {
   def (xs: List[T]) second[T] = xs.tail.head
 }
 ```
-## Anonymous Instances
+## Anonymous Inferred Instances
 
-The name of an instance definition can be left out. Examples:
+The name of an inferred instance can be left out. Examples:
 ```scala
-instance of Ord[Int] { ... }
-instance [T: Ord] of Ord[List[T]] { ... }
+inferred for Ord[Int] { ... }
+inferred [T: Ord] for Ord[List[T]] { ... }
 
-instance {
+inferred {
   def (xs: List[T]) second[T] = xs.tail.head
 }
 ```
-If the name of an instance is missing, the compiler will synthesize a name from
+If the name of an inferred instance is missing, the compiler will synthesize a name from
 the type in the of clause, or, if that is missing, from the first defined
 extension method.
 
-**Aside: ** Why anonymous instances?
+**Aside: ** Why anonymous inferred instances?
 
  - It avoids clutter, relieving the programmer from having to invent names that are never referred to.
    Usually the invented names are either meaning less (e.g. `ev1`), or they just rephrase the implemented type.
- - It gives a systematic foundation for synthesized instance definitions, such as those coming from a `derives` clause.
+ - It gives a systematic foundation for synthesized inferred instance definitions, such as those coming from a `derives` clause.
  - It achieves a uniform principle that the name of an implicit is always optional, no matter
-   whether the implicit is an instance definition or an implicit parameter.
+   whether the implicit is an inferred instance definition or an implicit parameter.
 
-## Conditional Implicits
+## Conditional Instances
 
-An instance definition can depend on another instance being defined. Example:
+An inferred instance definition can depend on another inferred instance being defined. Example:
 ```scala
 trait Conversion[-From, +To] {
   def apply(x: From): To
 }
 
-instance [S, T] given (c: Conversion[S, T]) of Conversion[List[S], List[T]] {
+inferred [S, T] given (c: Conversion[S, T]) for Conversion[List[S], List[T]] {
   def convert(x: List[From]): List[To] = x.map(c.apply)
 }
 ```
 This defines an implicit conversion from `List[S]` to `List[T]` provided there is an implicit conversion from `S` to `T`.
 The `given` clause defines required instances. The `Conversion[List[From], List[To]]` instance above
 is defined only if a `Conversion[From, To]` instance exists.
 
-Context bounds in instance definitions also translate to implicit parameters,
-and therefore they can be represented alternatively as with clauses. For example,
+Context bounds in inferred instance definitions also translate to implicit parameters,
+and therefore they can be represented alternatively as `given` clauses. For example,
 here is an equivalent definition of the `ListOrd` instance:
 ```scala
-instance ListOrd[T] given (ord: Ord[T]) of List[Ord[T]] { ... }
+inferred ListOrd[T] given (ord: Ord[T]) for List[Ord[T]] { ... }
 ```
 The name of a parameter in a `given` clause can also be left out, as shown in the following variant of `ListOrd`:
 ```scala
-instance ListOrd[T] given Ord[T] of List[Ord[T]] { ... }
+inferred ListOrd[T] given Ord[T] for List[Ord[T]] { ... }
 ```
 As usual one can then infer to implicit parameter only indirectly, by passing it as implicit argument to another function.
 
@@ -137,7 +138,7 @@ object Monoid {
   def apply[T] = implicitly[Monoid[T]]
 }
 
-instance of Monoid[String] {
+inferred for Monoid[String] {
   def (x: String) combine (y: String): String = x.concat(y)
   def unit: String = ""
 }
@@ -158,50 +159,51 @@ trait Monad[F[_]] extends Functor[F] {
   def pure[A](x: A): F[A]
 }
 
-instance ListMonad of Monad[List] {
+inferred ListMonad for 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)
 }
 
-instance ReaderMonad[Ctx] of Monad[[X] => Ctx => X] {
+inferred ReaderMonad[Ctx] for 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 =
     ctx => x
 }
 ```
-## Alias Instances
+## Inferred Alias Instances
 
-An alias instance creates an instance that is equal to some expression. E.g.,
+An inferred alias instance creates an inferred instance that is equal to
+some expression. E.g.,
 ```
-instance ctx of ExecutionContext = currentThreadPool().context
+inferred ctx for ExecutionContext = currentThreadPool().context
 ```
-Here, we create an instance `ctx` of type `ExecutionContext` that resolves to the
-right hand side `currentThreadPool().context`. Each time an instance of `ExecutionContext`
+Here, we create an inferred instance `ctx` of type `ExecutionContext` that resolves to the
+right hand side `currentThreadPool().context`. Each time an inferred instance of `ExecutionContext`
 is demanded, the result of evaluating the right-hand side expression is returned. The instance definition is equivalent to the following implicit definition:
 ```
 final implicit def ctx: ExecutionContext = currentThreadPool().context
 ```
 Alias instances may be anonymous, e.g.
 ```
-instance of Position = enclosingTree.position
+inferred for Position = enclosingTree.position
 ```
-An alias instance can have type and context parameters just like any other instance definition, but it can only implement a single type.
+An inferred alias instance can have type and context parameters just like any other inferred instance definition, but it can only implement a single type.
 
 ## Syntax
 
-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).
+Here is the new syntax of inferred instance definitions, seen as a delta from the [standard context free syntax of Scala 3](http://dotty.epfl.ch/docs/internals/syntax.html).
 ```
 TmplDef          ::=  ...
-                  |  ‘instance’ InstanceDef
+                  |  ‘inferred’ InstanceDef
 InstanceDef      ::=  [id] InstanceParams InstanceBody
 InstanceParams   ::=  [DefTypeParamClause] {InstParamClause}
 InstParamClause  ::=  ‘given’ (‘(’ [DefParams] ‘)’ | ContextTypes)
-InstanceBody     ::=  [‘of’ ConstrApp {‘,’ ConstrApp }] [TemplateBody]
-                   |  ‘of’ Type ‘=’ Expr
+InstanceBody     ::=  [‘for’ ConstrApp {‘,’ ConstrApp }] [TemplateBody]
+                   |  ‘for’ Type ‘=’ Expr
 ContextTypes     ::=  RefinedType {‘,’ RefinedType}
 ```
-The identifier `id` can be omitted only if either the `of` part or the template body is present.
-If the `of` part is missing, the template body must define at least one extension method.
+The identifier `id` can be omitted only if either the `for` part or the template body is present.
+If the `for` part is missing, the template body must define at least one extension method.