@griesemer @ianlancetaylor

It'd be easy to be fixed by func F(type T)(v Result(T)) Result(T). I think it needs to make it more clear what's (Result(T)) should be.

This is working as expected. This code will work:

package main

type Result(type T) struct {
	t T
}

func F(type T)(v Result(T)) Result(T) {
	return v
}

Alternatively, you need to write (_ Result(T)) or ((Result(T))). The reason is that (Result(T)) is interpreted as (Result (T)), i.e., the result is named Result and is of parenthesized type (T), for backwards-compatibility.

This is a common mistake people are making, so we are considering changing this. This is also documented in the design draft.

PS: https://go.googlesource.com/proposal/+/refs/heads/master/design/go2draft-type-parameters.md#using-generic-types-as-unnamed-function-parameter-types

@griesemer Thanks for clarifying.

@griesemer - Sorry to comment on a closed issue, but perhaps it might make sense to add a line in https://go.googlesource.com/proposal/+/refs/heads/master/design/go2draft-type-parameters.md#using-generic-types-as-unnamed-function-parameter-types mentioning that we need to write Result(T) as (_ Result(T))/(Result(T))?

When I read that section, it seemed to suggest that the new proposal actually breaks backward compatibility, so there's no need to write code with extra parentheses.

@agnivade I'm not sure quite what you are saying. It's OK to write func F() Result(T). The case that doesn't work at the moment is func F() (Result(T)). If you really want those parens then at the moment you need to write func F() (_ Result(T)) or func F() ((Result(T))).

Ah yea sorry about that. I realize now that I went on a slight tangent. I just wanted some clarification about the syntax added to the doc. In my case, what I needed was (_ Result(T))/((Result(T))), as you can see here. But I didn't realize that and wrote Result(T). It took me some googling to figure this out because it wasn't very clear from the error message, which was this:

/tmp/go2go-run630056446/cache.go2:43:3: expected operand, found 'return' (and 1 more errors)

This is what I would like to be added in the doc. (Or is it already there somewhere and I have missed it?)

I think that the current parser doesn't yet fully support the syntax described in the design draft. Let's revisit when that work is done.

FWITW, the required pair of surrounding parentheses gets removed by gofmt, both on the playground and locally at 9fe9a32, which is slightly annoying since these are required for successful compilation.

Example (https://go2goplay.golang.org/p/lr-Nvr1ydPA)

package main

func main() {}

type A(type T) interface{}

// (1) try:
func _(type T)() (A(T), error) { return nil, nil }
//
//  --> error: mixed named and unnamed function parameters

// (2) add parentheses:
func _(type T)() ((A(T)), error) { return nil, nil }
//
//  --> ok, compiles

// (3) run gofmt on (2) gets you back to (1)

Something similar (https://go2goplay.golang.org/p/zJ7wmOIPWxK)

package main

func main() {}

type A(type T) interface{}

func _(type T)()    A(T)    { return nil } // ok
func _(type T)()   (A(T))   { return nil } // nok: cannot convert nil (untyped nil value) to T
func _(type T)()  ((A(T)))  { return nil } // ok
func _(type T)() (((A(T)))) { return nil } // ok

func _(type T)()   (A(T), error)  { return nil, nil } // mixed named and unnamed function parameters
func _(type T)()  ((A(T)), error) { return nil, nil } // ok

func _(type T)()   (a A(T), err error)  { return nil, nil } // ok
func _(type T)()  (a (A(T)), err error) { return nil, nil } // ok

PS: Sorry to comment on a closed issue, but I also don't think this is worth opening a new one, just let me know if I should do it anyway.