Use infix extension to indicate right associativity with natural order

Author: nicolasstucki

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

@@ -996,11 +996,18 @@ object desugar {
 
               def badRightAssoc(problem: String) =
                 report.error(em"right-associative extension method $problem", mdef.srcPos)
-                () // extParamss ++ mdef.paramss
+                extParamss ++ mdef.paramss
 
               rightParam match
                 case ValDefs(vparam :: Nil) =>
-                  if !vparam.mods.is(Given) then
+                  if vparam.mods.is(Given) then
+                    badRightAssoc("cannot start with using clause")
+                  else if mdef.mods.is(Infix) then
+                    // New encoding:
+                    // we keep the extension method as is and rely on the swap of arguments at call site
+                    extParamss ++ mdef.paramss
+                  else
+                    // Old encoding:
                     // we merge the extension parameters with the method parameters,
                     // swapping the operator arguments:
                     // e.g.
@@ -1010,16 +1017,13 @@ object desugar {
                     //   def %:[A](using B)[E](f: F)(c: C)(using D)(g: G)(using H): Res = ???
                     //
                     // If you change the names of the clauses below, also change them in right-associative-extension-methods.md
-                    // val (leftTyParamsAndLeadingUsing, leftParamAndTrailingUsing) = extParamss.span(isUsingOrTypeParamClause)
-                    () // leftTyParamsAndLeadingUsing ::: rightTyParams ::: rightParam :: leftParamAndTrailingUsing ::: paramss1
-                  else
-                    badRightAssoc("cannot start with using clause")
+                    val (leftTyParamsAndLeadingUsing, leftParamAndTrailingUsing) = extParamss.span(isUsingOrTypeParamClause)
+                    leftTyParamsAndLeadingUsing ::: rightTyParams ::: rightParam :: leftParamAndTrailingUsing ::: paramss1
                 case _ =>
                   badRightAssoc("must start with a single parameter")
             case _ =>
               // no value parameters, so not an infix operator.
-              () // extParamss ++ mdef.paramss
-          extParamss ++ mdef.paramss
+              extParamss ++ mdef.paramss
         else
           extParamss ++ mdef.paramss
     ).withMods(mdef.mods | ExtensionMethod)

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

@@ -7,7 +7,7 @@ import util.{SourceFile, SourcePosition, SrcPos}
 import core.Contexts.*
 import core.Decorators.*
 import core.NameOps.*
-import core.Flags.{JavaDefined, ExtensionMethod}
+import core.Flags.{JavaDefined, ExtensionMethod, Infix}
 import core.StdNames.nme
 import ast.Trees.mods
 import annotation.constructorOnly
@@ -215,8 +215,8 @@ abstract class Positioned(implicit @constructorOnly src: SourceFile) extends Src
         check(tree.trailingParamss)
       case tree: DefDef if tree.mods.is(ExtensionMethod) =>
         tree.paramss match
-          // case vparams1 :: vparams2 :: rest if tree.name.isRightAssocOperatorName =>
-          //   // omit check for right-associatiove extension methods; their parameters were swapped
+          case vparams1 :: vparams2 :: rest if tree.name.isRightAssocOperatorName && !tree.mods.is(Infix) =>
+            // omit check for right-associatiove extension methods; their parameters were swapped
           case _ =>
             check(tree.paramss)
         check(tree.tpt)

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -933,35 +933,35 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         val coreSig =
           if isExtension then
             val paramss =
-              // if tree.name.isRightAssocOperatorName then
-              //   // If you change the names of the clauses below, also change them in right-associative-extension-methods.md
-              //   // we have the following encoding of tree.paramss:
-              //   //   (leftTyParams ++ leadingUsing
-              //   //      ++ rightTyParams ++ rightParam
-              //   //      ++ leftParam ++ trailingUsing ++ rest)
-              //   //   e.g.
-              //   //     extension [A](using B)(c: C)(using D)
-              //   //       def %:[E](f: F)(g: G)(using H): Res = ???
-              //   //   will have the following values:
-              //   //   - leftTyParams = List(`[A]`)
-              //   //   - leadingUsing = List(`(using B)`)
-              //   //   - rightTyParams = List(`[E]`)
-              //   //   - rightParam = List(`(f: F)`)
-              //   //   - leftParam = List(`(c: C)`)
-              //   //   - trailingUsing = List(`(using D)`)
-              //   //   - rest = List(`(g: G)`, `(using H)`)
-              //   // we need to swap (rightTyParams ++ rightParam) with (leftParam ++ trailingUsing)
-              //   val (leftTyParams, rest1) = tree.paramss.span(isTypeParamClause)
-              //   val (leadingUsing, rest2) = rest1.span(isUsingClause)
-              //   val (rightTyParams, rest3) = rest2.span(isTypeParamClause)
-              //   val (rightParam, rest4) = rest3.splitAt(1)
-              //   val (leftParam, rest5) = rest4.splitAt(1)
-              //   val (trailingUsing, rest6) = rest5.span(isUsingClause)
-              //   if leftParam.nonEmpty then
-              //     leftTyParams ::: leadingUsing ::: leftParam ::: trailingUsing ::: rightTyParams ::: rightParam ::: rest6
-              //   else
-              //     tree.paramss // it wasn't a binary operator, after all.
-              // else
+              if tree.name.isRightAssocOperatorName && !tree.mods.is(Infix) && !tree.symbol.is(Infix) then
+                // If you change the names of the clauses below, also change them in right-associative-extension-methods.md
+                // we have the following encoding of tree.paramss:
+                //   (leftTyParams ++ leadingUsing
+                //      ++ rightTyParams ++ rightParam
+                //      ++ leftParam ++ trailingUsing ++ rest)
+                //   e.g.
+                //     extension [A](using B)(c: C)(using D)
+                //       def %:[E](f: F)(g: G)(using H): Res = ???
+                //   will have the following values:
+                //   - leftTyParams = List(`[A]`)
+                //   - leadingUsing = List(`(using B)`)
+                //   - rightTyParams = List(`[E]`)
+                //   - rightParam = List(`(f: F)`)
+                //   - leftParam = List(`(c: C)`)
+                //   - trailingUsing = List(`(using D)`)
+                //   - rest = List(`(g: G)`, `(using H)`)
+                // we need to swap (rightTyParams ++ rightParam) with (leftParam ++ trailingUsing)
+                val (leftTyParams, rest1) = tree.paramss.span(isTypeParamClause)
+                val (leadingUsing, rest2) = rest1.span(isUsingClause)
+                val (rightTyParams, rest3) = rest2.span(isTypeParamClause)
+                val (rightParam, rest4) = rest3.splitAt(1)
+                val (leftParam, rest5) = rest4.splitAt(1)
+                val (trailingUsing, rest6) = rest5.span(isUsingClause)
+                if leftParam.nonEmpty then
+                  leftTyParams ::: leadingUsing ::: leftParam ::: trailingUsing ::: rightTyParams ::: rightParam ::: rest6
+                else
+                  tree.paramss // it wasn't a binary operator, after all.
+              else
                 tree.paramss
             val trailingParamss = paramss
               .dropWhile(isUsingOrTypeParamClause)

docs/_docs/reference/contextual/right-associative-extension-methods.md

@@ -36,7 +36,22 @@ single explicit term parameter (in other words, `rightParam` is present). In the
 
 The Scala compiler pre-processes a right-associative infix operation such as `x +: xs`
 to `xs.+:(x)` if `x` is a pure expression or a call-by-name parameter and to `val y = x; xs.+:(y)` otherwise. This is necessary since a regular right-associative infix method
-is defined in the class of its right operand. To make up for this swap,
+is defined in the class of its right operand.
+
+### Natural Order Right-Associative Extension Methods
+If the right-associative extension methods is defined as infix, then the extension is used in its natural order. The `leftParam` is the receiver and
+the `rightParam` is the argument. The order of the parameters is kept consistent with the order of the arguments at call site after desugaring.
+For instance:
+
+```scala
+  extension [T](xs: List[T])
+    infix def +:: (x: T): List[T] = ...
+
+  y +:: ys // ys.::y // +::(ys)(y)
+```
+
+### Inverted Right-Associative Extension Methods
+To make up for the swap in the order at call site,
 the expansion of right-associative extension methods performs the inverse parameter swap. More precisely, if `rightParam` is present, the total parameter sequence
 of the extension method's expansion is:
 
@@ -59,6 +74,27 @@ For instance, the `+::` method above would become
 ```
 
 This expansion has to be kept in mind when writing right-associative extension
-methods with inter-parameter dependencies.
+methods with inter-parameter dependencies. To avoid this limitation use _natural order right-associative extension methods_.
+
+This expansion also introduces some inconsistencies when calling the extension methods in non infix form. The user needs to invert the order of the arguments at call site manually. For instance:
+
+```scala
+  extension [T](x: T)
+    def *:(xs: List[T]): List[T] = ...
+
+  y.*:(ys) // error when following the parameter definition order
+  ys.*:(y)
+
+  *:(y)(ys) // error when following the parameter definition order
+  *:(ys)(y)
+```
 
-An overall simpler design could be obtained if right-associative operators could _only_ be defined as extension methods, and would be disallowed as normal methods. In that case neither arguments nor parameters would have to be swapped. Future versions of Scala should strive to achieve this simplification.
+Another limitation of this representation is that it is impossible to pass the
+type parameters of the `def` explicitly. For instance:
+
+```scala
+  extension (x: Int)
+    def *:[T](xs: List[T]): List[T] = ???
+
+  xs.*:[Int](1) // error when trying to set T explicitly
+```

library/src/scala/IArray.scala

@@ -319,10 +319,14 @@ object IArray:
     def zipAll[T1 >: T, U](that: Iterable[U], thisElem: T1, thatElem: U): IArray[(T1, U)] = genericArrayOps(arr).zipAll(that, thisElem, thatElem)
     def zipWithIndex: IArray[(T, Int)] = genericArrayOps(arr).zipWithIndex
 
-  extension [T, U >: T: ClassTag](arr: IArray[U])
-    def ++:(prefix: IterableOnce[T]): IArray[U] = genericArrayOps(arr).prependedAll(prefix)
-    def ++:(prefix: IArray[T]): IArray[U] = genericArrayOps(arr).prependedAll(prefix)
-    def +:(x: T): IArray[U] = genericArrayOps(arr).prepended(x)
+  extension [T, U >: T: ClassTag](prefix: IterableOnce[T])
+    def ++:(arr: IArray[U]): IArray[U] = genericArrayOps(arr).prependedAll(prefix)
+
+  extension [T, U >: T: ClassTag](prefix: IArray[T])
+    def ++:(arr: IArray[U]): IArray[U] = genericArrayOps(arr).prependedAll(prefix)
+
+  extension [T, U >: T: ClassTag](x: T)
+    def +:(arr: IArray[U]): IArray[U] = genericArrayOps(arr).prepended(x)
 
   // For backwards compatibility with code compiled without -Yexplicit-nulls
   private inline def mapNull[A, B](a: A, inline f: B): B =

presentation-compiler/test/dotty/tools/pc/tests/hover/HoverTypeSuite.scala

@@ -152,8 +152,8 @@ class HoverTypeSuite extends BaseHoverSuite:
          |class C
          |
          |object Foo:
-         |    extension [R](using A)(res: R)(using B)
-         |      def %:[T](main: T)(using C): R = ???
+         |    extension [T](using A)(main: T)(using B)
+         |      def %:[R](res: R)(using C): R = ???
          |    given A with {}
          |    given B with {}
          |    given C with {}
@@ -162,7 +162,7 @@ class HoverTypeSuite extends BaseHoverSuite:
          |end Foo
          |""".stripMargin,
       """|Int
-         |extension [R](using A)(using B)(res: R) def %:[T](main: T)(using C): R""".stripMargin.hover
+         |extension [T](using A)(main: T) def %:[R](res: R)(using B)(using C): R""".stripMargin.hover
     )
 
   @Test def `using` =

tests/neg-custom-args/captures/lazylists-exceptions.scala

@@ -20,8 +20,8 @@ final class LazyCons[+T](val x: T, val xs: () => LazyList[T]^) extends LazyList[
   def tail: LazyList[T]^{this} = xs()
 end LazyCons
 
-extension [A](xs1: => LazyList[A]^)
-  def #:(x: A): LazyList[A]^{xs1} =
+extension [A](x: A)
+  def #:(xs1: => LazyList[A]^): LazyList[A]^{xs1} =
     LazyCons(x, () => xs1)
 
 def tabulate[A](n: Int)(gen: Int => A): LazyList[A]^{gen} =

tests/neg/i13075.scala

@@ -8,8 +8,8 @@ object Implementing_Tuples:
   type *:[H, T <: Tup] = ConsTup[H, T] // for type matching
   type EmptyTup = EmptyTup.type        // for type matching
 
-  extension [T <: Tup](tail: T)
-    def *:[H](head: H) = ConsTup(head, tail)
+  extension [H](head: H)
+    def *:[T <: Tup](tail: T) = ConsTup(head, tail)
 
   type Fold[T <: Tup, Seed, F[_,_]] = T match
     case EmptyTup => Seed

tests/neg/i9562.scala

@@ -9,5 +9,4 @@ object Unrelated:
     def h1: Int = foo     // error
     def h2: Int = h1 + 1  // OK
     def h3: Int = g       // error
-  extension (x: Int)
-    def ++:(f: Foo): Int = f.h1 + x  // OK
+    def ++: (x: Int): Int = h1 + x  // OK

tests/pos-custom-args/captures/lazylists-exceptions.scala

@@ -42,8 +42,8 @@ extension [A](xs: LzyList[A]^)
     if n == 0 then xs else xs.tail.drop(n - 1)
 end extension
 
-extension [A](xs1: => LzyList[A]^)
-  def #:(x: A): LzyList[A]^{xs1} =
+extension [A](x: A)
+  def #:(xs1: => LzyList[A]^): LzyList[A]^{xs1} =
     LzyCons(x, () => xs1)
 
 def lazyCons[A](x: A, xs1: => LzyList[A]^): LzyList[A]^{xs1} =

tests/pos-custom-args/captures/logger.scala

@@ -32,8 +32,8 @@ final class LazyCons[+T](val x: T, val xs: () => LazyList[T]^) extends LazyList[
   def tail: LazyList[T]^{this} = xs()
 end LazyCons
 
-extension [A](xs1: => LazyList[A]^)
-  def #::(x: A): LazyList[A]^{xs1} =
+extension [A](x: A)
+  def #::(xs1: => LazyList[A]^): LazyList[A]^{xs1} =
     LazyCons(x, () => xs1)
 
 extension [A](xs: LazyList[A]^)

tests/pos-custom-args/captures/strictlists.scala

@@ -28,11 +28,12 @@ extension [A](xs: StrictList[A])
   def concat(ys: StrictList[A]): StrictList[A] =
     if xs.isEmpty then ys
     else xs.head #: xs.tail.concat(ys)
-
-  def #:(x: A): StrictList[A] =
-    StrictCons(x, xs)
 end extension
 
+extension [A](x: A)
+  def #:(xs1: StrictList[A]): StrictList[A] =
+    StrictCons(x, xs1)
+
 def tabulate[A](n: Int)(gen: Int => A) =
   def recur(i: Int): StrictList[A] =
     if i == n then StrictNil

tests/pos/i19197.scala

@@ -1,5 +1,5 @@
 extension (tuple: Tuple)
-  def **:[T >: tuple.type <: Tuple, H](x: H): H *: T = ???
+  infix def **:[T >: tuple.type <: Tuple, H](x: H): H *: T = ???
 
 def test1: (Int, String, Char) = 1 **: ("a", 'b')
 def test2: (Int, String, Char) = ("a", 'b').**:(1)

tests/pos/i9562.scala

@@ -8,6 +8,4 @@ object Unrelated:
   extension (f: Foo)
     def h1: Int = 0
     def h2: Int = h1 + 1  // OK
-
-  extension (x: Int)
-    def ++: (f: Foo): Int = f.h2 + x  // OK
+    def ++: (x: Int): Int = h2 + x  // OK

tests/pos/reference/extension-methods.scala

@@ -10,7 +10,7 @@ object ExtMethods:
   assert(circle.circumference == circumference(circle))
 
   extension (x: String) def < (y: String) = x.compareTo(y) < 0
-  extension [Elem](xs: Seq[Elem]) def #: (x: Elem) = x +: xs
+  extension [Elem](x: Elem) def #: (xs: Seq[Elem]) = x +: xs
   extension (x: Number) infix def min (y: Number) = x
 
   assert("a" < "bb")

tests/run/errorhandling/Result.scala

@@ -35,15 +35,12 @@ object Result:
       case (Err(e), Ok(_))    => Err(e :: Nil)
       case (Err(e1), Err(e2)) => Err(e1 :: e2 :: Nil)
 
-  end extension
-
-  extension [U <: Tuple, E](other: Result[U, List[E]])
     /** Validate both `r` and `other`; return a tuple of successes or a list of failures.
      *  Unlike with `zip`, the right hand side `other` must be a `Result` returning a `Tuple`,
      *  and the left hand side is added to it. See `Result.empty` for a convenient
      *  right unit of chains of `*:`s.
      */
-    def *: [T](r: Result[T, E]): Result[T *: U, List[E]] = (r, other) match
+    def *: [U <: Tuple](other: Result[U, List[E]]): Result[T *: U, List[E]] = (r, other) match
       case (Ok(x), Ok(ys))     => Ok(x *: ys)
       case (Ok(_), es: Err[?]) => es
       case (Err(e), Ok(_))     => Err(e :: Nil)

tests/run/export-in-extension.scala

@@ -11,7 +11,7 @@ object O:
     export cm.*
     def succ: Int = x + 1
     def succ2: Int = succ + 1
-    def ::: (y: Int) = y - x
+    def ::: (y: Int) = x - y
 
 object O2:
   import O.C
@@ -20,7 +20,7 @@ object O2:
     export cm.{bar, baz, bam, ::}
     def succ: Int = x + 1
     def succ2: Int = succ + 1
-    def ::: (y: Int) = y - x
+    def ::: (y: Int) = x - y
 
 @main def Test =
   import O.*

tests/run/i11583.scala

@@ -12,11 +12,11 @@ class Env:
 //     */
 //   def &&:[T <: ctx.Term](trm: T)(ext: env.Extra): (ctx.Type, T, env.Extra) = (tpe, trm, ext)
 
-extension [Ctx <: Context, T <: Boolean](using ctx: Ctx)(trm: T)(using env: Env)
-  def :#:(tpe: String)(ext: env.Extra): (String, T, env.Extra) = (tpe, trm, ext)
+extension [Ctx <: Context](using ctx: Ctx)(tpe: String)(using env: Env)
+  def :#:[T <: Boolean](trm: T)(ext: env.Extra): (String, T, env.Extra) = (tpe, trm, ext)
 
-extension [T <: Tuple](t: T)
-  def :*:[A](a: A): A *: T = a *: t
+extension [A](a: A)
+  def :*:[T <: Tuple](t: T): A *: T = a *: t
 
 @main def Test =
 

tests/run/i9530.scala

@@ -8,7 +8,7 @@ trait Scope:
 extension (using s: Scope)(expr: s.Expr)
    def show = expr.toString
    def eval = s.value(expr)
-   def *: (other: s.Expr) = s.combine(other, expr)
+   def *: (other: s.Expr) = s.combine(expr, other)
 
 def f(using s: Scope)(x: s.Expr): (String, s.Value) =
    (x.show, x.eval)

tests/run/instances.scala

@@ -31,7 +31,7 @@ object Test extends App {
   extension [T](xs: List[List[T]])
     def flattened = xs.foldLeft[List[T]](Nil)(_ ++ _)
 
-  extension [T](xs: Seq[T]) def :: (x: T) = x +: xs
+  extension [T](x: T) def :: (xs: Seq[T]) = x +: xs
 
   val ss: Seq[Int] = List(1, 2, 3)
   val ss1 = 0 :: ss