What are the specific impacts of Golang generics on functions?

Generics were introduced in Go 1.18, with the following specific effects on functions: Generic functions: can run on different types without creating specific versions. Type inference: The compiler can automatically infer type parameter types. Performance improvements: Improve performance by eliminating type conversions. Interface replacement: In simple scenarios, generic functions can replace interfaces. Practical case: Generic functions can be used to calculate the maximum value in a list, which is both flexible and efficient.

The specific impact of generics in Go on functions

Generics are an important feature introduced in Go 1.18. It allows us to create code that runs on various types. In the context of functions, generics bring the following specific effects:

• Universal functions:We can define generic functions that work on different types, and No need to create multiple type-specific versions. For example:

// 计算列表中的最大值
func Max[T comparable](list []T) T {
    max := list[0]
    for _, v := range list {
        if v > max {
            max = v
        }
    }
    return max
}

• Type inference: The compiler can automatically infer the types of type parameters in generic functions. This means that you usually don't need to explicitly specify type parameters when calling a function. For example:

nums := []int{1, 2, 3, 4, 5}
result := Max(nums)

• Performance improvements: Generic functions can improve performance by eliminating type conversions. Before generics, explicit type conversion was required to use functions on different types. For example:

// 使用泛型之前
nums := []int{1, 2, 3, 4, 5}
max := MaxInt(nums)

// 使用泛型之后
nums := []int{1, 2, 3, 4, 5}
max := Max(nums)

• Interface replacement: Generics can replace interfaces in certain situations. For simple scenarios, generic functions can eliminate the need to create and implement interfaces. For example:

// 使用接口之前
type Comparable interface {
    CompareTo(other Comparable) int
}

// 使用泛型之后
func Max[T comparable](list []T) T {
    max := list[0]
    for _, v := range list {
        if v > max {
            max = v
        }
    }
    return max
}

Practical case:

Consider a function that needs to calculate the maximum value in a list. Before generics, we needed to create multiple specific versions for different types:

func MaxInt(list []int) int
func MaxFloat64(list []float64) float64
func MaxString(list []string) string

However, with generics, we only need a common Max function:

func Max[T comparable](list []T) T

This makes our code both flexible and efficient.

The above is the detailed content of What are the specific impacts of Golang generics on functions?. For more information, please follow other related articles on the PHP Chinese website!