New syntax for given defs

odersky · odersky · commit 98b44f665b6d · 2024-04-14T14:07:26.000+02:00
given [A: Ord] =&gt; A is Ord:
      ...

    given [A: Ord] =&gt; A is Ord as listOrd:
      ...
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -968,19 +968,31 @@ object Parsers {
      *  i.e. an identifier followed by type and value parameters, followed by `:`?
      *  @pre  The current token is an identifier
      */
-    def followingIsGivenSig() =
+    def followingIsOldStyleGivenSig() =
       val lookahead = in.LookaheadScanner()
       if lookahead.isIdent then
         lookahead.nextToken()
+      var paramsSeen = false
       def skipParams(): Unit =
         if lookahead.token == LPAREN || lookahead.token == LBRACKET then
+          paramsSeen = true
           lookahead.skipParens()
           skipParams()
         else if lookahead.isNewLine then
           lookahead.nextToken()
           skipParams()
       skipParams()
       lookahead.isColon
+      && {
+        !in.featureEnabled(Feature.modularity)
+        || { // with modularity language import, a `:` at EOL after an identifier represents a single identifier given
+             // Example:
+             //    given C:
+             //      def f = ...
+          lookahead.nextToken()
+          !lookahead.isAfterLineEnd
+        }
+      }
 
     def followingIsExtension() =
       val next = in.lookahead.token
@@ -1793,7 +1805,9 @@ object Parsers {
 
     def infixTypeRest(t: Tree, operand: Location => Tree = refinedTypeFn): Tree =
       infixOps(t, canStartInfixTypeTokens, operand, Location.ElseWhere, ParseKind.Type,
-        isOperator = !followingIsVararg() && !isPureArrow
+        isOperator = !followingIsVararg()
+                     && !isPureArrow
+                     && !(isIdent(nme.as) && in.featureEnabled(Feature.modularity))
                      && nextCanFollowOperator(canStartInfixTypeTokens))
 
     /** RefinedType   ::=  WithType {[nl] Refinement} [`^` CaptureSet]
@@ -4079,15 +4093,30 @@ object Parsers {
         syntaxError(em"extension clause can only define methods", stat.span)
     }
 
-    /** GivenDef           ::=  [GivenSig] (GivenType [‘=’ Expr] | StructuralInstance)
-     *  GivenSig           ::=  [id] [DefTypeParamClause] {UsingParamClauses} ‘:’
-     *  GivenType          ::=  AnnotType1 {id [nl] AnnotType1}
+    /** GivenDef           ::=  OldGivenDef | NewGivenDef
+     *  OldGivenDef        ::=  [OldGivenSig] (GivenType [‘=’ Expr] | StructuralInstance)
+     *  OldGivenSig        ::=  [id] [DefTypeParamClause] {UsingParamClauses} ‘:’
      *  StructuralInstance ::=  ConstrApp {‘with’ ConstrApp} [‘with’ WithTemplateBody]
+     *
+     *  NewGivenDef        ::=  [GivenConditional '=>'] NewGivenSig
+     *  GivenConditional   ::=  [DefTypeParamClause | UsingParamClause] {UsingParamClause}
+     *  NewGivenSig        ::=  GivenType ['as' id] ([‘=’ Expr] | TemplateBody)
+     *                      |   ConstrApps ['as' id] TemplateBody
+     *
+     *  GivenType          ::=  AnnotType1 {id [nl] AnnotType1}
      */
     def givenDef(start: Offset, mods: Modifiers, givenMod: Mod) = atSpan(start, nameStart) {
       var mods1 = addMod(mods, givenMod)
       val nameStart = in.offset
-      val name = if isIdent && followingIsGivenSig() then ident() else EmptyTermName
+      var name = if isIdent && followingIsOldStyleGivenSig() then ident() else EmptyTermName
+      var newSyntaxAllowed = in.featureEnabled(Feature.modularity)
+
+      def moreConstrApps() =
+        if newSyntaxAllowed && in.token == COMMA then
+          in.nextToken()
+          constrApps()
+        else // need to be careful with last `with`
+          withConstrApps()
 
       // TODO Change syntax description
       def adjustDefParams(paramss: List[ParamClause]): List[ParamClause] =
@@ -4106,14 +4135,24 @@ object Parsers {
           else Nil
         newLinesOpt()
         val noParams = tparams.isEmpty && vparamss.isEmpty
-        if !(name.isEmpty && noParams) then acceptColon()
+        if !(name.isEmpty && noParams) then
+          if in.isColon then
+            newSyntaxAllowed = false
+            in.nextToken()
+          else if newSyntaxAllowed then accept(ARROW)
+          else acceptColon()
         val parents =
           if isSimpleLiteral then
             rejectWildcardType(annotType()) :: Nil
           else constrApp() match
-            case parent: Apply => parent :: withConstrApps()
-            case parent if in.isIdent => infixTypeRest(parent, _ => annotType1()) :: Nil
-            case parent => parent :: withConstrApps()
+            case parent: Apply => parent :: moreConstrApps()
+            case parent if in.isIdent =>
+              infixTypeRest(parent, _ => annotType1()) :: Nil
+            case parent => parent :: moreConstrApps()
+        if newSyntaxAllowed && in.isIdent(nme.as) then
+          in.nextToken()
+          name = ident()
+
         val parentsIsType = parents.length == 1 && parents.head.isType
         if in.token == EQUALS && parentsIsType then
           accept(EQUALS)
@@ -4123,7 +4162,7 @@ object Parsers {
             ValDef(name, parents.head, subExpr())
           else
             DefDef(name, adjustDefParams(joinParams(tparams, vparamss)), parents.head, subExpr())
-        else if (isStatSep || isStatSeqEnd) && parentsIsType then
+        else if (isStatSep || isStatSeqEnd) && parentsIsType && !newSyntaxAllowed then
           if name.isEmpty then
             syntaxError(em"anonymous given cannot be abstract")
           DefDef(name, adjustDefParams(joinParams(tparams, vparamss)), parents.head, EmptyTree)
@@ -4134,8 +4173,13 @@ object Parsers {
             else vparam
           val constr = makeConstructor(tparams, vparamss1)
           val templ =
-            if isStatSep || isStatSeqEnd then Template(constr, parents, Nil, EmptyValDef, Nil)
-            else withTemplate(constr, parents)
+            if isStatSep || isStatSeqEnd then
+              Template(constr, parents, Nil, EmptyValDef, Nil)
+            else if !newSyntaxAllowed || in.token == WITH then
+              withTemplate(constr, parents)
+            else
+              possibleTemplateStart()
+              templateBodyOpt(constr, parents, Nil)
           if noParams && !mods.is(Inline) then ModuleDef(name, templ)
           else TypeDef(name.toTypeName, templ)
       end gdef
diff --git a/compiler/test/dotc/pos-test-pickling.blacklist b/compiler/test/dotc/pos-test-pickling.blacklist
@@ -123,5 +123,7 @@ i15525.scala
 # alias types at different levels of dereferencing
 parsercombinators-givens.scala
 parsercombinators-givens-2.scala
+parsercombinators-arrow.scala
+
 
 
diff --git a/docs/_docs/internals/syntax.md b/docs/_docs/internals/syntax.md
@@ -460,10 +460,13 @@ ClassConstr       ::=  [ClsTypeParamClause] [ConstrMods] ClsParamClauses
 ConstrMods        ::=  {Annotation} [AccessModifier]
 ObjectDef         ::=  id [Template]                                            ModuleDef(mods, name, template)  // no constructor
 EnumDef           ::=  id ClassConstr InheritClauses EnumBody
-GivenDef          ::=  [GivenSig] (GivenType [‘=’ Expr] | StructuralInstance)
-GivenSig          ::=  [id] [DefTypeParamClause] {UsingParamClause} ‘:’         -- one of `id`, `DefTypeParamClause`, `UsingParamClause` must be present
+
+GivenDef          ::=  [GivenConditional '=>'] GivenSig
+GivenConditional  ::=  [DefTypeParamClause | UsingParamClause] {UsingParamClause}
+GivenSig          ::=  GivenType ['as' id] ([‘=’ Expr] | TemplateBody)
+                    |  ConstrApps ['as' id] TemplateBody
 GivenType         ::=  AnnotType1 {id [nl] AnnotType1}
-StructuralInstance ::=  ConstrApp {‘with’ ConstrApp} [‘with’ WithTemplateBody]
+
 Extension         ::=  ‘extension’ [DefTypeParamClause] {UsingParamClause}
                        ‘(’ DefTermParam ‘)’ {UsingParamClause} ExtMethods
 ExtMethods        ::=  ExtMethod | [nl] <<< ExtMethod {semi ExtMethod} >>>
diff --git a/tests/pos/typeclasses-arrow0.scala b/tests/pos/typeclasses-arrow0.scala
@@ -0,0 +1,136 @@
+//> using options -language:experimental.modularity -source future
+
+class Common:
+
+  trait Ord[A]:
+    extension (x: A)
+      def compareTo(y: A): Int
+      def < (y: A): Boolean = compareTo(y) < 0
+      def > (y: A): Boolean = compareTo(y) > 0
+      def <= (y: A): Boolean = compareTo(y) <= 0
+      def >= (y: A): Boolean = compareTo(y) >= 0
+      def max(y: A): A = if x < y then y else x
+
+  trait Show[A]:
+    extension (x: A) def show: String
+
+  trait SemiGroup[A]:
+    extension (x: A) def combine(y: A): A
+
+  trait Monoid[A] extends SemiGroup[A]:
+    def unit: A
+
+  trait Functor[F[_]]:
+    extension [A](x: F[A]) def map[B](f: A => B): F[B]
+
+  trait Monad[F[_]] extends Functor[F]:
+    def pure[A](x: A): F[A]
+    extension [A](x: F[A])
+      def flatMap[B](f: A => F[B]): F[B]
+      def map[B](f: A => B) = x.flatMap(f `andThen` pure)
+end Common
+
+object Instances extends Common:
+
+  given Ord[Int] as intOrd:
+    extension (x: Int)
+      def compareTo(y: Int) =
+        if x < y then -1
+        else if x > y then +1
+        else 0
+
+  given [T: Ord] => Ord[List[T]]:
+    extension (xs: List[T]) def compareTo(ys: List[T]): Int = (xs, ys) match
+      case (Nil, Nil) => 0
+      case (Nil, _) => -1
+      case (_, Nil) => +1
+      case (x :: xs1, y :: ys1) =>
+        val fst = x.compareTo(y)
+        if (fst != 0) fst else xs1.compareTo(ys1)
+
+  given Monad[List] as listMonad:
+    extension [A](xs: List[A]) def flatMap[B](f: A => List[B]): List[B] =
+      xs.flatMap(f)
+    def pure[A](x: A): List[A] =
+      List(x)
+
+  type Reader[Ctx] = [X] =>> Ctx => X
+
+  given [Ctx] => Monad[Reader[Ctx]] as readerMonad:
+    extension [A](r: Ctx => A) def flatMap[B](f: A => Ctx => B): Ctx => B =
+      ctx => f(r(ctx))(ctx)
+    def pure[A](x: A): Ctx => A =
+      ctx => x
+
+  extension (xs: Seq[String])
+    def longestStrings: Seq[String] =
+      val maxLength = xs.map(_.length).max
+      xs.filter(_.length == maxLength)
+
+  extension [T](xs: List[T])
+    def second = xs.tail.head
+    def third = xs.tail.tail.head
+
+  extension [M[_]: Monad, A](xss: M[M[A]])
+    def flatten: M[A] =
+      xss.flatMap(identity)
+
+  def maximum[T: Ord](xs: List[T]): T =
+    xs.reduce(_ `max` _)
+
+  given [T: Ord] => Ord[T] as descending:
+    extension (x: T) def compareTo(y: T) = summon[Ord[T]].compareTo(y)(x)
+
+  def minimum[T: Ord](xs: List[T]) =
+    maximum(xs)(using descending)
+
+  def test(): Unit =
+    val xs = List(1, 2, 3)
+    println(maximum(xs))
+    println(maximum(xs)(using descending))
+    println(maximum(xs)(using descending(using intOrd)))
+    println(minimum(xs))
+
+// Adapted from the Rust by Example book: https://doc.rust-lang.org/rust-by-example/trait.html
+//
+//           lines  words  chars
+// wc Scala: 28     105     793
+// wc Rust : 57     193    1466
+
+trait Animal[Self]:
+
+  // Associated function signature; `Self` refers to the implementor type.
+  def apply(name: String): Self
+
+  // Method signatures; these will return a string.
+  extension (self: Self)
+    def name: String
+    def noise: String
+    def talk(): Unit = println(s"$name, $noise")
+end Animal
+
+class Sheep(val name: String):
+  var isNaked = false
+  def shear() =
+    if isNaked then
+      println(s"$name is already naked...")
+    else
+      println(s"$name gets a haircut!")
+      isNaked = true
+
+given Animal[Sheep]:
+  def apply(name: String) = Sheep(name)
+  extension (self: Sheep)
+    def name: String = self.name
+    def noise: String = if self.isNaked then "baaaaah?" else "baaaaah!"
+    override def talk(): Unit =
+      println(s"$name pauses briefly... $noise")
+
+/*
+
+ - In a type pattern, A <: T, A >: T, A: T, A: _ are all allowed and mean
+   T is a fresh type variable (T can start with a capital letter).
+ - instance definitions
+ - `as m` syntax in context bounds and instance definitions
+
+*/
