We’ll get to a full discussion of type parameters later on, but knowing at least what they look like is useful for the next section. So here’s an example, used in the definition of a generic function:

func min[T ~int|~float64](x, y T) T {

In this example, min[T ~int|~float64] represents the type parameter.

With that in mind…

General interfaces

…

The type T in a term of the form T or ~T cannot be a type parameter, and the type sets of all non-interface terms must be pairwise disjoint (the pairwise intersection of the type sets must be empty). Given a type parameter P:

interface {
	P                // illegal: P is a type parameter
	int | ~P         // illegal: P is a type parameter
	~int | MyInt     // illegal: the type sets for ~int and MyInt are not disjoint (~int includes MyInt)
	float32 | Float  // overlapping type sets but Float is an interface
}

This means, for example, that within our above min function, the following would be illegal:

func min[T ~int|~float64](x, y T) T {
	var x interface {
		T // illegal because T is a type parameter of the generic function
	}

We also can’t combine types and underlying types that overlap. At least this restriction doesn’t require any special understanding of generics that we haven’t covered yet.

type MyInt int
interface {
	~int | MyInt // Illegal becasue of overlapping type sets
}

Quotes from The Go Programming Language Specification Version of December 15, 2022