Home > Article > Backend Development > How do generic functions interact with existing non-generic functions in Golang?
In Go, generic functions can interact with non-generic code by using type assertions, type aliases, or empty interfaces. Type assertions allow values to be converted to specific types; type aliases create generic aliases of existing types; and empty interfaces can represent variables of any type. Through these methods, generic functions can accept or return values of non-generic types, enabling data processing across different types.
How to make generic functions interact with non-generic functions in Go
Go Generics have been introduced since Go 1.18 , opens the door to reusing type and algorithm code. But how does new generic code interact with existing, non-generic code?
Using type assertions
Type assertions provide a way to convert an interface into a value of a specific type. This can be done using a switch statement:
func AnyToString(any interface{}) string { switch myString := any.(type) { case string: return myString default: return "Unknown" } }
This function attempts to convert an arbitrary value to a string, returning "Unknown" if it is not a string.
Using type aliases
Type aliases allow you to create aliases for existing types. This allows us to create a generic alias for a non-generic type:
type MyString string func GenericFunc[T MyString](t T) {}
Now, we can use the non-generic type MyString
in a generic function GenericFunc
:
GenericFunc(MyString("Hello"))
Use empty interface
The empty interface can represent any type of variable. This allows us to create generic functions that accept or return any type of value:
func GenericEmptyInterfaceFunc(empty interface{}) {}
We can call this function with any type of value:
GenericEmptyInterfaceFunc(10) GenericEmptyInterfaceFunc("Hello")
Practical example: Implementing generic sorting
Let's demonstrate the interaction of generic code with non-generic code by sorting a list.
// Sort is a generic function that sorts a slice of any type that implements sort.Interface. func Sort[T sort.Interface](s []T) { sort.Sort(s) } // IntSlice implements sort.Interface for a slice of int. type IntSlice []int func (s IntSlice) Len() int { return len(s) } func (s IntSlice) Less(i, j int) bool { return s[i] < s[j] } func (s IntSlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] } // StringSlice implements sort.Interface for a slice of string. type StringSlice []string func (s StringSlice) Len() int { return len(s) } func (s StringSlice) Less(i, j int) bool { return s[i] < s[j] } func (s StringSlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] } func main() { intSlice := IntSlice{10, 5, 7, 3, 11} Sort(intSlice) fmt.Println(intSlice) // Output: [3 5 7 10 11] stringSlice := StringSlice{"Hello", "World", "Go", "Golang"} Sort(stringSlice) fmt.Println(stringSlice) // Output: [Go Golang Hello World] }
This code demonstrates how to use the generic function Sort
to sort different lists of values based on a custom type.
The above is the detailed content of How do generic functions interact with existing non-generic functions in Golang?. For more information, please follow other related articles on the PHP Chinese website!