How to set multiple types for generic values in Go correctly?

I want to set multiple types for values of hashmap in Golang. I implemented golang generics any, and wrote function that returned map[string]any.

However, after I ran the code, it returned

$ cannot use r.Method (variable of type string) as type T in map literal

What is the correct way of setting multiple types for values of hashmap in Go?

Here's my code

package main

type RequestProperty struct {
	Method string
	Params []any
	Id     int
}

func SetRequestProperty[T any](payloadCombine bool) map[string]T {
	var p map[string]T
	var r = RequestProperty{
		Method: "SET_PROPERTY",
		Params: []any{"combined", payloadCombine},
		Id:     5,
	}
    // just for test
	p = map[string]T{
		"method": r.Method,  // << Error Here
	}

	return p
}

func main() {
    p := SetRequestProperty(true)
}

[EDIT]
This seems to be working though... I don't know why.

package main

type RequestProperty struct {
	Method string
	Params []any
	Id     int
}

// delete [T any], map[string]T 
// change it to map[string]any
func SetRequestProperty(payloadCombine bool) map[string]any {
	var p map[string]any
	var r = RequestProperty{
		Method: "SET_PROPERTY",
		Params: []any{"combined", payloadCombine},
		Id:     5,
	}
    // just for test
	p = map[string]any{
		"method": r.Method,
	}

	return p
}

func main() {
    p := SetRequestProperty(true)
}

Shouldn't T just act like an alias to type any? Am I misunderstanding something?

> Shouldn't T just act like an alias to type any?

No, it shouldn't.

T is a type parameter, not any. It is only constrained by any.

More generally: a type parameter is not its constraint.

Each time a generic function is instantiated, T is assigned a concrete type argument — which satisfies its constraint — and within the function body, map[string]T becomes a map from string to whatever the concrete T is.

p := SetRequestProperty[int](true)
// makes body look like: `var p map[string]int`
// the literal `map[string]int{"method": r.Method}` obviously can't work

Therefore at compile time, the compiler will reject assignments to T that are not compatible with all types in T's type set. The code map[string]T{"method": r.Method} doesn't compile because:

• T is constrained by any, so its type set comprises anything
• r.Method is of type string, and string isn't assignable to anything.

<hr>

With map[string]any instead any is not used as a constraint, it is used as a static type, which is an alias of interface{} and all types are always assignable to the empty interface.

If you want to have a container with different runtime types, using any as a static type as in map[string]any is the only way. To restrict allowed types, use basic interfaces instead of type parameters.

See also the top-voted answer here: https://stackoverflow.com/questions/71887083/what-are-the-benefits-of-replacing-an-interface-argument-with-a-type-parameter