golang generics_Bracket selection for Go generics: []or()?

Go language designers Robert Griesemer and Ian Lance Taylor recently posted on the Golang official forum to discuss issues about generics and their use of parentheses.

They mentioned that many people have expressed concerns about the syntax of generics, particularly regarding type parameter declarations and function instances, and the choice of brackets for generics.

Common computer keyboards provide four pairs of single-character symmetrical brackets, namely parentheses ( ), square brackets [ ], curly brackets { } and angle brackets . Based on this, they explain why the current generics draft uses parentheses in the example code. First, Go uses curly braces to delimit code blocks, composite literals, and some composite types, so it is almost impossible to use curly braces for generics without serious syntax problems. As for angle brackets, the parser requires that requires an unbounded lookahead in some cases.

So only ( ) and [ ] are left to choose from. However, the lack of qualifying square brackets can cause ambiguity in the type declarations of arrays and slices, and to a lesser extent when parsing index expressions. So at the beginning of the design they decided to use parentheses because they seemed to be more consistent with the style of the Go language and seemed to have the least problems.

In order for parentheses to work properly, and for backward compatibility, they said they had to introduce the type keyword in the type parameter list. Finally, they found additional parsing ambiguities in parameter lists, compound literals, and embedded types that required more nested parentheses to resolve. But even so, they decided to continue using parentheses because there were more important design issues to solve at the time.

Now they have decided to reconsider this initial decision. If you declare type parameters using square brackets only, you declare an array as follows:

type A [N]E

But this cannot be distinguished from a generic declaration:

type A[N] E

But if it is acceptable additional type keyword, then the ambiguity disappears:

type A[type N] E

Also, use small The ambiguity created when using parentheses does not appear to occur within square brackets. Here are some examples of using square brackets without additional nested parentheses:

using () using [] func f((T(int)) func f(T[ int]) struct{ (T(int)) } struct{ T[int] } interface{ (T(int)) } interface{ T[int] } [](T(int)){} []T[int ]{}

In order to better understand and test, they said they will start to modify the prototype implementation so that generics can use parentheses or square brackets (note not both at the same time Mixed, only one can be used). These changes will first be committed to the dev.go2go branch and will eventually appear on the Go playground.

Robert and Ian said that in addition to using square brackets, There are alternative, well-researched symbols to choose from that will allow them to make more informed decisions.

https://groups.google.com/forum/#!topic/golang- nuts/7t-Q2vt60J8