proposal: make generic parentheses declaration order consistent with array bracket declaration order

[gertcuykens]

https://go.googlesource.com/proposal/+/master/design/go2draft-contracts.md

Can we maybe just reorder the generic parentheses like array brackets order please?
So everything is exactly the same as the current contract proposal just reordered a bit.

package graph

contract (Node, Edge)G {
	Node Edges() []Edge
	Edge Nodes() (from, to Node)
}

type (type Node, Edge G) Graph struct { ... }
func (type Node, Edge G) New(nodes []Node) (Node, Edge)*Graph { ... }
func (g (Node, Edge)*Graph) ShortestPath(from, to Node) []Edge { ... }

// Instead of this
contract G(Node, Edge) {
	Node Edges() []Edge
	Edge Nodes() (from, to Node)
}

type Graph(type Node, Edge G) struct { ... }
func New(type Node, Edge G)(nodes []Node) *Graph(Node, Edge) { ... }
func (g *Graph(Node, Edge)) ShortestPath(from, to Node) []Edge { ... }

Basically following the same order as array's get declared [5]int

Related to: #36177 but yet another suggestion in case it wasn't suggested before

EDIT: Iteration of this proposal (see comments) to something like this to separate generics completely from regular go code

package graph

contract (Node, Edge)G {
	Node Edges() []Edge
	Edge Nodes() (from, to Node)
}

type (type Node, Edge G) ( Graph )
func (type Node, Edge G) ( New )
const _ = (Node, Edge) Graph

type Graph struct { ... }
func New(nodes []Node) *Graph { ... }
func (g *Graph) ShortestPath(from, to Node) []Edge { ... }

General generics issue: #15292 (see comment below)

[ianlancetaylor]

I don't understand why this is better. Since we are using parentheses, and since type parameters are much more like non-type parameters than they are like anything else, consistency with function declarations and calls seems more useful than consistency with array declarations and uses.

[gertcuykens]

For me it makes it more readable to distinguish generic syntax. Especially this two lines messes with my head and predict I will be making regular typo's for example forgetting the word type or use , instead of )(

type Graph(type Node, Edge G) struct { ... }
func New(type Node, Edge G)(nodes []Node) *Graph(Node, Edge) { ... }

Also I believe alignment is important

func (type Node, Edge G) New(nodes []Node) (Node, Edge)*Graph { ... }
func (type Node, Edge G) Delete(nodes []Node) (Node, Edge)*Graph { ... }
func (type Node, Edge G) ShortestPath(nodes []Node) (Node, Edge)*Graph { ... }
func (type Node, Edge G) Find(nodes []Node) (Node, Edge)*Graph { ... }
func (type Node, Edge G) Add(nodes []Node) (Node, Edge)*Graph { ... }

func New (type Node, Edge G) (nodes []Node) *Graph(Node, Edge) { ... }
func Delete (type Node, Edge G) (nodes []Node) *Graph(Node, Edge) { ... }
func ShortestPath (type Node, Edge G) (nodes []Node) *Graph(Node, Edge) { ... }
func Find (type Node, Edge G) (nodes []Node) *Graph(Node, Edge) { ... }
func Add (type Node, Edge G) (nodes []Node) *Graph(Node, Edge) { ... }

[beoran]

Hmm, I am not sure if I like this or not, however would then this syntax also be allowed?

func (type Node, Edge G) (
        New(nodes []Node) (Node, Edge)*Graph { ... }
        Delete(nodes []Node) (Node, Edge)*Graph { ... }
        ShortestPath(nodes []Node) (Node, Edge)*Graph { ... }
        Find(nodes []Node) (Node, Edge)*Graph { ... }
        Add(nodes []Node) (Node, Edge)*Graph { ... }
)

If so that could make writing generics easier, although it might make reading them harder again.

[gertcuykens]

Your suggestion looks nice to have some sort of decoration ability like const (...) and var (...) Actually if you would be able to find some sort of syntax that just completely separate generic stuff from regular go without mixing it, even if it would be more verbose it's worth the price of clarity.

func (type Node, Edge G) (
        New
        Delete
        ShortestPath
        Find
        Add
)

func New(nodes []Node) (Node, Edge)*Graph { ... }
func Delete(nodes []Node) (Node, Edge)*Graph { ... }
func ShortestPath(nodes []Node) (Node, Edge)*Graph { ... }
func Find(nodes []Node) (Node, Edge)*Graph { ... }
func Add(nodes []Node) (Node, Edge)*Graph { ... }

And if you extend it with something like const _ = (Node, Edge) Graph you would get complete separation.

package graph

contract (Node, Edge)G {
	Node Edges() []Edge
	Edge Nodes() (from, to Node)
}

type (type Node, Edge G) ( Graph )
func (type Node, Edge G) ( New )
const _ = (Node, Edge) Graph

type Graph struct { ... }
func New(nodes []Node) *Graph { ... }
func (g *Graph) ShortestPath(from, to Node) []Edge { ... }

[ianlancetaylor]

Upon discussion with Go 2 proposal review committee, we would like to fold this issue into the general generics issue #15292. Please also feel free to add a link to this issue to https://golang.org/wiki/Go2GenericsFeedback. We don't think it will be helpful to keep multiple generics syntax issues open simultaneously, spreading the discussion to too many different places.

-- for @golang/proposal-review