Weird action at a distance beyond parentheses

[ByteEater-pl]

I can't do Seq(0).sortBy(_.abs)(0). That's understandable – the (0) isn't understood as indexing but a second parameter list (implicit) for sortBy, expected to contain a value of type Ordering[Int]. The common remedy is to explicitly reach for apply, thus: Seq(0).sortBy(_.abs) apply 0. I thought I could guide the compiler to get my intention with a pair of parentheses: (Seq(0).sortBy(_.abs))(0). But no – it gives the same error message as without. What helps is ({Seq(0).sortBy(_.abs)})(0).

Additionally, rejection of {Seq(0).sortBy(_.abs)}(0) as invalid syntax also seems a wart. And the message in this case is perplexing both in worksheet mode:

; expected but ( found

and in normal mode:

end of toplevel definition expected but '(' found

[ByteEater-pl]

With this code (I tried to get something different from "end of toplevel definition expected"):

@main def f = ()
val _ = 5 + ((Seq(0).sortBy(_.abs))(0))

the message (or two, actually) is longer and appears to treat the result of sortBy – without the (0), despite it being included inside parentheses! – as an argument to +:

Found:    (0 : Int)
Required: Ordering[Int]

None of the overloaded alternatives of method + in class Int with types
 (x: Double): Double
 (x: Float): Float
 (x: Long): Long
 (x: Int): Int
 (x: Char): Int
 (x: Short): Int
 (x: Byte): Int
 (x: String): String
match arguments (Seq[Int])

And if I change parentheses to braces:

@main def f = ()
val _ = 5 + ({Seq(0).sortBy(_.abs)}(0))

it's:

')' expected, but '(' found

None of the overloaded alternatives of method + in class Int with types
 (x: Double): Double
 (x: Float): Float
 (x: Long): Long
 (x: Int): Int
 (x: Char): Int
 (x: Short): Int
 (x: Byte): Int
 (x: String): String
match arguments (Seq[Int])

[som-snytt]

TIL

scala> {List(42)}(0)
                 ^
       error: ';' expected but '(' found.

scala> ({List(42)})(0)
val res10: Int = 42

The spec for application says "if f has some value type", without reference to syntax.

I remember Scala 2's typedApply tries to apply to the result expr of a block, but I don't recall the use case offhand.

OK, I see the syntax diff in Scala 2 is SimpleExpr1, so this works:

scala> { new Runnable() { def run() = println("hi") }}.run()
hi

but args follow a SimpleExpr1, so the block must be wrapped in parens as you showed.

(In a different context, I saw Scala 3 doesn't have SimpleExpr1, so I don't know without experimenting how this changes in Scala 3.) (Sorry I don't remember that different context where I wondered recently how do they get by without a SimpleExpr1 production.)

The other syntax worth mentioning is

Seq(42,-17).sortBy(_.abs)(implicitly)(0)

but the user wants better feedback on the implicit param list, which is effectively concealed.

Edit: on wrapping a simpleexpr1 in parens, hoping it becomes { val e = (e0) ; e.id }, it can't work that way because a block is not a simpleexpr1.