Two thoughts: 1. How useful is it in practice to have separate start and end delimiters? Does it matter for nested declarations? I didn't see any nested declarations in the Draft Design document <https://go.googlesource.com/proposal/+/refs/heads/master/design/go2draft-type-parameters.md>, for example. If allow the same token on both sides, we could use the vertical bar, and not require the type keyword at all:
func f(T|int|) struct{ T|int| } interface{ T|int| } []T|int|{} type S|T| struct { v T } (A concrete example is included at the end of this e-mail.) The above was one of the options Matt McCullough outlined in "Towards Clarity: Syntax Changes for Contracts in Go <https://gist.github.com/tooolbox/6bde6925a1a8c78cb593b2c11e977b07#non-parenthetical-delimiters> ". 2. Otherwise, could we also consider double square brackets so it becomes immediately obvious that the expression has nothing to do with an array? (The type keyword is not needed here either.) func f(T[[int]]) struct{ T[[int]] } interface{ T[[int]] } []T[[int]]{} type S[[T]] struct { v T } (The same example in this style is included at the end of this e-mail.) On the whole, I prefer [[...]] over |...| over [...] over (...), but would also prefer that type declarations stick out easily enough. jpap PS. An example from Matt Layher <https://mdlayher.com/blog/go-generics-draft-design-building-a-hashtable/>, rewritten using vertical bars: // Package hashtable implements a basic hashtable for generic key/value pairs. package hashtable // A Table is a basic generic hashtable. type Table|K comparable, V interface{}| struct { // hash is a function which can hash a key of type K with t.m. hash func(key K, m int) int m int table [][]kv|K, V| } // A kv stores generic key/value data in a Table. type kv|K, V| struct { Key K Value V } // New creates a table with m internal buckets which uses the specified hash // function for an input type K. func New|K comparable, V interface{}|(m int, hash func(K, int) int) *Table|K, V| { return &Table|K, V|{ hash: hash, m: m, table: make([][]kv|K, V|, m), } } PPS. The same example from Matt Layher <https://mdlayher.com/blog/go-generics-draft-design-building-a-hashtable/>, rewritten using [[...]]: // Package hashtable implements a basic hashtable for generic key/value pairs. package hashtable // A Table is a basic generic hashtable. type Table[[K comparable, V interface{}]] struct { // hash is a function which can hash a key of type K with t.m. hash func(key K, m int) int m int table [][]kv[[K, V]] } // A kv stores generic key/value data in a Table. type kv[[K, V]] struct { Key K Value V } // New creates a table with m internal buckets which uses the specified hash // function for an input type K. func New[[K comparable, V interface{}]](m int, hash func(K, int) int) *Table[[K, V]] { return &Table[[K, V]]{ hash: hash, m: m, table: make([][]kv[[K, V]], m), } } -- You received this message because you are subscribed to the Google Groups "golang-nuts" group. To unsubscribe from this group and stop receiving emails from it, send an email to golang-nuts+unsubscr...@googlegroups.com. To view this discussion on the web visit https://groups.google.com/d/msgid/golang-nuts/3f0b6dc9-6ff1-4b20-bb09-8ef1aeb688beo%40googlegroups.com.