Merge pull request #6558 from dotty-staging/change-tl-syntax

Use =>> for type lambdas

Author: milessabin

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -819,13 +819,13 @@ object desugar {
 
   /** Expand
    *
-   *    <mods> opaque type T = [Xs] => R
+   *    <mods> opaque type T = [Xs] =>> R
    *
    *  to
    *
    *    <mods> opaque type T = T.T
    *    synthetic object T {
-   *      synthetic opaque type T >: [Xs] => R
+   *      synthetic opaque type T >: [Xs] =>> R
    *    }
    *
    *  The generated companion object will later (in Namer) be merged with the user-defined

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -851,7 +851,7 @@ object Parsers {
     def toplevelTyp(): Tree = rejectWildcardType(typ())
 
     /** Type        ::=  FunTypeMods FunArgTypes `=>' Type
-     *                |  HkTypeParamClause `->' Type
+     *                |  HkTypeParamClause `=>>' Type
      *                |  InfixType
      *  FunArgTypes ::=  InfixType
      *                |  `(' [ FunArgType {`,' FunArgType } ] `)'
@@ -922,9 +922,9 @@ object Parsers {
         else if (in.token == LBRACKET) {
           val start = in.offset
           val tparams = typeParamClause(ParamOwner.TypeParam)
-          if (in.token == ARROW)
+          if (in.token == TLARROW)
             atSpan(start, in.skipToken())(LambdaTypeTree(tparams, toplevelTyp()))
-          else { accept(ARROW); typ() }
+          else { accept(TLARROW); typ() }
         }
         else infixType()
 

compiler/src/dotty/tools/dotc/parsing/Tokens.scala

@@ -195,13 +195,15 @@ object Tokens extends TokensCommon {
   final val SUPERTYPE = 81;        enter(SUPERTYPE, ">:")
   final val HASH = 82;             enter(HASH, "#")
   final val VIEWBOUND = 84;        enter(VIEWBOUND, "<%")
-  final val QUOTE = 85;            enter(QUOTE, "'")
+  final val TLARROW = 85;          enter(TLARROW, "=>>")
+
+  final val QUOTE = 86;            enter(QUOTE, "'")
 
   /** XML mode */
   final val XMLSTART = 96;         enter(XMLSTART, "$XMLSTART$<") // TODO: deprecate
 
   final val alphaKeywords: TokenSet = tokenRange(IF, MACRO)
-  final val symbolicKeywords: TokenSet = tokenRange(USCORE, VIEWBOUND)
+  final val symbolicKeywords: TokenSet = tokenRange(USCORE, TLARROW)
   final val keywords: TokenSet = alphaKeywords | symbolicKeywords
 
   final val allTokens: TokenSet = tokenRange(minToken, maxToken)

compiler/test-resources/repl/i6474

@@ -1,8 +1,8 @@
 scala> object Foo1 { type T[+A] = (A, Int) }
 // defined object Foo1
-scala> object Foo2 { type T[+A] = [+B] => (A, B) }
+scala> object Foo2 { type T[+A] = [+B] =>> (A, B) }
 // defined object Foo2
-scala> object Foo3 { type T[+A] = [+B] => [C] => (A, B) }
+scala> object Foo3 { type T[+A] = [+B] =>> [C] =>> (A, B) }
 // defined object Foo3
 scala> ((1, 2): Foo1.T[Int]): Foo1.T[Any]
 val res0: (Any, Int) = (1,2)
@@ -14,7 +14,7 @@ scala> (1, 2): Foo3.T[Int][Int]
   |         Missing type parameter for Foo3.T[Int][Int]
 scala> ((1, 2): Foo3.T[Int][Int][Int]): Foo3.T[Any][Int][Int]
 val res2: (Any, Int) = (1,2)
-scala> object Foo3 { type T[A] = [B] => [C] => (A, B) }
+scala> object Foo3 { type T[A] = [B] =>> [C] =>> (A, B) }
 // defined object Foo3
 scala> ((1, 2): Foo3.T[Int][Int][Int])
 val res3: (Int, Int) = (1,2)

docs/blog/_posts/2018-04-27-eighth-dotty-milestone-release.md

@@ -68,8 +68,8 @@ def foo[T](x: T) = x match {
 Normally type parameters in Scala are partitioned into kinds. First-level types are types of values.
 Higher-kinded types are type constructors such as `List` or `Map`. The kind of a type is indicated
 by the top type of which it is a subtype. Normal types are subtypes of `Any`, covariant single
-argument type constructors such as List are subtypes of `[+X] => Any`, and the `Map` type
-constructor is a subtype of `[X, +Y] => Any`.
+argument type constructors such as List are subtypes of `[+X] =>> Any`, and the `Map` type
+constructor is a subtype of `[X, +Y] =>> Any`.
 
 Sometimes we would like to have type parameters that can have more than one kind, for instance to
 define an implicit value that works for parameters of any kind. This is now possible through a form
@@ -87,7 +87,7 @@ legal:
 f[Int]
 f[List]
 f[Map]
-f[[X] => String]
+f[[X] =>> String]
 ```
 
 **Note**: This feature is considered experimental and is only enabled under a compiler flag

docs/docs/internals/syntax.md

@@ -99,6 +99,7 @@ package   private   protected override  return    super     sealed    then
 throw     trait     true      try       type      val       var       while
 with      yield
 :         =         <-        =>        <:        :>        #         @
+=>>
 ```
 
 ### Soft keywords
@@ -139,7 +140,7 @@ ClassQualifier    ::=  ‘[’ id ‘]’
 ### Types
 ```ebnf
 Type              ::=  { ‘erased’ | ‘given’} FunArgTypes ‘=>’ Type              Function(ts, t)
-                    |  HkTypeParamClause ‘=>’ Type                              TypeLambda(ps, t)
+                    |  HkTypeParamClause ‘=>>’ Type                              TypeLambda(ps, t)
                     |  MatchType
                     |  InfixType
 FunArgTypes       ::=  InfixType

docs/docs/reference/contextual/typeclasses.md

@@ -55,7 +55,7 @@ implied ListMonad for Monad[List] {
     List(x)
 }
 
-implied ReaderMonad[Ctx] for Monad[[X] => Ctx => X] {
+implied 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 =

docs/docs/reference/new-types/type-lambdas-spec.md

@@ -6,22 +6,22 @@ title: "Type Lambdas - More Details"
 ## Syntax
 
 ```
-Type              ::=  ... |  HkTypeParamClause ‘=>’ Type
+Type              ::=  ... |  HkTypeParamClause ‘=>>’ Type
 HkTypeParamClause ::=  ‘[’ HkTypeParam {‘,’ HkTypeParam} ‘]’
 HkTypeParam       ::=  {Annotation} [‘+’ | ‘-’] (Id[HkTypeParamClause] | ‘_’) TypeBounds
 TypeBounds        ::=  [‘>:’ Type] [‘<:’ Type]
 ```
 
 ### Type Checking
 
-A type lambda such `[X] => F[X]` defines a function from types to types. The parameter(s) may carry bounds and variance annotations.
-If a parameter is is bounded, as in `[X >: L <: H] => F[X]` it is checked that arguments to the parameters conform to the bounds `L` and `H`.
+A type lambda such `[X] =>> F[X]` defines a function from types to types. The parameter(s) may carry bounds and variance annotations.
+If a parameter is is bounded, as in `[X >: L <: H] =>> F[X]` it is checked that arguments to the parameters conform to the bounds `L` and `H`.
 Only the upper bound `H` can be F-bounded, i.e. `X` can appear in it.
 
 A variance annotation on a parameter indicates a subtyping relationship on type instances. For instance, given
 ```scala
-type TL1 = [+A] => F[A]
-type TL2 = [-A] => F[A]
+type TL1 = [+A] =>> F[A]
+type TL2 = [-A] =>> F[A]
 ```
 and two types `S <: T`, we have
 ```scala
@@ -37,8 +37,8 @@ It is checked that variance annotations on parameters of type lambdas are respec
 
 Assume two type lambdas
 ```scala
-type TL1  =  [v1 X >: L1 <: U1] => R1
-type TL2  =  [v2 X >: L2 <: U2] => R2
+type TL1  =  [v1 X >: L1 <: U1] =>> R1
+type TL2  =  [v2 X >: L2 <: U2] =>> R2
 ```
 where `v1` and `v2` are optional variance annotations: `+`, `-`, or absent.
 Then `TL1 <: TL2`, if
@@ -51,7 +51,7 @@ Then `TL1 <: TL2`, if
 Here we have relied on alpha renaming to bring match the two bound types `X`.
 
 A partially applied type constructor such as `List` is assumed to be equivalent to
-its eta expansion. I.e, `List = [+X] => List[X]`. This allows type constructors
+its eta expansion. I.e, `List = [+X] =>> List[X]`. This allows type constructors
 to be compared with type lambdas.
 
 ## Relationship with Parameterized Type Definitions
@@ -62,7 +62,7 @@ type T[X] = R
 ```
 is regarded as a shorthand for an unparameterized definition with a type lambda as right-hand side:
 ```scala
-type T = [X] => R
+type T = [X] =>> R
 ```
 
 A parameterized abstract type
@@ -71,19 +71,19 @@ type T[X] >: L <: U
 ```
 is regarded as shorthand for an unparameterized abstract type with type lambdas as bounds.
 ```scala
-type T >: ([X] => L) <: ([X] => U)
+type T >: ([X] =>> L) <: ([X] =>> U)
 ```
 However, if `L` is `Nothing` it is not parameterized, since `Nothing` is treated as a bottom type for all kinds. For instance,
 ```scala
 type T[-X] <: X => ()
 ```
 is expanded to
 ```scala
-type T >: Nothing <: ([-X] => X => ())
+type T >: Nothing <: ([-X] =>> X => ())
 ```
 instead of
 ```scala
-type T >: ([X] => Nothing) <: ([-X] => X => ())
+type T >: ([X] =>> Nothing) <: ([-X] =>> X => ())
 ```
 
 The same expansions apply to type parameters. E.g.
@@ -92,7 +92,7 @@ The same expansions apply to type parameters. E.g.
 ```
 is treated as a shorthand for
 ```scala
-[F >: Nothing <: [X] => Coll[X]]
+[F >: Nothing <: [X] =>> Coll[X]]
 ```
 
 **Note**: The decision to treat `Nothing` as universal bottom type is provisional, and might be changed afer further discussion.
@@ -103,7 +103,7 @@ is treated as a shorthand for
 
 The body of a type lambda can again be a type lambda. Example:
 ```scala
-type TL = [X] => [Y] => (X, Y)
+type TL = [X] =>> [Y] =>> (X, Y)
 ```
 Currently, no special provision is made to infer type arguments to such curried type lambdas. This is left for future work.
 

docs/docs/reference/new-types/type-lambdas.md

@@ -6,7 +6,7 @@ title: "Type Lambdas"
 A _type lambda_ lets one express a higher-kinded type directly, without
 a type definition.
 
-    [+X, Y] => Map[Y, X]
+    [+X, Y] =>> Map[Y, X]
 
 For instance, the type above defines a binary type constructor, with a
 covariant parameter `X` and a non-variant parameter `Y`. The
@@ -19,6 +19,6 @@ definition or declaration such as
 is a shorthand for a plain type definition with a type-lambda as its
 right-hand side:
 
-    type T = [X] => (X, X)
+    type T = [X] =>> (X, X)
 
 [More details](./type-lambdas-spec.html)

docs/docs/reference/other-new-features/kind-polymorphism.md

@@ -5,10 +5,10 @@ title: "Kind Polymorphism"
 
 Normally type parameters in Scala are partitioned into _kinds_. First-level types are types of values. Higher-kinded types are type constructors
 such as `List` or `Map`. The kind of a type is indicated by the top type of which it is a subtype. Normal types are subtypes of `Any`,
-covariant single argument type constructors such as `List` are subtypes of `[+X] => Any`, and the `Map` type constructor is
-a subtype of `[X, +Y] => Any`.
+covariant single argument type constructors such as `List` are subtypes of `[+X] =>> Any`, and the `Map` type constructor is
+a subtype of `[X, +Y] =>> Any`.
 
-A type can be used only as prescribed by its kind. Subtypes of `Any` cannot be applied to type arguments whereas subtypes of `[X] => Any`
+A type can be used only as prescribed by its kind. Subtypes of `Any` cannot be applied to type arguments whereas subtypes of `[X] =>> Any`
 _must_ be applied to a type argument, unless they are passed to type parameters of the same kind.
 
 Sometimes we would like to have type parameters that can have more than one kind, for instance to define an implicit
@@ -25,7 +25,7 @@ The actual type arguments of `f` can then be types of arbitrary kinds. So the fo
 f[Int]
 f[List]
 f[Map]
-f[[X] => String]
+f[[X] =>> String]
 ```
 
 We call type parameters and abstract types with an `AnyKind` upper bound _any-kinded types_`.