reflect: reflect.Type does not implement comparable

[oakad]

Indeed:

func P[K comparable](d K) {
	fmt.Println(d)
}

func main() {
	d := reflect.TypeOf(int64(0))
	P(d)
}

I believe the above should work per the:

Type values are comparable, such as with the == operator, so they can be used as map keys. Two Type values are equal if they represent identical types.

[cherrymui]

There are a few proposals about making comparable works better with interface types, including reflect.Type, see e.g. #51338 , #52509 , #53734 . Closing this as a dup. Thanks.

[oakad]

@cherrymui This must be at least mentioned in the docs. Because the word "comparable" now has specific meaning and the documentation for Type becomes misleading.

[randall77]

The docs for the constraint comparable in the spec https://go.dev/ref/spec#Type_constraints are clear:

The predeclared interface type comparable denotes the set of all non-interface types that are comparable

reflect.Type is an interface type, and thus not comparable.

Note that this is different from the language meaning of "comparable", which is https://go.dev/ref/spec#Comparison_operators

I agree that using the same name for both is kind of confusing. Unfortunately English has limited words in this space so we have to make do with what we have. As the links that Cherry mentioned make clear, it was originally intended that comparable include interfaces, but we took it out because we were not sure about the semantics, and we wanted to be on the safe side of backwards compatibility.