Consider the following (playground):

package main

type I(type T) interface {
	M() T
}

type S(type T) struct{}

func (s S(T)) M() T {
	var zero T
	return zero
}

func TakesI(type T)(i I(T)) {}

func main() {
	var s S(int)
	var i I(int)
	i = s          // ok
	TakesI(i)      // ok
	TakesI(int)(s) // ok
	TakesI(s) // type S(int) of s does not match I(T)
}

In short, we have a generic interface I(T), a generic type S(T) which implements it, and a function which accepts an I(T). Given a value of type S(int), we can assign it to I(int), but we can only pass the function if we explicitly pass the type parameter. If we don't, we get an error type S(int) of s does not match I(T). Offhand, I would think the compiler should be able to infer just fine here, but if not it should just say cannot infer T.