Fixes to syntax and docs

Author: odersky

docs/docs/internals/syntax.md

@@ -388,7 +388,7 @@ ObjectDef         ::=  id [Template]
 EnumDef           ::=  id ClassConstr InheritClauses EnumBody                   EnumDef(mods, name, tparams, template)
 GivenDef          ::=  [GivenSig (‘:’ | <:)] Type ‘=’ Expr
                     |  [GivenSig ‘:’] [ConstrApp {‘,’ ConstrApp }] [TemplateBody]
-                    |  [id ‘:’] [ExtParamClause] TemplateBody
+                    |  [GivenSig ‘:’] [ExtParamClause] TemplateBody
 GivenSig          ::=  [id] [DefTypeParamClause] {GivenParamClause}
 ExtParamClause    ::=  [DefTypeParamClause] ‘(’ DefParam ‘)’ {GivenParamClause}
 Template          ::=  InheritClauses [TemplateBody]                            Template(constr, parents, self, stats)

docs/docs/reference/contextual-new/delegates.md

@@ -82,6 +82,6 @@ GivenDef         ::=  [GivenSig (‘:’ | <:)] Type ‘=’ Expr
                   |   [GivenSig ‘:’] [ConstrApp {‘,’ ConstrApp }] [TemplateBody]
 GivenSig         ::=  [id] [DefTypeParamClause] {GivenParamClause}
 GivenParamClause ::=  ‘(’ ‘given’ (DefParams | GivenTypes) ‘)’
-GivenTypes       ::=  AnnotType {‘,’ AnnotType}
+GivenTypes       ::=  Type {‘,’ Type}
 ```
 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-new/extension-methods.md

@@ -80,10 +80,10 @@ So `circle.circumference` translates to `CircleOps.circumference(circle)`, provi
 
 ### Given Instances for Extension Methods
 
-Given instances that define extension methods can also be defined without an `as` clause. E.g.,
+Given instances that define extension methods can also be defined without a parent. E.g.,
 
 ```scala
-given StringOps {
+given stringOps: {
   def (xs: Seq[String]) longestStrings: Seq[String] = {
     val maxLength = xs.map(_.length).max
     xs.filter(_.length == maxLength)
@@ -98,18 +98,18 @@ If such given instances are anonymous (as in the second clause), their name is s
 
 ### Given Instances with Collective Parameters
 
-If a given instance has several extension methods one can pull out the left parameter section
+If a given instance has no parent but several extension methods one can pull out the left parameter section
 as well as any type parameters of these extension methods into the given instance itself.
 For instance, here is a given instance with two extension methods.
 ```scala
-given ListOps {
+given listOps: {
   def (xs: List[T]) second[T]: T = xs.tail.head
   def (xs: List[T]) third[T]: T = xs.tail.tail.head
 }
 ```
 The repetition in the parameters can be avoided by moving the parameters into the given instance itself. The following version is a shorthand for the code above.
 ```scala
-given ListOps[T](xs: List[T]) {
+given listOps: [T](xs: List[T]) {
   def second: T = xs.tail.head
   def third: T = xs.tail.tail.head
 }
@@ -168,6 +168,7 @@ to the [current syntax](../../internals/syntax.md).
 ```
 DefSig            ::=  ...
                     |  ‘(’ DefParam ‘)’ [nl] id [DefTypeParamClause] DefParamClauses
-GivenBody         ::=  ...
-                    |  ‘(’ DefParam ‘)’ TemplateBody
+GivenDef          ::=  ...
+                       [GivenSig ‘:’] [ExtParamClause] TemplateBody
+ExtParamClause    ::=  [DefTypeParamClause] ‘(’ DefParam ‘)’ {GivenParamClause}
 ```

docs/docs/reference/contextual-new/implicit-function-types-spec.md

@@ -6,9 +6,11 @@ title: "Implicit Function Types - More Details"
 ## Syntax
 
     Type              ::=  ...
-                        |  `(' `given' FunArgTypes `)' `=>' Type
-    Expr              ::=  ...
-                        |  `(' `given' FunParams `)' `=>' Expr
+                        |  FunArgTypes ‘=>’ Typee
+    FunArgTypes       ::=  InfixType
+                        |  ‘(’ [ ‘[given]’ FunArgType {‘,’ FunArgType } ] ‘)’
+                        |  ‘(’ ‘[given]’ TypedFunParam {‘,’ TypedFunParam } ‘)’
+    Bindings          ::=  ‘(’ [[‘given’] Binding {‘,’ Binding}] ‘)’
 
 Implicit function types associate to the right, e.g.
 `(given S) => (given T) => U` is the same as `(given S) => ((given T) => U)`.