Change context function syntax

Instead of `A? => B`, use a joint operator `A ?=> B`.
The two separate operators look more familiar, but that
can also be a problem since they suggest that `A?` is
a nullable or in other ways optional type. By joining
`?` and `=>` into a new `?=>` operator we avoid that
misconception and also keep the possibiliy to use postfix
`?` at some point in the future (maybe for the fancy
unboxed options?).

Author: odersky

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

@@ -6,12 +6,12 @@ title: "Context Functions - More Details"
 ## Syntax
 
     Type              ::=  ...
-                        |  FunArgTypes ‘?’ ‘=>’ Type
+                        |  FunArgTypes ‘?=>’ Type
     Expr              ::=  ...
-                        |  FunParams ‘?’ ‘=>’ Expr
+                        |  FunParams ‘?=>’ Expr
 
 Context function types associate to the right, e.g.
-`S? => T? => U` is the same as `S? => (T? => U)`.
+`S ?=> T ?=> U` is the same as `S ?=> (T ?=> U)`.
 
 ## Implementation
 
@@ -28,7 +28,7 @@ trait ContextFunctionN[-T1 , ... , -TN, +R] {
 Context function types erase to normal function types, so these classes are
 generated on the fly for typechecking, but not realized in actual code.
 
-Context function literals `(x1: T1, ..., xn: Tn)? => e` map
+Context function literals `(x1: T1, ..., xn: Tn) ?=> e` map
 context parameters `xi` of types `Ti` to the result of evaluating the expression `e`.
 The scope of each context parameter `xi` is `e`. The parameters must have pairwise distinct names.
 
@@ -54,7 +54,7 @@ Note: The closing paragraph of the
 [Anonymous Functions section](https://www.scala-lang.org/files/archive/spec/2.12/06-expressions.html#anonymous-functions)
 of Scala 2.12 is subsumed by context function types and should be removed.
 
-Context function literals `(x1: T1, ..., xn: Tn)? => e` are
+Context function literals `(x1: T1, ..., xn: Tn) ?=> e` are
 automatically created for any expression `e` whose expected type is
 `scala.ContextFunctionN[T1, ..., Tn, R]`, unless `e` is
 itself a context function literal. This is analogous to the automatic

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

@@ -7,10 +7,11 @@ _Context functions_ are functions with (only) context parameters.
 Their types are _context function types_. Here is an example of a context function type:
 
 ```scala
-type Executable[T] = ExecutionContext? => T
+type Executable[T] = ExecutionContext ?=> T
 ```
-A context function is applied to synthesized arguments, in
-the same way a method with context parameters is applied. For instance:
+Context function are written using `?=>` as the "arrow" sign.
+They are applied to synthesized arguments, in
+the same way methods with context parameters is applied. For instance:
 ```scala
   given ec as ExecutionContext = ...
 
@@ -20,26 +21,26 @@ the same way a method with context parameters is applied. For instance:
   f(2)             // argument is inferred
 ```
 Conversely, if the expected type of an expression `E` is a context function type
-`(T_1, ..., T_n)? => U` and `E` is not already an
+`(T_1, ..., T_n) ?=> U` and `E` is not already an
 context function literal, `E` is converted to an context function literal by rewriting to
 ```scala
-  (x_1: T1, ..., x_n: Tn)? => E
+  (x_1: T1, ..., x_n: Tn) ?=> E
 ```
 where the names `x_1`, ..., `x_n` are arbitrary. This expansion is performed
 before the expression `E` is typechecked, which means that `x_1`, ..., `x_n`
 are available as givens in `E`.
 
-Like their types, context function literals are written with a `?` after the parameters. They differ from normal function literals in that their types are context function types.
+Like their types, context function literals are written using `?=>` as the arrow between parameters and results. They differ from normal function literals in that their types are context function types.
 
 For example, continuing with the previous definitions,
 ```scala
   def g(arg: Executable[Int]) = ...
 
-  g(22)      // is expanded to g((ev: ExecutionContext)? => 22)
+  g(22)      // is expanded to g((ev: ExecutionContext) ?=> 22)
 
-  g(f(2))    // is expanded to g((ev: ExecutionContext)? => f(2).with(ev))
+  g(f(2))    // is expanded to g((ev: ExecutionContext) ?=> f(2).with(ev))
 
-  g((ctx: ExecutionContext)? => f(22).with(ctx)) // is left as it is
+  g((ctx: ExecutionContext) ?=> f(22).with(ctx)) // is left as it is
 ```
 ### Example: Builder Pattern
 
@@ -79,13 +80,13 @@ Then, the `table`, `row` and `cell` constructor methods can be defined
 with context function types as parameters to avoid the plumbing boilerplate
 that would otherwise be necessary.
 ```scala
-  def table(init: Table? => Unit) = {
+  def table(init: Table ?=> Unit) = {
     given t as Table
     init
     t
   }
 
-  def row(init: Row? => Unit) with (t: Table) = {
+  def row(init: Row ?=> Unit) with (t: Table) = {
     given r as Row
     init
     t.add(r)
@@ -96,14 +97,14 @@ that would otherwise be necessary.
 ```
 With that setup, the table construction code above compiles and expands to:
 ```scala
-  table { ($t: Table)? =>
+  table { ($t: Table) ?=>
 
-    row { ($r: Row)? =>
+    row { ($r: Row) ?=>
       cell("top left").with($r)
       cell("top right").with($r)
     }.with($t)
 
-    row { ($r: Row)? =>
+    row { ($r: Row) ?=>
       cell("bottom left").with($r)
       cell("bottom right").with($r)
     }.with($t)
@@ -119,7 +120,7 @@ object PostConditions {
 
   def result[T] with (r: WrappedResult[T]) : T = r
 
-  def (x: T) ensuring[T](condition: WrappedResult[T]? => Boolean): T = {
+  def (x: T) ensuring[T](condition: WrappedResult[T] ?=> Boolean): T = {
     assert(condition.with(x))
     x
   }
@@ -128,7 +129,7 @@ import PostConditions.{ensuring, result}
 
 val s = List(1, 2, 3).sum.ensuring(result == 6)
 ```
-**Explanations**: We use a context function type `WrappedResult[T]? => Boolean`
+**Explanations**: We use a context function type `WrappedResult[T] ?=> Boolean`
 as the type of the condition of `ensuring`. An argument to `ensuring` such as
 `(result == 6)` will therefore have a given of type `WrappedResult[T]` in
 scope to pass along to the `result` method. `WrappedResult` is a fresh type, to make sure