Is there a way to use two levels of generics in Go?

I am working on a library for genetic algorithms and wanted to know if there was a way to use two levels of generics. The class structure is that type Gene[T comparable] struct contains bases of type T; type Allele[T comparable] struct contains Gene[T]s; type Chromosome[T comparable] struct contains Allele[T]s; and type Genome[T comparable] struct contains Chromosome[T]s. I wanted to write an optimization function that could take a type Code[T comparable] interface { Gene[T] | Allele[T] | Chromosome[T] | Genome[T] } as a parameter, e.g. func Optimize[T comparable, C Code[T]](params OptimizationParams). However, accessing the methods on variables of type C resulted in the error "(type *C is pointer to type parameter, not type parameter)". If I change the function signature to func Optimize[T comparable, C *Code[T]](...), the error becomes "cannot use type Code[T] outside a type constraint: interface contains type constraints" and "gene.Recombine undefined (type *C is pointer to type parameter, not type parameter)".

I have created simplified examples that demonstrate this issue in both forms. My solution was to just write all the functions four times using the same code with just the types changed where necessary, which is a bit of a drag since I like to keep my code DRY.

Is there a way to use two levels of generics in Go? Or would the DRY solution be to create a wrapper struct?

> type *C is pointer to type parameter, not type parameter

For this error message, see https://stackoverflow.com/questions/71444847/go-with-generics-type-t-is-pointer-to-type-parameter-not-type-parameter.

Let's dereference the pointer first:

func TopAreas[T comparable, S Shape[T]](shapes []SizedShape[T, S]) [2]float32 {
	return [2]float32{(*(shapes[0].shape)).Area(), (*(shapes[1].shape)).Area()}
}

Now the error is:

(*(shapes[0].shape)).Area undefined (type S has no field or method Area)

Let's reproduce the issue with a simplified demo:

package main

import "fmt"

type T1 struct{}

func (t T1) F() {
	fmt.Println("T1")
}

type T2 struct{}

func (t T2) F() {
	fmt.Println("T2")
}

type T interface {
	T1 | T2
}

func Use[S T](t S) {
	t.F() // <== t.F undefined (type T has no field or method F)
}

func main() {
	Use(T1{})
	Use(T2{})
}

The error is:

t.F undefined (type T has no field or method F)

The first approach is to use a type assertion to check whether the object has the method F and call the method if it does:

func Use[S T](t S) {
	type I interface {
		F()
	}
	tt, ok := any(t).(I)
	if ok {
		tt.F()
	}
	panic("t does not implement the interface I")
}

Here is a full example based on your code that uses type assertion to call Area: https://go.dev/play/p/eI-RHw-Z5DQ.

A better approach is to define T as a basic interface:

type T interface {
	F()
}

And the Use func can be implemented as:

func Use(t T) {
	t.F()
}

Here is a full example based on your code that defines Shape as a basic interface: https://go.dev/play/p/YQKRLKI_f3Z.