generics with a T type and a named function type that takes T

I have a module that defines a bunch of types

type Thing1 struct {}

type Thing2 struct {}

and named functions types that take the types above as arguments

type T1 func(t *Thing1)
type T2 func(t *Thing2)

Then it defines a map using these function types

var (
    ModThing1 = map[string]T1{ ... }
    ModThing2 = map[string]T2{ ... }
)

In my app that uses this module, I would like use a generic for Thing1 and Thing2

Something like:

func do[T any](in *T, inMap map[string]func(in *T)) {
  for _, val := range inMap {
     val(in)
  }
}
...
do[mod.Thing1](&mod.Thing1{}, mod.ModThing1)

Of course the problem is that Go wont allow this because the type of the value of the map is not the same as mod.ModThing1 value type. func(in *T)) vs mod.T1

Is there a way to get this to work?

In the function do, declare an additional type parameter F with an approximated constraint that also references T. You take advantage of T1 and T2 having similar underlying types. You don't even have to explicitly instantiate do's type arguments, both can be inferred.

func main() {
	do(&foo.Thing1{}, foo.ModThing1)
	do(&foo.Thing2{}, foo.ModThing2)
}

func do[T any, F ~func(*T)](in *T, inMap map[string]F) {
	for _, val := range inMap {
		val(in)
	}
}

Playground: https://go.dev/play/p/wiWWzXVDG7v

<hr>

If you have control over the imported package, another solution is to use a generic function type instead of T1 and T2. The principle behind this abstraction is the same. In fact, here you can see more clearly why the first solution works:

type F[T any] func(t *T)

// instead of
// type T1 func(t *Thing1)
// type T2 func(t *Thing2)

Then you declare the map variables with specific instantiations of F[T]:

var (
	ModThing1 = map[string]F[Thing1]{ ... }
	ModThing2 = map[string]F[Thing2]{ ... }
)

Then in the do function you instantiate F with the type parameter:

func do[T any](in *T, inMap map[string]F[T]) {
	for _, val := range inMap {
		val(in)
	}
}

Playground: https://go.dev/play/p/ITBqiqjjVUz

<hr>

By the way, you can also abstract the map type:

type M[T any] map[string]F[T]

func do[T any](in *T, inMap M[T]) {
	for _, val := range inMap {
		val(in)
	}
}