Go is a language designed to improve development efficiency. Its concise syntax and efficient running speed make it the first choice for many developers. However, Go has been criticized for generics because it is relatively backward in this regard. However, in Go 1.18, generics have been officially introduced and have become an important feature in the Go language. This article will introduce in detail the relevant concepts, syntax and usage of Go generics, hoping to help everyone better understand and apply this feature.
1. Overview
1.1 What is a generic
Generics is a programming idea that allows the use of unknown types when writing code. Generics can increase code flexibility and reusability, while also improving code security and readability. Generics have been widely used in languages such as C++, Java and Python, but have not been supported in Go.
1.2 Background of Go generics
In Go, due to the lack of generics, developers need to write a corresponding version for each type, which leads to increased code redundancy and maintenance costs. At the same time, this also makes it impossible to implement some common algorithms and data structures. Therefore, the Go community has been calling for the addition of generic features. After years of waiting and exploration, Go version 1.18 finally added a generic feature, and the introduction of this feature is considered a major event in the history of the Go language.
1.3 Features of Go generics
The features of Go generics include:
- Generics based on type constraints: Go generics implement generics through type constraints, which means that generic functions or types can accept specific types.
- Compile-time type safety: Go generics ensure type safety through compile-time type checking, which helps avoid runtime errors.
- Supports multiple types: Go generics support multiple types, including basic types and custom types.
2. Syntax
In Golang, the syntax of generics includes type parameters, type constraints, generic functions, and generic types.
2.1 Generic Functions
In Go, the syntax of a generic function is as follows:
func FuncName[T Type](params) returnType {
// Function body
}Among them, T represents the generic type parameter, Type represents the specific type, params represents the parameter of the function, and returnType represents the return value type of the function.
For example, here is a simple generic function that can take any type of parameters and return a slice:
func toSlice[T any](args ...T) []T {
return args
}In this example, T represents any type, args represents an indefinite parameter, and the function returns a slice composed of indefinite parameters. When a function is called, any type of parameter can be passed, for example:
strings := toSlice("hello", "world") // Return []string{"hello", "world"} nums := toSlice(1, 2, 3) // return []int{1, 2, 3}2.2 Generic Types
In addition to generic functions, Go version 1.18 also introduces generic types. The syntax of generic types is as follows:
type TypeName[T Type] struct {
// Fields
}Among them, TypeName represents the generic type name, T represents the generic type parameter, and Type represents the specific type.
For example, here is a definition of a generic stack type that can store any type of data:
type Stack[T any] struct {
data []T
}
func (s *Stack[T]) Push(x T) {
= append(, x)
}
func (s *Stack[T]) Pop() T {
n := len()
x := [n-1]
= [:n-1]
return x
}In this example, T represents any type, data is a slice that stores the generic type parameter T, the Push method can add elements to the stack, and the Pop method can pop and return to the top element of the stack.
When using generic types, you need to specify a specific type, for example:
s := Stack[int]{}
(1)
(2)
x := () // return 2In this example, we create a stack that stores the integer type and add two elements to it. Then we pop up the top element of the stack and assign it to the variable x.
2.3 Generic Constraints
When using generics, sometimes certain constraints are required on the generic types. For example, we want a generic function or type to accept only a specific type of parameters, or a specific type of parameters must implement an interface. In Go, generic constraints can be used to implement these requirements.
2.3.1 Type constraints
Type constraints allow generic functions or types to accept only parameters of a specific type. In Go, type constraints can be implemented using interface{} type and type assertions. For example, the following is a generic function that can accept types that implement the interface:
func Print[T ](x T) {
(())
}In this example, T represents any type of the interface. The function accepts a parameter of type T and calls its String() method to output its string representation.
2.3.2 Constraint Syntax
Type constraints can be implemented using a type parameter with a constraint type. For example, the following is a generic function that can accept types that implement and interfaces:
func Print[T , U ](x T, y U) {
(())
_, _ = (, y)
}In this example, T and U represent any type that implements the interface and , respectively. The function takes a parameter of type T and a parameter of type U, and calls their methods to output its string representation and read data.
2.3.3 Interface Constraints
In addition to using the interface{} type for type constraints, Go also supports using interfaces to constrain generic types. For example, the following is a generic type that requires its generic type parameters to implement the interface:
type MyType[T ] struct {
data T
}
func (m *MyType[T]) String() string {
return ()
}In this example, T represents any type that implements the interface. The type MyType[T] saves the value of the generic type parameter T, and implements the String() method of the interface.
2.4 Generic Specialization
Generic specialization refers to converting generic code into specific types of code. In Go, generic specialization is done during compilation. Specialization can improve the performance and running efficiency of the code, because the compiler can optimize for specific types, avoiding type checking and type conversion at runtime.
In Go, generic specialization is implemented through a code generator. The code generator will generate code for specific types or functions based on the definition of a generic type or function. For example, the following is a generic function definition:
func Swap[T any](a, b *T) {
*a, *b = *b, *a
}This function can swap the values of two variables of any type. During compilation, the code generator generates specific function code based on the type of parameter passed when the function is called. For example, if you are passing a pointer of type integer, the code generator generates the following code:
func Swap_int(a, b *int) {
*a, *b = *b, *a
}If you are passing a pointer of string type, the code generator will generate the following code:
func Swap_string(a, b *string) {
*a, *b = *b, *a
}2.5 Generic Interface
A generic interface is an interface that can handle multiple types of data. In Golang, you can use type parameters to implement generic interfaces.
For example:
type Container[T any] interface {
Len() int
Add(T)
Remove() T
}In the above code, the Container interface uses the type parameter T to represent the element type that can be stored. This interface contains three methods, which are used to return the number of elements, add elements and remove elements.
2.5.1 Generic interface constraints
Generic interface constraints are used to limit the scope of types that implement generic interfaces, ensuring that generic code can only be used for types that meet certain conditions. In Golang, generic interface constraints are defined using interfaces.
For example:
type Stringer interface {
String() string
}
type Container[T Stringer] interface {
Len() int
Add(T)
Remove() T
}In the above code, the Container interface is limited to only storing types that implement the Stringer interface.
3. Common scenarios for generics
Golang generics can be applied to various data structures and algorithms, such as sorting, searching, mapping, etc. Below we use these scenarios as examples to demonstrate the use of Golang generics.
3.1 Sort
In Golang, you can sort slices of any type using the sort package. To support generic sorting, we can define a generic function Sort[T comparable] as shown below:
func Sort[T comparable](s []T) {
(s, func(i, j int) bool {
return s[i] < s[j]
})
}In the above code, the Sort function uses the type parameter T and constrains it, requiring T to implement the comparable interface. This ensures that the Sort function only accepts type parameters that implement the comparable interface. Use the function to sort slices.
Here is a sample code for sorting integer slices using the Sort function:
func main() {
numbers := []int{3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}
Sort(numbers)
(numbers)
}The output result is:
[1 1 2 3 3 4 5 5 5 6 9]
3.2 Search
In Golang, you can search for any type of slice using the search package. To support generic search, we can define a generic function Search[T comparable] as shown below:
func Search[T comparable](s []T, x T) int {
return (len(s), func(i int) bool {
return s[i] >= x
})
}In the above code, the Search function uses the type parameter T and constrains it, requiring T to implement the comparable interface. This ensures that the Search function only accepts type parameters that implement the comparable interface. Use the function to search for slices.
Here is a sample code for finding a value in an integer slice using the Search function:
func main() {
numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
x := 5
index := Search(numbers, x)
(index)
}The output result is:
4
3.3 Mapping
In Golang, maps can be implemented using the map type. To support generic mapping, we can define a generic function Map[K comparable, V any] as follows:
func Map[K comparable, V any](s []K, f func(K) V) map[K]V {
result := make(map[K]V)
for _, k := range s {
result[k] = f(k)
}
return result
}In the above code, the Map function uses the type parameters K and V, where K requires the implementation of the comparable interface, and V has no restrictions. Use the make function to create an empty map object, then loop through the slice using the for loop, map each element with the function f, and save the result in the map object.
Here is a sample code to convert each string in a string slice into capital letters using the Map function:
func main() {
words := []string{"apple", "banana", "cherry", "durian", "elderberry", "fig"}
uppercased := Map(words, func(word string) string {
return (word)
})
(uppercased)
}The output result is:
map[APPLE:APPLE BANANA:BANANA CHERRY:CHERRY DURIAN:DURIAN ELDERBERRY:ELDERBERRY FIG:FIG]
In the above code, we use the function to convert the string to uppercase letters and use the Map function to convert all strings to uppercase letters. Finally, the map object is printed, where the key is the original string and the value is the converted string.
The above is an example of using Golang generics to implement sorting, searching, and mapping. These scenarios are only part of the application of Golang generics, which can also be applied to more scenarios, such as collections, trees, graphs and other data structures. No matter what scenario, using Golang generics can make the code more concise and clear, and reduce the repetition of the code.
4. Summary
This article introduces generic mechanisms in the Go language, including generic functions, generic types, generic constraints, and generic specialization. The generic mechanism introduced in Go 1.18 can help everyone write more general and flexible code, and can also improve the readability and maintainability of the code.
When using generics, we need to pay attention to the following points:
- Use constraint types as much as possible to ensure type safety and readability of generic code.
- When using interface constraints, you should use smaller interfaces as much as possible to avoid unnecessary constraints.
- Pay attention to the initialization and operation of generic types to avoid type mismatch.
- When using generics, you should follow Go conventions and best practices to ensure the readability and maintainability of your code.
In addition to the above precautions, we also need to pay attention to the following points:
- When using generics, you should avoid using too many type parameters as much as possible to ensure the simplicity and readability of the code.
- When defining generic types, recursive type definitions should be avoided to avoid circular dependencies.
- When using generics, excessive abstraction should be avoided to avoid the complexity and readability of the code.
In short, generics are a very powerful language feature that can help us write more general and flexible code. When using generics, we need to pay attention to the above things to ensure the readability, maintainability and performance of the code. At the same time, we also need to pay attention to the usage scenarios of generics, avoid abuse of generics, and increase the complexity and readability of the code.
The above is a detailed article that will give you a deep understanding of generics in Golang. For more information about generics in Golang, please pay attention to my other related articles!