generic function to convert Map to List in GO

How can I write a function in Go that would convert any Map to a List of object (dropping the keys) ?

For instance:

func mapToList(inputMap map[any]any) any {
    var resultList []any 
    for _, obj := range inputMap {
        resultList = append(resultList, obj)
    }
    return resultList
}

func main() {
	myMap := make(map[string]string)
	myMap["a"] = "1"
	myMap["b"] = "12"
	l := mapToList(myMap).([]string)
    fmt.Printf("(%v, %T)\n", l, l)
}

would output: ([1 12], []string)

But I always run into a type issue and didn't find a way around. Using type assertion or conversion I run into the similar issue.

cannot use myMap (variable of type map[string]string) as map[any]any value in argument to mapToList

How should I write the mapToList() function ?

It must take as an input inputMap map[any]any or inputMap any because I want to pass in any kind of map (map[string]CustomStruct; map[int][]CustomStruct, etc.)

Update: I added the function as I first write it and more more details on the input

See this tutorial on Generics or the language spec

any is not the variable type, it is a type constraint, a description of the types that can be used. You need to define the type parameters with the constraint any, and then reference the generic types from within the parameter signatures.

//                                 | from this point on, K and V are
//                                 | now valid types to use in the function
func mapToSlice[K comparable, V any](m map[K]V) []V {
	s := make([]V, 0, len(m))
	for _, v := range m {
		s = append(s, v)
	}
	return s
}

The parameter m must be map[K]V, where K is a comparable type and V is any type. The return type []V will be a slice of the same type used for the values in the input map.

Note that any can't be used as the constraint for the keys of the map, since not all types can be used as keys, only comparable types.

Then to call the method, you pass in a type that satisfies the constraints (eg map[string][]string), optionally making explicit the type parameters.

m := map[string][]string{
	"A": {"B", "C"},
	"D": {"E", "F"},
}
s := mapToSlice(m)
// or
t := mapToSlice[string, []string](m)
// [[B C] [E F]]

By making the type explicit, you can self-document your code and also catch any accidental type issues. For example, the following code will return an error:

v := mapToSlice[string, []int](m)
...
./main.go:14:33: cannot use m (variable of type map[string][]string) as map[string][]int value in argument to mapToSlice[string, []int]