anonymous rest arguments

Since parameter names can be omitted (see Anonymous Parameters), how do I type rest arguments anonymously? How about:

Named:

(...args: Any[]) => Array

Anonymous:

(...Any) => Array

[Mouvedia]

If there’s no objections I will proceed with the merge.

[ericelliott]

From chat:

When I say easy to parse, I’m not just talking about human parsing. I’m also talking about the parser itself. (...Any[]) => Array requires more complex lookahead rules than (...: Any[]) => Array because the former creates ambiguity. When we get to Any are we looking at a parameter name? (The default assumption). At what point can you discover that Any is actually the type annotation? Maybe when you hit the square brackets you can realize you’ve made a parsing mistake… at which point you have to rewind the parser state.

In the (...: Any[]) => Array example, the parameter name is already optional, and the : disambiguates and makes it clear that Any[] is the type annotation. Which means there is no lookahead required, and there won’t be a need to rewind the parser state.

A human being reading the signature might recognize the built-in Any type and assume that it’s the type annotation, but we can’t disambiguate that way in the parser, because some type names, such as Any and Predicate are perfectly valid parameter names.

I normally rate user friendliness over parser friendliness, but in this case, I feel that the (...: Any[]) => Array notation is friendlier to users, too, because it’s logically consistent with the rest of the spec rules. In fact, if we change nothing in the existing spec documentation, that is currently legal syntax. If we wanted to make it illegal, we’d actually have to add a rule to the spec to do so.

Regardless of all that, I would still recommend that users stick to (...args: Any[]) => Array because there’s no ambiguity, the intent is crystal clear, and it’s only a few more keystrokes.