go generics: how to declare a type parameter compatible with another type parameter

I'm looking for a way to declare type compatibility between type parameters in Go generics constraints.

More specifically, I need to say some type T is compatible with another type U. For instance, T is a pointer to a struct that implements the interface U.

Below is a concrete example of what I want to accomplish:

NOTE: Please, do not answer with alternative ways to implement "array prepend". I've only used it as a concrete application of the problem I'm looking to solve. Focusing on the specific example digresses the conversation.

func Prepend[T any](array []T, values ...T) []T {
  if len(values) < 1 { return array }

  result := make([]T, len(values) + len(array))

  copy(result, values)
  copy(result[len(values):], array)

  return result
}

The above function can be called to append elements of a given type T to an array of the same type, so the code below works just fine:

type Foo struct{ x int }
func (self *Foo) String() string { return fmt.Sprintf("foo#%d", self.x) }

func grow(array []*Foo) []*Foo {
  return Prepend(array, &Foo{x: len(array)})
}

If the array type is different than the elements being added (say, an interface implemented by the elements' type), the code fails to compile (as expected) with type *Foo of &Foo{…} does not match inferred type Base for T:

type Base interface { fmt.Stringer }
type Foo struct{ x int }
func (self *Foo) String() string { return fmt.Sprintf("foo#%d", self.x) }

func grow(array []Base) []Base {
  return Prepend(array, &Foo{x: len(array)})
}

The intuitive solution to that is to change the type parameters for Prepend so that array and values have different, but compatible types. That's the part I don't know how to express in Go.

For instance, the code below doesn't work (as expected) because the types of array and values are independent of each other. Similar code would work with C++ templates since the compatibility is validated after template instantiation (similar to duck typing). The Go compiler gives out the error invalid argument: arguments to copy result (variable of type []A) and values (variable of type []T) have different element types A and T:

func Prepend[A any, T any](array []A, values ...T) []A {
  if len(values) < 1 { return array }

  result := make([]A, len(values) + len(array))

  copy(result, values)
  copy(result[len(values):], array)

  return result
}

I've tried making the type T compatible with A with the constraint ~A, but Go doesn't like a type parameter used as type of a constraint, giving out the error type in term ~A cannot be a type parameter:

func Prepend[A any, T ~A](array []A, values ...T) []A {

What's the proper way to declare this type compatibility as generics constraints without resorting to reflection?

This is a limitation of Go's type parameter inference, which is the system that tries to automatically insert type parameters in cases where you don't define them explicitly. Try adding in the type parameter explicitly, and you'll see that it works. For example:

// This works.
func grow(array []Base) []Base {
  return Prepend[Base](array, &Foo{x: len(array)})
}

You can also try explicitly converting the *Foo value to a Base interface. For example:

// This works too.
func grow(array []Base) []Base {
  return Prepend(array, Base(&Foo{x: len(array)}))
}

Explanation

First, you should bear in mind that the "proper" use of type parameters is to always include them explicitly. The option to omit the type parameter list is considered a "nice to have", but not intended to cover all use cases.

From the blog post An Introduction To Generics:
> ##### Type inference in practice
>
> The exact details of how type inference works are complicated, but using it is not: type inference either succeeds or fails. If it succeeds, type arguments can be omitted, and calling generic functions looks no different than calling ordinary functions. If type inference fails, the compiler will give an error message, and in those cases we can just provide the necessary type arguments.
>
> In adding type inference to the language we’ve tried to strike a balance between inference power and complexity. We want to ensure that when the compiler infers types, those types are never surprising. We’ve tried to be careful to err on the side of failing to infer a type rather than on the side of inferring the wrong type. We probably have not gotten it entirely right, and we may continue to refine it in future releases. The effect will be that more programs can be written without explicit type arguments. Programs that don’t need type arguments today won’t need them tomorrow either.

In other words, type inference may improve over time, but you should expect it to be limited.

In this case:

// This works.
func grow(array []*Foo) []*Foo {
  return Prepend(array, &Foo{x: len(array)})
}

It is relatively simple for the compiler to match that the argument types of []*Foo and *Foo match the pattern []T and ...T by substitutingT = *Foo.

So why does the plain solution you gave first not work?

// Why does this not work?
func grow(array []Base) []Base {
  return Prepend(array, &Foo{x: len(array)})
}

To make []Base and *Foo match the pattern []T and ...T, just substituting T = *Foo or T = Base provides no apparent match. You have to apply the rule that *Foo is assignable to the type Base to see that T = Base works. Apparently the inference system doesn't go the extra mile to try to figure that out, so it fails here.