Basic + Slice + Map Type Compatible Generics?

Is there a way to create a generic function that can adjust its operation when passed a map or a slice type vs a basic type?

Goal

Create a slice reading function generator with a flexible return type:

func ValueReader[T <probably something fancy>](i int) func ([]ProtoConvertable) T {
	return func (row []ProtoConvertable) T {
		return ...
	}
}

row := []ProtoConvertable{
	&Data[int]{Value: 333},
	&ListData{Values: []ProtoConvertable{
		&Data[string]{Value: "hello"},
		&Data[string]{Value: "world"},
	}},
	&MapData{Values: map[ProtoConvertable]ProtoConvertable{
		&Data[int]{Value: 22}: &Data[string]{Value: "world"},
		&Data[int]{Value: 11}: &Data[string]{Value: "hello"},
	}},
}

dataReader := ValueReader[int](0) // A function that converts the first element to an int
listDataReader := ValueReader[[]string](1) // A function that converts the second element to a slice
mapDataReader := ValueReader[map[int]string](2) // A function that converts the third element to a map

data := dataReader(row) // 333
listData := listDataReader(row) // []string{"hello", "world"}
mapData := mapDataReader(row) // map[int]string{11: "hello", 22: "world"}

Types

type ValueType interface {
	int | string
}

type ProtoConvertable interface {
	ToProto() *pb.GenericMessage
}

type Data[T ValueType] struct {
	Value T
}

func (d *Data) ToProto() *pb.GenericMessage{
	...
}

type ListData struct {
	Values []ProtoConvertable
}

func (d *ListData) ToProto() *pb.GenericMessage {
	...
}

type MapData struct {
	Values map[ProtoConvertable]ProtoConvertable
}

func (d *MapData) ToProto() *pb.GenericMessage {
	...
}

Current Solution

func ValueReader[T ValueType](i int) func([]ProtoConvertable) T {
	return func(row []ProtoConvertable) T {
		return row[i].(*Data[T]).Value
	}
}

func ListValueReader[T ValueType](i int) func([]ProtoConvertable) []T {
	return func(row []ProtoConvertable) []T {
		vs := row[i].(*ListData).Values
		res := make([]T, len(vs))
		for i, v := range vs {
			res[i] = v.(*Data[T]).Value
		}
		return res
	}
}

func MapValueReader[K ValueType, V ValueType](i int) func([]ProtoConvertable) map[K]V {
	return func(row []ProtoConvertable) map[K]V {
		vs := row[i].(*MapData).Values
		res := make(map[K]V, len(vs))
		for k, v := range vs {
			res[k.(*Data[K]).Value] = v.(*Data[V]).Value
		}
		return res
	}
}

dataReader := ValueReader[int](0)
listDataReader := ListValueReader[string](1)
mapDataReader := MapValueReader[int, string](2)

Note: all of this code is an untested simplification of a more complicated library. It might need some tweaking to get to actually work.

The <probably something fancy> doesn't exist.

The main issue is that you want to model a type parameter that matches a base value and two composite types, one of which is a map type where you want to capture both K and V.

Even if it existed, the body of ValueReader would be a type-switch on T to return each specialized reader function, so your existing solution that involves a small amount of code duplication seems just a better strategy overall.

My advice is to use generics when the operations on the different concrete types of T are really identical. You can read more at: https://go.dev/blog/when-generics