Get type parameter from a generic struct using reflection

Imagine I have the following struct:

type MyGeneric[T string | int] struct {
}

I want to check whether the generic used to instantiate that struct was a string or a int when creating a new MyGeneric.

myGenericString := MyGeneric[string]{}
myGenericString.canHandle("hello") -> should return true
myGenericString.canHandle(8) -> should return false

func (mG MyGeneric[T]) canHandle(value any) bool {
    // how to get what T is the same type as value
}

Just instantiate the T directly to get its value.

type MyGeneric[T any] struct {
}

func (mG MyGeneric[T]) canHandle(value any) bool {
	var t T
	tt := reflect.TypeOf(t)

	vt := reflect.TypeOf(value)

	fmt.Printf("-> %v == %v\n", tt, vt)
	return tt == vt
}

type empty struct{}

func main() {
	fmt.Printf("%v\n", MyGeneric[string]{}.canHandle(""))
	fmt.Printf("%v\n", MyGeneric[string]{}.canHandle(1))
	fmt.Printf("%v\n", MyGeneric[MyGeneric[struct{}]]{}.canHandle(MyGeneric[struct{}]{}))
	fmt.Printf("%v\n", MyGeneric[MyGeneric[struct{}]]{}.canHandle(MyGeneric[empty]{}))
}

Output:

-> string == string
true
-> string == int
false
-> main.MyGeneric[struct {}] == main.MyGeneric[struct {}]
true
-> main.MyGeneric[struct {}] == main.MyGeneric[main.empty]
false

If you are worried about T allocating too much unused stack, make it an array instead:

var tArr [0]T
tt := reflect.TypeOf(tArr).Elem()

It hasn't been implemented yet. There is an open proposal about adding the necessary methods to reflect.Type.

The current workaround as of Go 1.19 is to parse the string obtained from TypeOf. Something like this:

var r = regexp.MustCompile("[A-Za-z0-9_]+\\.[A-Za-z0-9_]+\\[(.*)\\]")

func (mG MyGeneric[T]) typeParam(value any) {
    tname := reflect.TypeOf(mG).String() // this is `main.MyGeneric[string]`
	match := r.FindStringSubmatch(tname)
	fmt.Println(match[1]) // string
}

This if the goal is just to obtain the name of the type parameter. It's not great, as it depends on the type's string representation. On the bright side, it doesn't force you to think about what happens if you instantiate T with interfaces.

If you need to do further computations with the type of T, e.g. compare it to other types etc. @SOFe’s answer provides a solution that doesn’t depend on arbitrary string representations.

However watch out for T instantiated with interfaces: see also https://stackoverflow.com/questions/74000242/in-golang-how-to-compare-interface-as-generics-type-to-nil

Another solution is to add a placeHolder field to your struct, that can be used to get its type via type switch to avoid reflect:

type MyGeneric[T string | int] struct {
  placeHolder T
}

func (mG MyGeneric[T]) canHandle(value any) bool {
    switch t1 := any(p.placeHolder).(type) {
	case any:
		switch t2 := value.(type) {
		case any:
			return t1 == t2
		}
	}
	return false
}