Go generics: return slice of underlying type as []T

I am working on a genetic algorithm library, and I use a generic type declaration for the bases of each gene, i.e. type Gene[T comparable] struct { Bases: []T }. The reason for this is that not every problem can be solved using a particular data type, e.g. float64 or uint8, so it is designed to be flexible to the end-user use cases. I have run into an issue with the sequencing scheme, where genes are separated by separator []T: in the case of an empty final gene, sequencing results in an anomalous separator that should not be there, which can cause desequencing to parse it as a separate allele or a gene containing just the separator. There are two ways to deal with it: the first way is to ignore empty genetic structs and exclude them during sequencing, but this may delete structural information that is useful, e.g. in the case of saving intermediate genomes including genetic drift during a simulation/optimization; the second way is to introduce a placeholder sequence to identify empty structures. The latter is what I wish to do.

I would like for this placeholder sequence to be generated automatically from the separator by flipping the bits of each base in the separator []T, and I can use the "reflect" package to detect which type is being used. However, I cannot return []int when the function return signature is []T. I can do something like the following, but I am unsure if it is good practice.

func inverseSeparator[T comparable](separator []T) []T {
	result := []T
	switch reflect.TypeOf(separator[0]).Kind() {
	case reflect.Int:
		var v interface{}
		for i := 0; i < len(separator); i++ {
			// do the bit flip
			v = resultOfBitFlip 
			result = append(result, v.(T))
		}
	// other cases
	}
	return result
}

What is the best way to go about converting the result of the bit flipping back to a slice of T, or is this a bad approach?

• I think a good optimization for the attached code is the following, it provides a basic error-handling mechanism:

func inverseSeparator[T comparable](separator []T) ([]T, error) {
    switch separator[0].(type) {
    case int:
        var result []T
        for _, val := range separator {
            // Perform bit flip
            // Make sure T is a valid numeric type (int, uint, etc.) before flipping bits
            if n, ok := val.(int); ok {
                // Perform bit flipping for integers
                flipped := ^n
                result = append(result, T(flipped).(T))
            } else {
                // Return an error if the type is not supported for bit flipping
                return nil, fmt.Errorf("unsupported type for bit flipping: %T", val)
            }
        }
        return result, nil
    // Handle other cases for different types, if needed.
    default:
        return nil, fmt.Errorf("unsupported type for inverseSeparator: %T", separator[0])
    }
}