Type can be applied only once to type arguments.

[scabug]

The EBNF of SimpleType and TypeArgs in the current (2.9) version of the scala language specification is:

SimpleType ::= SimpleType TypeArgs
             | SimpleType ‘#’ id
             | StableId
             | Path ‘.’ ‘type’
             | ‘(’ Types ’)’

TypeArgs ::= ‘[’ Types ‘]’

This would allow currying of type args, i.e. Foo[A][B]...[N]. However, as there cannot be more than one TypeParamClause for any type, class or trait, the syntax makes no sense and should be invalid.

For the same reason (A, B)[C] should also be invalid syntax, since that would be an alias for scala.Tuple2[A,B][C].

[scabug]

Imported From: https://issues.scala-lang.org/browse/SI-6729?orig=1
Reporter: Heikki Vesalainen (hvesalai)
Affected Versions: 2.9.2

[scabug]

@adriaanm said:
This is implemented in the parser as specified. We could in principle give an error during parsing in some cases, but not all.

[scabug]

@adriaanm said:
This is valid Scala:

scala> class C { def apply[T] = new C }
defined class C

scala> (new C)[Int][String]
res0: C = C@52437b9a

[scabug]

Heikki Vesalainen (hvesalai) said (edited on Mar 15, 2014 10:50:27 AM UTC):
I think Adriaan's response did not answer the issue and does not warrant the closing of this issue.

While it is true that (new C)[Int][String] is valid Scala, the statement is a value expression (see Chapter 6 Expressions) and has nothing to do with this issue, which is about SimpleType (Chapter 3, Types).

For those who are not versed in reading BNF, the issue here is the rule
SimpleType ::= SimpleType TypeArgs
which, by recursive application, expands to
SimpleType ::= SimpleType TypeArgs TypeArgs
This rule should be rewritten so that the recursion is not possible. To make it clear, the bug is primarily in the BNF. I don't know how the parser/compiler is implemented.

As for Adriaans example, it is a SimpleExpr1, which expands as follows using the rules of Chapter 6:

SimpleExpr1 
=> SimpleExpr TypeArgs
=> SimpleExpr1 TypeArgs
=> SimpleExpr TypeArgs TypeArgs
=> etc, etc
=> ‘(’ 'new' ClassTemplate ‘)’ TypeArgs TypeArgs
=> (new C)[Int][String]

I.e. the example is not relevant to this case as it does not employ the SimpleType rules for the TypeArgs.

[scabug]

@adriaanm said:
You're absolutely right. I was seeing what I wanted to see: fewer specification bugs :-)

[scabug]

@adriaanm said:
For 2.11 I'm focussing on fixing discrepancies between the spec and the implementation, and this still isn't one. The parser accepts repeated type application in types as well, but the type checker will disallow it. Since the EBNF only governs what the parser accepts, this is still implemented as specified.

We should consider making the spec stricter in 2.12. Though I had always hoped we'd go the other way and add support for this instead.

[scabug]

@xeno-by said:
In principle, how hard would it be to support multiple type parameter lists?

[scabug]

@paulp said:
In principle in principle, or in principle in practice?

[scabug]

@xeno-by said:
Both discussions are relevant to my interests.

[scabug]

@SethTisue said:
There is now a SIP for multiple implicit parameter lists: scala/docs.scala-lang#520