Golang SQL rows.Scan function for all fields of generic type

This is a poor use case for generics.

The arguments to the function sql.Rows.Scan are supposed to be the scan destinations, i.e. your struct fields, one for each column in the result set, and within the generic function body you do not have access to the fields of R type parameter.

Even if you did, the structs in your Result constraint likely have different fields...? So how do you envision writing generic code that works with different fields?

You might accomplish what you want with a package that provides arbitrary struct scanning like sqlx with facilities like StructScan, but that uses reflection under the hood to map the struct fields into sql.Rows.Scan arguments, so you are not getting any benefit at all with generics.

If anything, you are making it worse, because now you have the additional performance overheads of using type parameters.

Another answer shows how to create a map of types as asked in the question. You don't actually need a map of types.

For each type, you need a function to create a pointer to a new value and a function to deference the pointer. Let's declare an interface for the required functionality:

type FieldTyper interface {
    // Return pointer to new value.
    New() (ptr any)
    // Dereference pointer.
    Deref(ptr any) (val any)
}

Create a generic implementation of that interface:

type FieldType[T any] struct{}

func (v FieldType[T]) New() any {
    return new(T)
}

func (v FieldType[T]) Deref(p any) any {
    return *p.(*T)
}

Create a map of column names to FieldTypers:

var fieldTypes = map[string]FieldTyper{
    "id":   FieldType[Type_int]{},
    "name": FieldType[Type_string]{},
}

Use the field typers to setup the scan args and deference those args and add to map.

func SetupScanArgs(columnNames []string, fieldTypes map[string]FieldTyper) []any {
    args := make([]any, len(columnNames))
    for i, n := range columnNames {
        args[i] = fieldTypes[n].New()
    }
    return args
}

func ArgsToValueMap(columnNames []string, fieldTypes map[string]FieldTyper, args []any) map[string]any {
    result := make(map[string]any)
    for i, n := range columnNames {
        result[n] = fieldTypes[n].Deref(args[i])
    }
    return result
}

Scan like this:

args := SetupScanArgs(columnNames, fieldTypes)
if err := rows.Scan(args...); err != nil {
    return err
}
m := ArgsToValueMap(columnNames, fieldTypes, args)

Use the reflect package:

func scan(rows *sql.Rows, types map[string]reflect.Type) (map[string]any, error) {
    names, _ := rows.Columns()
    ptrs := make([]any, len(names))
    vals := make([]reflect.Value, len(names))
    for i, n := range names {
        vals[i] = reflect.New(types[n])
        ptrs[i] = vals[i].Interface()
    }
    if err := rows.Scan(ptrs...); err != nil {
        return nil, err
    }
    result := make(map[string]any)
    for i, v := range vals {
        result[names[i]] = v.Elem().Interface()
    }
    return result, nil
}

where types is something like this:

types = map[string]reflect.Type{
   "id": reflect.TypeOf(Type_int(0)),
   "name": reflect.TypeOf(Type_string("")),
}